electron/atom/browser/net/url_request_fetch_job.cc

// Copyright (c) 2015 GitHub, Inc.
// Use of this source code is governed by the MIT license that can be
// found in the LICENSE file.

#include "atom/browser/net/url_request_fetch_job.h"

#include <algorithm>
#include <string>

#include "atom/browser/api/atom_api_session.h"
#include "atom/browser/atom_browser_context.h"
#include "base/guid.h"
#include "base/memory/ptr_util.h"
#include "base/strings/string_util.h"
#include "brightray/browser/url_request_context_getter.h"
#include "content/browser/streams/stream_context.h"
#include "native_mate/dictionary.h"
#include "net/base/io_buffer.h"
#include "net/base/net_errors.h"
#include "net/http/http_response_headers.h"
#include "net/url_request/url_fetcher.h"
#include "net/url_request/url_fetcher_response_writer.h"
#include "url/url_constants.h"

using content::BrowserThread;

namespace atom {

namespace {

// Convert string to RequestType.
net::URLFetcher::RequestType GetRequestType(const std::string& raw) {
  std::string method = base::ToUpperASCII(raw);
  if (method.empty() || method == "GET")
    return net::URLFetcher::GET;
  else if (method == "POST")
    return net::URLFetcher::POST;
  else if (method == "HEAD")
    return net::URLFetcher::HEAD;
  else if (method == "DELETE")
    return net::URLFetcher::DELETE_REQUEST;
  else if (method == "PUT")
    return net::URLFetcher::PUT;
  else if (method == "PATCH")
    return net::URLFetcher::PATCH;
  else  // Use "GET" as fallback.
    return net::URLFetcher::GET;
}

// Pipe the response writer back to URLRequestFetchJob.
class ResponsePiper : public net::URLFetcherResponseWriter {
 public:
  explicit ResponsePiper(URLRequestFetchJob* job)
      : first_write_(true), job_(job) {}

  // net::URLFetcherResponseWriter:
  int Initialize(const net::CompletionCallback& callback) override {
    return net::OK;
  }
  int Write(net::IOBuffer* buffer,
            int num_bytes,
            const net::CompletionCallback& callback) override {
    if (first_write_) {
      // The URLFetcherResponseWriter doesn't have an event when headers have
      // been read, so we have to emulate by hooking to first write event.
      job_->HeadersCompleted();
      first_write_ = false;
    }
    job_->stream()->AddData(buffer->data(), num_bytes);
    return num_bytes;
  }
  int Finish(int net_error, const net::CompletionCallback& callback) override {
    return net::OK;
  }

 private:
  bool first_write_;
  URLRequestFetchJob* job_;

  DISALLOW_COPY_AND_ASSIGN(ResponsePiper);
};

}  // namespace

URLRequestFetchJob::URLRequestFetchJob(net::URLRequest* request,
                                       net::NetworkDelegate* network_delegate)
    : JsAsker<net::URLRequestJob>(request, network_delegate),
      pending_buffer_size_(0),
      total_bytes_read_(0) {}

void URLRequestFetchJob::BeforeStartInUI(
    v8::Isolate* isolate, v8::Local<v8::Value> value) {
  mate::Dictionary options;
  if (!mate::ConvertFromV8(isolate, value, &options))
    return;

  // When |session| is set to |null| we use a new request context for fetch job.
  v8::Local<v8::Value> val;
  if (options.Get("session", &val)) {
    if (val->IsNull()) {
      // We have to create the URLRequestContextGetter on UI thread.
      url_request_context_getter_ = new brightray::URLRequestContextGetter(
          this, nullptr, nullptr, base::FilePath(), true,
          BrowserThread::GetTaskRunnerForThread(BrowserThread::IO),
          BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE),
          nullptr, content::URLRequestInterceptorScopedVector());
    } else {
      mate::Handle<api::Session> session;
      if (mate::ConvertFromV8(isolate, val, &session) && !session.IsEmpty()) {
        AtomBrowserContext* browser_context = session->browser_context();
        url_request_context_getter_ =
            browser_context->url_request_context_getter();
      }
    }
  }
}

