Move creation and ownership of ResourceDispatcherHost and PluginService to content. This gives a ...

chrome/browser/web_resource/web_resource_service.cc

 // Copyright (c) 2011 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 "chrome/browser/web_resource/web_resource_service.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 12 matching lines @@
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_status.h"
 
 using content::BrowserThread;
 
 // This class coordinates a web resource unpack and parse task which is run in
 // a separate process.  Results are sent back to this class and routed to
 // the WebResourceService.
 class WebResourceService::UnpackerClient : public UtilityProcessHost::Client {
  public:
-  explicit UnpackerClient(WebResourceService* web_resource_service)
+  UnpackerClient(WebResourceService* web_resource_service,
+                 bool use_utility_process)
     : web_resource_service_(web_resource_service),
-      resource_dispatcher_host_(g_browser_process->resource_dispatcher_host()),
+      use_utility_process_(use_utility_process),
       got_response_(false) {
   }
 
   void Start(const std::string& json_data) {
     AddRef();  // balanced in Cleanup.
 
-    // TODO(willchan): Look for a better signal of whether we're in a unit test
-    // or not. Using |resource_dispatcher_host_| for this is pretty lame.
-    // If we don't have a resource_dispatcher_host_, assume we're in
-    // a test and run the unpacker directly in-process.
     bool use_utility_process =
-        resource_dispatcher_host_ != NULL &&
+        use_utility_process_ &&
         !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess);
     if (use_utility_process) {
       BrowserThread::ID thread_id;
       CHECK(BrowserThread::GetCurrentThreadIdentifier(&thread_id));
       BrowserThread::PostTask(
           BrowserThread::IO, FROM_HERE,
           base::Bind(&UnpackerClient::StartProcessOnIOThread,
                      this, thread_id, json_data));
     } else {
       WebResourceUnpacker unpacker(json_data);
@@ skipping 53 matching lines @@
                               const std::string& json_data) {
     UtilityProcessHost* host = new UtilityProcessHost(this, thread_id);
     host->set_use_linux_zygote(true);
     // TODO(mrc): get proper file path when we start using web resources
     // that need to be unpacked.
     host->Send(new ChromeUtilityMsg_UnpackWebResource(json_data));
   }
 
   scoped_refptr<WebResourceService> web_resource_service_;
 
-  // Owned by the global browser process.
-  ResourceDispatcherHost* resource_dispatcher_host_;
+  bool use_utility_process_;
 
   // True if we got a response from the utility process and have cleaned up
   // already.
   bool got_response_;
 };
 
 WebResourceService::WebResourceService(
     PrefService* prefs,
     const char* web_resource_server,
     bool apply_locale_to_url,
     const char* last_update_time_pref_name,
     int start_fetch_delay_ms,
     int cache_update_delay_ms)
     : prefs_(prefs),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       in_fetch_(false),
       web_resource_server_(web_resource_server),
       apply_locale_to_url_(apply_locale_to_url),
       last_update_time_pref_name_(last_update_time_pref_name),
       start_fetch_delay_ms_(start_fetch_delay_ms),
-      cache_update_delay_ms_(cache_update_delay_ms) {
+      cache_update_delay_ms_(cache_update_delay_ms),
+      use_utility_process_(true) {
   DCHECK(prefs);
 }
 
 WebResourceService::~WebResourceService() { }
 
 void WebResourceService::EndFetch() {
   in_fetch_ = false;
 }
 
 void WebResourceService::StartAfterDelay() {
@@ skipping 70 matching lines @@
 
   // Don't parse data if attempt to download was unsuccessful.
   // Stop loading new web resource data, and silently exit.
   if (!source->GetStatus().is_success() || (source->GetResponseCode() != 200))
     return;
 
   std::string data;
   source->GetResponseAsString(&data);
 
   // UnpackerClient releases itself.
-  UnpackerClient* client = new UnpackerClient(this);
+  UnpackerClient* client = new UnpackerClient(this, use_utility_process_);
   client->Start(data);
 
   Release();
 }