src/mojo/services/html_viewer/weburlloader_impl.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "mojo/services/html_viewer/weburlloader_impl.h"
   6
   7 #include "base/bind.h"
   8 #include "base/logging.h"
   9 #include "base/thread_task_runner_handle.h"
  10 #include "mojo/common/common_type_converters.h"
  11 #include "mojo/services/html_viewer/blink_url_request_type_converters.h"
  12 #include "mojo/services/public/interfaces/network/network_service.mojom.h"
  13 #include "net/base/net_errors.h"
  14 #include "third_party/WebKit/public/platform/WebURLError.h"
  15 #include "third_party/WebKit/public/platform/WebURLLoadTiming.h"
  16 #include "third_party/WebKit/public/platform/WebURLLoaderClient.h"
  17 #include "third_party/WebKit/public/platform/WebURLResponse.h"
  18
  19 namespace mojo {
  20 namespace {
  21
  22 blink::WebURLResponse ToWebURLResponse(const URLResponsePtr& url_response) {
  23   blink::WebURLResponse result;
  24   result.initialize();
  25   result.setURL(GURL(url_response->url));
  26   result.setMIMEType(blink::WebString::fromUTF8(url_response->mime_type));
  27   result.setTextEncodingName(blink::WebString::fromUTF8(url_response->charset));
  28   result.setHTTPStatusCode(url_response->status_code);
  29
  30   // TODO(darin): Initialize timing properly.
  31   blink::WebURLLoadTiming timing;
  32   timing.initialize();
  33   result.setLoadTiming(timing);
  34
  35   // TODO(darin): Copy other fields.
  36   return result;
  37 }
  38
  39 }  // namespace
  40
  41 WebURLRequestExtraData::WebURLRequestExtraData() {
  42 }
  43
  44 WebURLRequestExtraData::~WebURLRequestExtraData() {
  45 }
  46
  47 WebURLLoaderImpl::WebURLLoaderImpl(NetworkService* network_service)
  48     : client_(NULL),
  49       weak_factory_(this) {
  50   network_service->CreateURLLoader(Get(&url_loader_));
  51 }
  52
  53 WebURLLoaderImpl::~WebURLLoaderImpl() {
  54 }
  55
  56 void WebURLLoaderImpl::loadSynchronously(
  57     const blink::WebURLRequest& request,
  58     blink::WebURLResponse& response,
  59     blink::WebURLError& error,
  60     blink::WebData& data) {
  61   NOTIMPLEMENTED();
  62 }
  63
  64 void WebURLLoaderImpl::loadAsynchronously(const blink::WebURLRequest& request,
  65                                           blink::WebURLLoaderClient* client) {
  66   client_ = client;
  67   url_ = request.url();
  68
  69   URLRequestPtr url_request = URLRequest::From(request);
  70   url_request->auto_follow_redirects = false;
  71
  72   if (request.extraData()) {
  73     WebURLRequestExtraData* extra_data =
  74         static_cast<WebURLRequestExtraData*>(request.extraData());
  75     base::ThreadTaskRunnerHandle::Get()->PostTask(
  76         FROM_HERE,
  77         base::Bind(&WebURLLoaderImpl::OnReceivedResponse,
  78                    weak_factory_.GetWeakPtr(),
  79                    base::Passed(&extra_data->synthetic_response)));
  80   } else {
  81     url_loader_->Start(url_request.Pass(),
  82                        base::Bind(&WebURLLoaderImpl::OnReceivedResponse,
  83                                   weak_factory_.GetWeakPtr()));
  84   }
  85 }
  86
  87 void WebURLLoaderImpl::cancel() {
  88   url_loader_.reset();
  89   response_body_stream_.reset();
  90
  91   URLResponsePtr failed_response(URLResponse::New());
  92   failed_response->url = String::From(url_);
  93   failed_response->error = NetworkError::New();
  94   failed_response->error->code = net::ERR_ABORTED;
  95
  96   base::ThreadTaskRunnerHandle::Get()->PostTask(
  97       FROM_HERE,
  98       base::Bind(&WebURLLoaderImpl::OnReceivedResponse,
  99                  weak_factory_.GetWeakPtr(),
 100                  base::Passed(&failed_response)));
 101 }
 102
 103 void WebURLLoaderImpl::setDefersLoading(bool defers_loading) {
 104   NOTIMPLEMENTED();
 105 }
 106
 107 void WebURLLoaderImpl::OnReceivedResponse(URLResponsePtr url_response) {
 108   url_ = GURL(url_response->url);
 109
 110   if (url_response->error) {
 111     OnReceivedError(url_response.Pass());
 112   } else if (url_response->redirect_url) {
 113     OnReceivedRedirect(url_response.Pass());
 114   } else {
 115     base::WeakPtr<WebURLLoaderImpl> self(weak_factory_.GetWeakPtr());
 116     client_->didReceiveResponse(this, ToWebURLResponse(url_response));
 117
 118     // We may have been deleted during didReceiveResponse.
 119     if (!self)
 120       return;
 121
 122     // Start streaming data
 123     response_body_stream_ = url_response->body.Pass();
 124     ReadMore();
 125   }
 126 }
 127
 128 void WebURLLoaderImpl::OnReceivedError(URLResponsePtr url_response) {
 129   blink::WebURLError web_error;
 130   web_error.domain = blink::WebString::fromUTF8(net::kErrorDomain);
 131   web_error.reason = url_response->error->code;
 132   web_error.unreachableURL = GURL(url_response->url);
 133   web_error.staleCopyInCache = false;
 134   web_error.isCancellation =
 135       url_response->error->code == net::ERR_ABORTED ? true : false;
 136
 137   client_->didFail(this, web_error);
 138 }
 139
 140 void WebURLLoaderImpl::OnReceivedRedirect(URLResponsePtr url_response) {
 141   blink::WebURLRequest new_request;
 142   new_request.initialize();
 143   new_request.setURL(GURL(url_response->redirect_url));
 144   new_request.setHTTPMethod(
 145       blink::WebString::fromUTF8(url_response->redirect_method));
 146
 147   client_->willSendRequest(this, new_request, ToWebURLResponse(url_response));
 148   // TODO(darin): Check if new_request was rejected.
 149
 150   url_loader_->FollowRedirect(
 151       base::Bind(&WebURLLoaderImpl::OnReceivedResponse,
 152                  weak_factory_.GetWeakPtr()));
 153 }
 154
 155 void WebURLLoaderImpl::ReadMore() {
 156   const void* buf;
 157   uint32_t buf_size;
 158   MojoResult rv = BeginReadDataRaw(response_body_stream_.get(),
 159                                    &buf,
 160                                    &buf_size,
 161                                    MOJO_READ_DATA_FLAG_NONE);
 162   if (rv == MOJO_RESULT_OK) {
 163     client_->didReceiveData(this, static_cast<const char*>(buf), buf_size, -1);
 164     EndReadDataRaw(response_body_stream_.get(), buf_size);
 165     WaitToReadMore();
 166   } else if (rv == MOJO_RESULT_SHOULD_WAIT) {
 167     WaitToReadMore();
 168   } else if (rv == MOJO_RESULT_FAILED_PRECONDITION) {
 169     // We reached end-of-file.
 170     double finish_time = base::Time::Now().ToDoubleT();
 171     client_->didFinishLoading(
 172         this,
 173         finish_time,
 174         blink::WebURLLoaderClient::kUnknownEncodedDataLength);
 175   } else {
 176     // TODO(darin): Oops!
 177   }
 178 }
 179
 180 void WebURLLoaderImpl::WaitToReadMore() {
 181   handle_watcher_.Start(
 182       response_body_stream_.get(),
 183       MOJO_HANDLE_SIGNAL_READABLE,
 184       MOJO_DEADLINE_INDEFINITE,
 185       base::Bind(&WebURLLoaderImpl::OnResponseBodyStreamReady,
 186                  weak_factory_.GetWeakPtr()));
 187 }
 188
 189 void WebURLLoaderImpl::OnResponseBodyStreamReady(MojoResult result) {
 190   ReadMore();
 191 }
 192
 193 }  // namespace mojo