Remove webkit's ResourceLoaderBridge interface.

content/child/resource_dispatcher.cc

 // Copyright (c) 2012 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.
 
 // See http://dev.chromium.org/developers/design-documents/multi-process-resource-loading
 
 #include "content/child/resource_dispatcher.h"
 
 #include "base/basictypes.h"
 #include "base/bind.h"
@@ skipping 10 matching lines @@
 #include "content/child/sync_load_response.h"
 #include "content/common/inter_process_time_ticks_converter.h"
 #include "content/common/resource_messages.h"
 #include "content/public/child/request_peer.h"
 #include "content/public/child/resource_dispatcher_delegate.h"
 #include "content/public/common/resource_response.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_util.h"
 #include "net/base/request_priority.h"
 #include "net/http/http_response_headers.h"
-#include "webkit/child/resource_loader_bridge.h"
 #include "webkit/common/resource_type.h"
 
-using webkit_glue::ResourceLoaderBridge;
 using webkit_glue::ResourceResponseInfo;
 
 namespace content {
 
 namespace {
 
 // Converts |time| from a remote to local TimeTicks, overwriting the original
 // value.
 void RemoteToLocalTimeTicks(
     const InterProcessTimeTicksConverter& converter,
     base::TimeTicks* time) {
   RemoteTimeTicks remote_time = RemoteTimeTicks::FromTimeTicks(*time);
   *time = converter.ToLocalTimeTicks(remote_time).ToTimeTicks();
 }
 
-
-}  // namespace
-
-static void CrashOnMapFailure() {
+void CrashOnMapFailure() {
 #if defined(OS_WIN)
   DWORD last_err = GetLastError();
   base::debug::Alias(&last_err);
 #endif
   CHECK(false);
 }
 
 // Each resource request is assigned an ID scoped to this process.
-static int MakeRequestID() {
+int MakeRequestID() {
   // NOTE: The resource_dispatcher_host also needs probably unique
   // request_ids, so they count down from -2 (-1 is a special we're
   // screwed value), while the renderer process counts up.
   static int next_request_id = 0;
   return next_request_id++;
 }
 
-// ResourceLoaderBridge implementation ----------------------------------------
+}  // namespace
 
-class IPCResourceLoaderBridge : public ResourceLoaderBridge {
+class ResourceDispatcher::IPCResourceLoaderBridge {
  public:
   IPCResourceLoaderBridge(ResourceDispatcher* dispatcher,
                           const RequestInfo& request_info);
   virtual ~IPCResourceLoaderBridge();
 
-  // ResourceLoaderBridge
-  virtual void SetRequestBody(ResourceRequestBody* request_body) OVERRIDE;
-  virtual bool Start(RequestPeer* peer) OVERRIDE;
-  virtual void Cancel() OVERRIDE;
-  virtual void SetDefersLoading(bool value) OVERRIDE;
-  virtual void DidChangePriority(net::RequestPriority new_priority) OVERRIDE;
-  virtual void SyncLoad(SyncLoadResponse* response) OVERRIDE;
+  void SetRequestBody(ResourceRequestBody* request_body);
+  bool Start(RequestPeer* peer);
+  void Cancel();
+  void SetDefersLoading(bool value);
+  void DidChangePriority(net::RequestPriority new_priority);
+  void SyncLoad(SyncLoadResponse* response);
 
  private:
   RequestPeer* peer_;
 
   // The resource dispatcher for this loader.  The bridge doesn't own it, but
   // it's guaranteed to outlive the bridge.
   ResourceDispatcher* dispatcher_;
 
   // The request to send, created on initialization for modification and
   // appending data.
   ResourceHostMsg_Request request_;
 
   // ID for the request, valid once Start()ed, -1 if not valid yet.
   int request_id_;
 
   // The routing id used when sending IPC messages.
   int routing_id_;
 
   // The security origin of the frame that initiates this request.
   GURL frame_origin_;
 
   bool is_synchronous_request_;
 };
 
-IPCResourceLoaderBridge::IPCResourceLoaderBridge(
+ResourceDispatcher::IPCResourceLoaderBridge::IPCResourceLoaderBridge(
     ResourceDispatcher* dispatcher,
     const RequestInfo& request_info)
     : peer_(NULL),
       dispatcher_(dispatcher),
       request_id_(-1),
       routing_id_(request_info.routing_id),
       is_synchronous_request_(false) {
   DCHECK(dispatcher_) << "no resource dispatcher";
   request_.method = request_info.method;
   request_.url = request_info.url;
@@ skipping 27 matching lines @@
       extra_data->should_replace_current_entry();
   request_.transferred_request_child_id =
       extra_data->transferred_request_child_id();
   request_.transferred_request_request_id =
       extra_data->transferred_request_request_id();
   request_.service_worker_provider_id =
       extra_data->service_worker_provider_id();
   frame_origin_ = extra_data->frame_origin();
 }
 
-IPCResourceLoaderBridge::~IPCResourceLoaderBridge() {
+ResourceDispatcher::IPCResourceLoaderBridge::~IPCResourceLoaderBridge() {
   // we remove our hook for the resource dispatcher only when going away, since
   // it doesn't keep track of whether we've force terminated the request
   if (request_id_ >= 0) {
     // this operation may fail, as the dispatcher will have preemptively
     // removed us when the renderer sends the ReceivedAllData message.
     dispatcher_->RemovePendingRequest(request_id_);
 
     if (request_.download_to_file) {
       dispatcher_->message_sender()->Send(
           new ResourceHostMsg_ReleaseDownloadedFile(request_id_));
     }
   }
 }
 
-void IPCResourceLoaderBridge::SetRequestBody(
+void ResourceDispatcher::IPCResourceLoaderBridge::SetRequestBody(
     ResourceRequestBody* request_body) {
   DCHECK(request_id_ == -1) << "request already started";
   request_.request_body = request_body;
 }
 
 // Writes a footer on the message and sends it
-bool IPCResourceLoaderBridge::Start(RequestPeer* peer) {
+bool ResourceDispatcher::IPCResourceLoaderBridge::Start(RequestPeer* peer) {
   if (request_id_ != -1) {
     NOTREACHED() << "Starting a request twice";
     return false;
   }
 
   peer_ = peer;
 
   // generate the request ID, and append it to the message
   request_id_ = dispatcher_->AddPendingRequest(peer_,
                                                request_.resource_type,
                                                request_.origin_pid,
                                                frame_origin_,
                                                request_.url);
 
   return dispatcher_->message_sender()->Send(
       new ResourceHostMsg_RequestResource(routing_id_, request_id_, request_));
 }
 
-void IPCResourceLoaderBridge::Cancel() {
+void ResourceDispatcher::IPCResourceLoaderBridge::Cancel() {
   if (request_id_ < 0) {
     NOTREACHED() << "Trying to cancel an unstarted request";
     return;
   }
 
   if (!is_synchronous_request_)
     dispatcher_->CancelPendingRequest(request_id_);
 
   // We can't remove the request ID from the resource dispatcher because more
   // data might be pending. Sending the cancel message may cause more data
   // to be flushed, and will then cause a complete message to be sent.
 }
 
-void IPCResourceLoaderBridge::SetDefersLoading(bool value) {
+void ResourceDispatcher::IPCResourceLoaderBridge::SetDefersLoading(bool value) {
   if (request_id_ < 0) {
     NOTREACHED() << "Trying to (un)defer an unstarted request";
     return;
   }
 
   dispatcher_->SetDefersLoading(request_id_, value);
 }
 
-void IPCResourceLoaderBridge::DidChangePriority(
+void ResourceDispatcher::IPCResourceLoaderBridge::DidChangePriority(
     net::RequestPriority new_priority) {
   if (request_id_ < 0) {
     NOTREACHED() << "Trying to change priority of an unstarted request";
     return;
   }
 
   dispatcher_->DidChangePriority(routing_id_, request_id_, new_priority);
 }
 
-void IPCResourceLoaderBridge::SyncLoad(SyncLoadResponse* response) {
+void ResourceDispatcher::IPCResourceLoaderBridge::SyncLoad(
+    SyncLoadResponse* response) {
   if (request_id_ != -1) {
     NOTREACHED() << "Starting a request twice";
     response->error_code = net::ERR_FAILED;
     return;
   }
 
   request_id_ = MakeRequestID();
   is_synchronous_request_ = true;
 
   SyncLoadResult result;
@@ skipping 67 matching lines @@
     if (request_info->is_deferred) {
       request_info->deferred_message_queue.push_back(new IPC::Message(message));
       return true;
     }
   }
 
   DispatchMessage(message);
   return true;
 }
 
+void ResourceDispatcher::CreateBridge(const RequestInfo& info) {
+  bridge_.reset(new IPCResourceLoaderBridge(this, info));
+}
+
+void ResourceDispatcher::SetRequestBody(ResourceRequestBody* request_body) {
+  if (bridge_)
+    bridge_->SetRequestBody(request_body);
+}
+
+bool ResourceDispatcher::Start(RequestPeer* peer) {
+  if (bridge_)
+    return bridge_->Start(peer);
+  return false;
+}
+
+void ResourceDispatcher::Cancel() {
+  if (bridge_)
+    bridge_->Cancel();
+}
+
+void ResourceDispatcher::SetDefersLoading(bool value) {
+  if (bridge_)
+    bridge_->SetDefersLoading(value);
+}
+
+void ResourceDispatcher::DidChangePriority(net::RequestPriority new_priority) {
+  if (bridge_)
+    bridge_->DidChangePriority(new_priority);
+}
+
+void ResourceDispatcher::SyncLoad(SyncLoadResponse* response) {
+  if (bridge_)
+    bridge_->SyncLoad(response);
+}
+
 ResourceDispatcher::PendingRequestInfo*
 ResourceDispatcher::GetPendingRequestInfo(int request_id) {
   PendingRequestList::iterator it = pending_requests_.find(request_id);
   if (it == pending_requests_.end()) {
     // This might happen for kill()ed requests on the webkit end.
     return NULL;
   }
   return &(it->second);
 }
 
@@ skipping 355 matching lines @@
     if (index != pending_requests_.end()) {
       PendingRequestInfo& pending_request = index->second;
       if (pending_request.is_deferred) {
         pending_request.deferred_message_queue.swap(q);
         return;
       }
     }
   }
 }
 
-ResourceLoaderBridge* ResourceDispatcher::CreateBridge(
-    const RequestInfo& request_info) {
-  return new IPCResourceLoaderBridge(this, request_info);
-}
-
 void ResourceDispatcher::ToResourceResponseInfo(
     const PendingRequestInfo& request_info,
     const ResourceResponseHead& browser_info,
     ResourceResponseInfo* renderer_info) const {
   *renderer_info = browser_info;
   if (request_info.request_start.is_null() ||
       request_info.response_start.is_null() ||
       browser_info.request_start.is_null() ||
       browser_info.response_start.is_null() ||
       browser_info.load_timing.request_start.is_null()) {
@@ skipping 93 matching lines @@
 void ResourceDispatcher::ReleaseResourcesInMessageQueue(MessageQueue* queue) {
   while (!queue->empty()) {
     IPC::Message* message = queue->front();
     ReleaseResourcesInDataMessage(*message);
     queue->pop_front();
     delete message;
   }
 }
 
 }  // namespace content