Revert of Remove webkit's ResourceLoaderBridge interface.

content/child/web_url_loader_impl.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+// An implementation of WebURLLoader in terms of ResourceLoaderBridge.
+
 #include "content/child/web_url_loader_impl.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "content/child/child_thread.h"
 #include "content/child/ftp_directory_listing_response_delegate.h"
 #include "content/child/request_extra_data.h"
 #include "content/child/request_info.h"
-#include "content/child/resource_dispatcher.h"
 #include "content/child/sync_load_response.h"
-#include "content/common/resource_messages.h"
 #include "content/common/resource_request_body.h"
 #include "content/public/child/request_peer.h"
 #include "net/base/data_url.h"
 #include "net/base/filename_util.h"
 #include "net/base/load_flags.h"
 #include "net/base/mime_util.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_util.h"
 #include "net/url_request/url_request.h"
 #include "third_party/WebKit/public/platform/WebHTTPHeaderVisitor.h"
 #include "third_party/WebKit/public/platform/WebHTTPLoadInfo.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebURLError.h"
 #include "third_party/WebKit/public/platform/WebURLLoadTiming.h"
 #include "third_party/WebKit/public/platform/WebURLLoaderClient.h"
 #include "third_party/WebKit/public/platform/WebURLRequest.h"
 #include "third_party/WebKit/public/platform/WebURLResponse.h"
 #include "third_party/WebKit/public/web/WebSecurityPolicy.h"
 #include "webkit/child/multipart_response_delegate.h"
+#include "webkit/child/resource_loader_bridge.h"
 #include "webkit/child/weburlresponse_extradata_impl.h"
 
 using base::Time;
 using base::TimeTicks;
 using blink::WebData;
 using blink::WebHTTPBody;
 using blink::WebHTTPHeaderVisitor;
 using blink::WebHTTPLoadInfo;
 using blink::WebReferrerPolicy;
 using blink::WebSecurityPolicy;
 using blink::WebString;
 using blink::WebURL;
 using blink::WebURLError;
 using blink::WebURLLoadTiming;
 using blink::WebURLLoader;
 using blink::WebURLLoaderClient;
 using blink::WebURLRequest;
 using blink::WebURLResponse;
 using webkit_glue::MultipartResponseDelegate;
 using webkit_glue::ResourceDevToolsInfo;
