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_;
-  scoped_ptr<ResourceLoaderBridge> completed_bridge_;
+  int request_id_;
 };
 
 WebURLLoaderImpl::Context::Context(WebURLLoaderImpl* loader)
     : loader_(loader),
       client_(NULL),
-      referrer_policy_(blink::WebReferrerPolicyDefault) {
+      referrer_policy_(blink::WebReferrerPolicyDefault),
+      request_id_(-1) {
 }
 
 void WebURLLoaderImpl::Context::Cancel() {
-  // The bridge will still send OnCompletedRequest, which will Release() us, so
-  // we don't do that here.
-  if (bridge_)
-    bridge_->Cancel();
+  ChildThread::current()->resource_dispatcher()->Cancel(request_id_);

[tfarina, 2014/04/30 01:33:11]

John, this is crashing:

[ RUN      ] RenderViewImplTest.OnHandleKeyboardEvent
[1635:1635:0429/222921:519387653807:WARNING:resource_bundle.cc(283)]
locale_file_path.empty()
Received signal 11 SEGV_MAPERR 000000000138
#0 0x7fc7345bfe7e base::debug::StackTrace::StackTrace()
#1 0x7fc7345bf9b7 base::debug::(anonymous namespace)::StackDumpSignalHandler()
#2 0x7fc72713bcb0 <unknown>
#3 0x7fc72b46c01c base::internal::scoped_ptr_impl<>::get()
#4 0x7fc72b46d7b5 scoped_ptr<>::get()
#5 0x7fc72b46ae1c content::ChildThread::resource_dispatcher()
#6 0x7fc72b55e881 content::WebURLLoaderImpl::Context::Cancel()
#7 0x7fc72b562864 content::WebURLLoaderImpl::cancel()
#8 0x7fc7305f71a5 WebCore::ResourceLoader::releaseResources()
#9 0x7fc7305f92dc WebCore::ResourceLoader::didFinishLoading()
#10 0x7fc72b561c8d content::WebURLLoaderImpl::Context::OnCompletedRequest()
#11 0x7fc72b55fef5 content::WebURLLoaderImpl::Context::HandleDataURL()

I tried adding:
 if (ChildThread::current()->resource_dispatcher()) 

but that didn't help.

[jam, 2014/05/01 16:28:16]

you probably need to check for

if (ChildThread::current())  // NULL in unittests

instead

[tfarina, 2014/05/01 19:57:16]

Fixed, it does not crash now, but the test failed (I hope is just an issue
locally and in the trybots it will be fine). Done.

 
   // 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) {
-  if (bridge_)
-    bridge_->SetDefersLoading(value);
+  ChildThread::current()->resource_dispatcher()->SetDefersLoading(request_id_,
+                                                                  value);
 }
 
 void WebURLLoaderImpl::Context::DidChangePriority(
-    WebURLRequest::Priority new_priority, int intra_priority_value) {
-  if (bridge_)
-    bridge_->DidChangePriority(
-        ConvertWebKitPriorityToNetPriority(new_priority), intra_priority_value);
+    WebURLRequest::Priority new_priority,
+    int intra_priority_value) {
+  ChildThread::current()->resource_dispatcher()->DidChangePriority(
+      request_id_,
+      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();
-  bridge_.reset(ChildThread::current()->CreateBridge(request_info));
+  ResourceDispatcher* dispatcher =
+      ChildThread::current()->resource_dispatcher();
+
+  scoped_refptr<ResourceRequestBody> request_body = new ResourceRequestBody;
 
   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) {
-    bridge_->SyncLoad(sync_load_response);
+    dispatcher->StartSync(request_info, request_body.get(), sync_load_response);
     return;
   }
 
-  if (bridge_->Start(this)) {
-    AddRef();  // Balanced in OnCompletedRequest
-  } else {
-    bridge_.reset();
-  }
+  AddRef();  // Balanced in OnCompletedRequest.
+  request_id_ = dispatcher->StartAsync(request_info, request_body.get(), this);
 }
 
 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_);
+  }
+  if (request_.downloadToFile()) {
+    ChildThread::current()->resource_dispatcher()->message_sender()->Send(
+        new ResourceHostMsg_ReleaseDownloadedFile(request_id_));

[jam, 2014/04/28 15:26:13]

nit: we should keep the sending of resource related IPCs in ResourceDispatcher.

How about make this callsite call RemovePendingRequest as it does above. and in
that method, it can do this check of downloadToFile

[tfarina, 2014/04/30 01:33:11]

John, ResourceDispatcher does not have |request_| to access downloadToFile. Do
you want me to store this bool in PendingRequestInfo struct? I think I get get
it from RequestInfo::download_to_file.

[jam, 2014/05/01 16:28:16]

sure

[tfarina, 2014/05/01 19:57:16]

Done.

+  }
+}
+
 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, which do not have an underlying
-  // ResourceLoaderBridge implementation.
+  // reasons as well as to support unit tests.
 
 #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