Modify ResourceMessageFilter so that it can support attaching to PluginProcessHost.

content/browser/loader/async_resource_handler.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.
 
 #include "content/browser/loader/async_resource_handler.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/command_line.h"
@@ skipping 60 matching lines @@
       : net::WrappedIOBuffer(memory),
         backing_(backing) {
   }
  private:
   virtual ~DependentIOBuffer() {}
   scoped_refptr<ResourceBuffer> backing_;
 };
 
 AsyncResourceHandler::AsyncResourceHandler(
     ResourceMessageFilter* filter,
+    ResourceContext* resource_context,
     net::URLRequest* request,
     ResourceDispatcherHostImpl* rdh)
     : ResourceMessageDelegate(request),
       filter_(filter),
+      resource_context_(resource_context),
       request_(request),
       rdh_(rdh),
       pending_data_count_(0),
       allocation_size_(0),
       did_defer_(false),
       has_checked_for_sufficient_resources_(false),
       sent_received_response_msg_(false),
       sent_first_data_msg_(false) {
   InitializeResourceBufferConstants();
 }
@@ skipping 46 matching lines @@
                                                       size));
 }
 
 bool AsyncResourceHandler::OnRequestRedirected(int request_id,
                                                const GURL& new_url,
                                                ResourceResponse* response,
                                                bool* defer) {
   *defer = did_defer_ = true;
 
   if (rdh_->delegate()) {
-    rdh_->delegate()->OnRequestRedirected(new_url, request_,
-                                          filter_->resource_context(),
-                                          response);
+    rdh_->delegate()->OnRequestRedirected(
+        new_url, request_, resource_context_, response);
   }
 
   DevToolsNetLogObserver::PopulateResponseInfo(request_, response);
   response->head.request_start = request_->creation_time();
   response->head.response_start = TimeTicks::Now();
   return filter_->Send(new ResourceMsg_ReceivedRedirect(
       request_id, new_url, response->head));
 }
 
 bool AsyncResourceHandler::OnResponseStarted(int request_id,
                                              ResourceResponse* response,
                                              bool* defer) {
   // For changes to the main frame, inform the renderer of the new URL's
   // per-host settings before the request actually commits.  This way the
   // renderer will be able to set these precisely at the time the
   // request commits, avoiding the possibility of e.g. zooming the old content
   // or of having to layout the new content twice.
 
-  ResourceContext* resource_context = filter_->resource_context();
   if (rdh_->delegate()) {
     rdh_->delegate()->OnResponseStarted(
-        request_, resource_context, response, filter_.get());
+        request_, resource_context_, response, filter_.get());
   }
 
   DevToolsNetLogObserver::PopulateResponseInfo(request_, response);
 
   HostZoomMap* host_zoom_map =
-      GetHostZoomMapForResourceContext(resource_context);
+      GetHostZoomMapForResourceContext(resource_context_);
 
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request_);
   if (info->GetResourceType() == ResourceType::MAIN_FRAME && host_zoom_map) {
     const GURL& request_url = request_->url();
     filter_->Send(new ViewMsg_SetZoomLevelForLoadingURL(
         info->GetRouteID(),
         request_url, host_zoom_map->GetZoomLevelForHostAndScheme(
             request_url.scheme(),
             net::GetHostOrSpecFromURL(request_url))));
   }
@@ skipping 160 matching lines @@
 }
 
 void AsyncResourceHandler::ResumeIfDeferred() {
   if (did_defer_) {
     did_defer_ = false;
     controller()->Resume();
   }
 }
 
 }  // namespace content