+using webkit_glue::ResourceLoaderBridge;
 using webkit_glue::ResourceResponseInfo;
 using webkit_glue::WebURLResponseExtraDataImpl;
 
 namespace content {
 
 // Utilities ------------------------------------------------------------------
 
 namespace {
 
 const char kThrottledErrorDescription[] =
@@ skipping 180 matching lines @@
   virtual void OnCompletedRequest(
       int error_code,
       bool was_ignored_by_handler,
       bool stale_copy_in_cache,
       const std::string& security_info,
       const base::TimeTicks& completion_time,
       int64 total_transfer_size) OVERRIDE;
 
  private:
   friend class base::RefCounted<Context>;
-  virtual ~Context();
+  virtual ~Context() {}
 
   // We can optimize the handling of data URLs in most cases.
   bool CanHandleDataURL(const GURL& url) const;
   void HandleDataURL();
 
   WebURLLoaderImpl* loader_;
   WebURLRequest request_;
   WebURLLoaderClient* client_;
   WebReferrerPolicy referrer_policy_;
+  scoped_ptr<ResourceLoaderBridge> bridge_;
   scoped_ptr<FtpDirectoryListingResponseDelegate> ftp_listing_delegate_;
   scoped_ptr<MultipartResponseDelegate> multipart_delegate_;
-  int request_id_;
+  scoped_ptr<ResourceLoaderBridge> completed_bridge_;
 };
 
 WebURLLoaderImpl::Context::Context(WebURLLoaderImpl* loader)
     : loader_(loader),
       client_(NULL),
-      referrer_policy_(blink::WebReferrerPolicyDefault),
-      request_id_(-1) {
+      referrer_policy_(blink::WebReferrerPolicyDefault) {
 }
 
 void WebURLLoaderImpl::Context::Cancel() {
-  if (ChildThread::current())  // NULL in unittest.
-    ChildThread::current()->resource_dispatcher()->Cancel(request_id_);
+  // The bridge will still send OnCompletedRequest, which will Release() us, so
+  // we don't do that here.
+  if (bridge_)
+    bridge_->Cancel();
 
   // Ensure that we do not notify the multipart delegate anymore as it has
   // its own pointer to the client.
   if (multipart_delegate_)
     multipart_delegate_->Cancel();
 
   // Do not make any further calls to the client.
   client_ = NULL;
   loader_ = NULL;
 }
 
 void WebURLLoaderImpl::Context::SetDefersLoading(bool value) {
-  ChildThread::current()->resource_dispatcher()->SetDefersLoading(request_id_,
-                                                                  value);
+  if (bridge_)
+    bridge_->SetDefersLoading(value);
 }
 
 void WebURLLoaderImpl::Context::DidChangePriority(
-    WebURLRequest::Priority new_priority,
-    int intra_priority_value) {
-  ChildThread::current()->resource_dispatcher()->DidChangePriority(
-      request_id_,
-      ConvertWebKitPriorityToNetPriority(new_priority),
-      intra_priority_value);
+    WebURLRequest::Priority new_priority, int intra_priority_value) {
+  if (bridge_)
+    bridge_->DidChangePriority(
+        ConvertWebKitPriorityToNetPriority(new_priority), intra_priority_value);
 }
 
 void WebURLLoaderImpl::Context::Start(const WebURLRequest& request,
                                       SyncLoadResponse* sync_load_response) {
+  DCHECK(!bridge_.get());
+
   request_ = request;  // Save the request.
 
   GURL url = request.url();
   if (url.SchemeIs("data") && CanHandleDataURL(url)) {
     if (sync_load_response) {
       // This is a sync load. Do the work now.
       sync_load_response->url = url;
       std::string data;
       GetInfoFromDataURL(sync_load_response->url, sync_load_response,
                          &sync_load_response->data,
@@ skipping 67 matching lines @@
       ResourceType::FromTargetType(request.targetType());
   request_info.priority =
       ConvertWebKitPriorityToNetPriority(request.priority());
   request_info.appcache_host_id = request.appCacheHostID();
   request_info.routing_id = request.requestorID();
   request_info.download_to_file = request.downloadToFile();
   request_info.has_user_gesture = request.hasUserGesture();
   request_info.extra_data = request.extraData();
   referrer_policy_ = request.referrerPolicy();
   request_info.referrer_policy = request.referrerPolicy();
-  ResourceDispatcher* dispatcher =
-      ChildThread::current()->resource_dispatcher();
-
-  scoped_refptr<ResourceRequestBody> request_body = new ResourceRequestBody;
+  bridge_.reset(ChildThread::current()->CreateBridge(request_info));
 
   if (!request.httpBody().isNull()) {
     // GET and HEAD requests shouldn't have http bodies.
     DCHECK(method != "GET" && method != "HEAD");
     const WebHTTPBody& httpBody = request.httpBody();
     size_t i = 0;
     WebHTTPBody::Element element;
+    scoped_refptr<ResourceRequestBody> request_body = new ResourceRequestBody;
     while (httpBody.elementAt(i++, element)) {
       switch (element.type) {
         case WebHTTPBody::Element::TypeData:
           if (!element.data.isEmpty()) {
             // WebKit sometimes gives up empty data to append. These aren't
             // necessary so we just optimize those out here.
             request_body->AppendBytes(
                 element.data.data(), static_cast<int>(element.data.size()));
           }
           break;
@@ skipping 21 matching lines @@
           break;
         }
         case WebHTTPBody::Element::TypeBlob:
           request_body->AppendBlob(element.blobUUID.utf8());
           break;
         default:
           NOTREACHED();
       }
     }
     request_body->set_identifier(request.httpBody().identifier());
-
+    bridge_->SetRequestBody(request_body.get());
   }
 
   if (sync_load_response) {
-    dispatcher->StartSync(request_info, request_body.get(), sync_load_response);
+    bridge_->SyncLoad(sync_load_response);
     return;
   }
 
-  AddRef();  // Balanced in OnCompletedRequest.
-  request_id_ = dispatcher->StartAsync(request_info, request_body.get(), this);
+  if (bridge_->Start(this)) {
+    AddRef();  // Balanced in OnCompletedRequest
+  } else {
+    bridge_.reset();
+  }
 }
 
 void WebURLLoaderImpl::Context::OnUploadProgress(uint64 position, uint64 size) {
   if (client_)
     client_->didSendData(loader_, position, size);
 }
 
 bool WebURLLoaderImpl::Context::OnReceivedRedirect(
     const GURL& new_url,
     const ResourceResponseInfo& info,
@@ skipping 116 matching lines @@
     ftp_listing_delegate_->OnReceivedData(data, data_length);
   } else if (multipart_delegate_) {
     // The multipart delegate will make the appropriate calls to
     // client_->didReceiveData and client_->didReceiveResponse.
     multipart_delegate_->OnReceivedData(data, data_length, encoded_data_length);
   } else {
     client_->didReceiveData(loader_, data, data_length, encoded_data_length);
   }
 }
 
-void WebURLLoaderImpl::Context::OnReceivedCachedMetadata(const char* data,
-                                                         int len) {
+void WebURLLoaderImpl::Context::OnReceivedCachedMetadata(
+    const char* data, int len) {
   if (client_)
     client_->didReceiveCachedMetadata(loader_, data, len);
 }
 
 void WebURLLoaderImpl::Context::OnCompletedRequest(
     int error_code,
     bool was_ignored_by_handler,
     bool stale_copy_in_cache,
     const std::string& security_info,
     const base::TimeTicks& completion_time,
     int64 total_transfer_size) {
   if (ftp_listing_delegate_) {
     ftp_listing_delegate_->OnCompletedRequest();
     ftp_listing_delegate_.reset(NULL);
   } else if (multipart_delegate_) {
     multipart_delegate_->OnCompletedRequest();
     multipart_delegate_.reset(NULL);
   }
 
+  // Prevent any further IPC to the browser now that we're complete, but
+  // don't delete it to keep any downloaded temp files alive.
+  DCHECK(!completed_bridge_.get());
+  completed_bridge_.swap(bridge_);
+
   if (client_) {
     if (error_code != net::OK) {
       client_->didFail(loader_, CreateError(request_.url(),
                                             stale_copy_in_cache,
                                             error_code));
     } else {
       client_->didFinishLoading(
           loader_, (completion_time - TimeTicks()).InSecondsF(),
           total_transfer_size);
     }
   }
 
   // We are done with the bridge now, and so we need to release the reference
   // to ourselves that we took on behalf of the bridge.  This may cause our
   // destruction.
   Release();
 }
 
-WebURLLoaderImpl::Context::~Context() {
-  if (request_id_ >= 0) {
-    ChildThread::current()->resource_dispatcher()->RemovePendingRequest(
-        request_id_);
-  }
-}
-
 bool WebURLLoaderImpl::Context::CanHandleDataURL(const GURL& url) const {
   DCHECK(url.SchemeIs("data"));
 
   // Optimize for the case where we can handle a data URL locally.  We must
   // skip this for data URLs targetted at frames since those could trigger a
   // download.
   //
   // NOTE: We special case MIME types we can render both for performance
-  // reasons as well as to support unit tests.
+  // reasons as well as to support unit tests, which do not have an underlying
+  // ResourceLoaderBridge implementation.
 
 #if defined(OS_ANDROID)
   // For compatibility reasons on Android we need to expose top-level data://
   // to the browser.
   if (request_.targetType() == WebURLRequest::TargetIsMainFrame)
     return false;
 #endif
 
   if (request_.targetType() != WebURLRequest::TargetIsMainFrame &&
       request_.targetType() != WebURLRequest::TargetIsSubframe)
@@ skipping 201 matching lines @@
 void WebURLLoaderImpl::setDefersLoading(bool value) {
   context_->SetDefersLoading(value);
 }
 
 void WebURLLoaderImpl::didChangePriority(WebURLRequest::Priority new_priority,
                                          int intra_priority_value) {
   context_->DidChangePriority(new_priority, intra_priority_value);
 }
 
 }  // namespace content