void URLRequestFetchJob::StartAsync(std::unique_ptr<base::Value> options) {
  if (!options->IsType(base::Value::Type::DICTIONARY)) {
    NotifyStartError(net::URLRequestStatus(
          net::URLRequestStatus::FAILED, net::ERR_NOT_IMPLEMENTED));
    return;
  }

  std::string url, method, referrer;
  base::DictionaryValue* upload_data = nullptr;
  base::DictionaryValue* dict =
      static_cast<base::DictionaryValue*>(options.get());
  dict->GetString("url", &url);
  dict->GetString("method", &method);
  dict->GetString("referrer", &referrer);
  dict->GetDictionary("uploadData", &upload_data);

  // Check if URL is valid.
  GURL formated_url(url);
  if (!formated_url.is_valid()) {
    NotifyStartError(net::URLRequestStatus(
          net::URLRequestStatus::FAILED, net::ERR_INVALID_URL));
    return;
  }

  // Use |request|'s method if |method| is not specified.
  net::URLFetcher::RequestType request_type;
  if (method.empty())
    request_type = GetRequestType(request()->method());
  else
    request_type = GetRequestType(method);

  fetcher_ = net::URLFetcher::Create(formated_url, request_type, this);
  fetcher_->SaveResponseWithWriter(base::WrapUnique(new ResponsePiper(this)));

  // A request context getter is passed by the user.
  if (url_request_context_getter_)
    fetcher_->SetRequestContext(url_request_context_getter_.get());
  else
    fetcher_->SetRequestContext(request_context_getter());

  // Use |request|'s referrer if |referrer| is not specified.
  if (referrer.empty())
    fetcher_->SetReferrer(request()->referrer());
  else
    fetcher_->SetReferrer(referrer);

  // Set the data needed for POSTs.
  if (upload_data && request_type == net::URLFetcher::POST) {
    std::string content_type, data;
    upload_data->GetString("contentType", &content_type);
    upload_data->GetString("data", &data);
    fetcher_->SetUploadData(content_type, data);
  }

  // Use |request|'s headers.
  fetcher_->SetExtraRequestHeaders(
      request()->extra_request_headers().ToString());

  // Create readable stream for URLFetcher response.
  content::StreamContext* stream_context =
      static_cast<brightray::URLRequestContextGetter*>(request_context_getter())
          ->stream_context();

  if (stream_context) {
    GURL stream_url(std::string(url::kBlobScheme) + ":" +
                    formated_url.GetOrigin().spec() + base::GenerateGUID());
    stream_ =
        new content::Stream(stream_context->registry(), nullptr, stream_url);
    stream_->SetReadObserver(this);
    fetcher_->Start();
  } else {
    NotifyStartError(net::URLRequestStatus(net::URLRequestStatus::CANCELED,
                                           net::ERR_ABORTED));
  }
}

void URLRequestFetchJob::HeadersCompleted() {
  response_info_.reset(new net::HttpResponseInfo);
  response_info_->headers = fetcher_->GetResponseHeaders();
  NotifyHeadersComplete();
}

void URLRequestFetchJob::Kill() {
  JsAsker<URLRequestJob>::Kill();
  ClearStream();
  fetcher_.reset();
}

void URLRequestFetchJob::OnDataAvailable(content::Stream* stream) {
  if (!pending_buffer_.get())
    return;

  int result = 0;
  auto state = stream_->ReadRawData(pending_buffer_.get(), pending_buffer_size_,
                                    &result);
  if (state == content::Stream::STREAM_ABORTED)
    result = net::ERR_CONNECTION_RESET;

  // Clear the buffers before notifying the read is complete, so that it is
  // safe for the observer to read.
  pending_buffer_ = nullptr;
  pending_buffer_size_ = 0;

  if (result > 0)
    total_bytes_read_ += result;
  ReadRawDataComplete(result);
}

int URLRequestFetchJob::ReadRawData(net::IOBuffer* dest, int dest_size) {
  if (GetResponseCode() == 204) {
    request()->set_received_response_content_length(prefilter_bytes_read());
    return net::OK;
  }

  int bytes_read = 0;
  switch (stream_->ReadRawData(dest, dest_size, &bytes_read)) {
    case content::Stream::STREAM_HAS_DATA:
      total_bytes_read_ += bytes_read;
      return bytes_read;
    case content::Stream::STREAM_COMPLETE:
      return stream_->GetStatus();
    case content::Stream::STREAM_EMPTY:
      pending_buffer_ = dest;
      pending_buffer_size_ = dest_size;
      return net::ERR_IO_PENDING;
    case content::Stream::STREAM_ABORTED:
      // Handle this as connection reset.
      return net::ERR_CONNECTION_RESET;
  }
  NOTREACHED();
  return net::ERR_FAILED;
}

bool URLRequestFetchJob::GetMimeType(std::string* mime_type) const {
  if (!response_info_ || !response_info_->headers)
    return false;

  return response_info_->headers->GetMimeType(mime_type);
}

void URLRequestFetchJob::GetResponseInfo(net::HttpResponseInfo* info) {
  if (response_info_)
    *info = *response_info_;
}

int URLRequestFetchJob::GetResponseCode() const {
  if (!response_info_ || !response_info_->headers)
    return -1;

  return response_info_->headers->response_code();
}

int64_t URLRequestFetchJob::GetTotalReceivedBytes() const {
  int64_t total_received_bytes = 0;
  if (response_info_)
    total_received_bytes = response_info_->headers->raw_headers().size();
  if (stream_.get())
    total_received_bytes += total_bytes_read_;
  return total_received_bytes;
}

void URLRequestFetchJob::OnURLFetchComplete(const net::URLFetcher* source) {
  auto status = fetcher_->GetStatus();
  if (status.is_success()) {
    if (!response_info_) {
      // Since we notify header completion only after first write there will be
      // no response object constructed for http respones with no content 204.
      // We notify header completion here.
      HeadersCompleted();
      return;
    }
    stream_->Finalize(0);
  } else {
    stream_->Finalize(status.error());
    NotifyStartError(status);
  }
}

void URLRequestFetchJob::ClearStream() {
  stream_->RemoveReadObserver(this);
  stream_ = nullptr;
}

}  // namespace atom