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

chrome/browser/extensions/extension_updater.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 "chrome/browser/extensions/extension_updater.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 464 matching lines @@
 ExtensionUpdater::ExtensionUpdater(ExtensionServiceInterface* service,
                                    ExtensionPrefs* extension_prefs,
                                    PrefService* prefs,
                                    Profile* profile,
                                    int frequency_seconds)
     : alive_(false),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       service_(service), frequency_seconds_(frequency_seconds),
       will_check_soon_(false), extension_prefs_(extension_prefs),
       prefs_(prefs), profile_(profile), blacklist_checks_enabled_(true),
-      crx_install_is_running_(false) {
+      crx_install_is_running_(false),
+      use_utility_process_(true) {
   Init();
 }
 
 void ExtensionUpdater::Init() {
   DCHECK_GE(frequency_seconds_, 5);
   DCHECK_LE(frequency_seconds_, kMaxUpdateFrequencySeconds);
 #ifdef NDEBUG
   // In Release mode we enforce that update checks don't happen too often.
   frequency_seconds_ = std::max(frequency_seconds_, kMinUpdateFrequencySeconds);
 #endif
@@ skipping 119 matching lines @@
     NOTREACHED();
   }
   NotifyIfFinished();
 }
 
 // Utility class to handle doing xml parsing in a sandboxed utility process.
 class SafeManifestParser : public UtilityProcessHost::Client {
  public:
   // Takes ownership of |fetch_data|.
   SafeManifestParser(const std::string& xml, ManifestFetchData* fetch_data,
-                     base::WeakPtr<ExtensionUpdater> updater)
-      : xml_(xml), updater_(updater) {
+                     base::WeakPtr<ExtensionUpdater> updater,
+                     bool use_utility_process)
+      : xml_(xml),
+        updater_(updater),
+        use_utility_process_(use_utility_process) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     fetch_data_.reset(fetch_data);
   }
 
   // Posts a task over to the IO loop to start the parsing of xml_ in a
   // utility process.
   void Start() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!BrowserThread::PostTask(
             BrowserThread::IO, FROM_HERE,
             base::Bind(
-                &SafeManifestParser::ParseInSandbox, this,
-                g_browser_process->resource_dispatcher_host()))) {
+                &SafeManifestParser::ParseInSandbox, this))) {
       NOTREACHED();
     }
   }
 
   // Creates the sandboxed utility process and tells it to start parsing.
-  void ParseInSandbox(ResourceDispatcherHost* rdh) {
+  void ParseInSandbox() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     // TODO(asargent) we shouldn't need to do this branch here - instead
     // UtilityProcessHost should handle it for us. (http://crbug.com/19192)
-    bool use_utility_process = rdh &&
+    bool use_utility_process = use_utility_process_ &&
         !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess);
     if (use_utility_process) {
       UtilityProcessHost* host = new UtilityProcessHost(
           this, BrowserThread::UI);
       host->set_use_linux_zygote(true);
       host->Send(new ChromeUtilityMsg_ParseUpdateManifest(xml_));
     } else {
       UpdateManifest manifest;
       if (manifest.Parse(xml_)) {
         if (!BrowserThread::PostTask(
@@ skipping 53 matching lines @@
   ~SafeManifestParser() {
     // If we're using UtilityProcessHost, we may not be destroyed on
     // the UI or IO thread.
   }
 
   const std::string xml_;
 
   // Should be accessed only on UI thread.
   scoped_ptr<ManifestFetchData> fetch_data_;
   base::WeakPtr<ExtensionUpdater> updater_;
+  bool use_utility_process_;
 };
 
 
 void ExtensionUpdater::OnManifestFetchComplete(
     const GURL& url,
     const net::URLRequestStatus& status,
     int response_code,
     const std::string& data) {
   // We want to try parsing the manifest, and if it indicates updates are
   // available, we want to fire off requests to fetch those updates.
   if (status.status() == net::URLRequestStatus::SUCCESS &&
       (response_code == 200 || (url.SchemeIsFile() && data.length() > 0))) {
     VLOG(2) << "beginning manifest parse for " << url;
     scoped_refptr<SafeManifestParser> safe_parser(
         new SafeManifestParser(data, current_manifest_fetch_.release(),
-                               weak_ptr_factory_.GetWeakPtr()));
+                               weak_ptr_factory_.GetWeakPtr(),
+                               use_utility_process_));
     safe_parser->Start();
   } else {
     // TODO(asargent) Do exponential backoff here. (http://crbug.com/12546).
     VLOG(1) << "Failed to fetch manifest '" << url.possibly_invalid_spec()
             << "' response code:" << response_code;
     RemoveFromInProgress(current_manifest_fetch_->extension_ids());
   }
   manifest_fetcher_.reset();
   current_manifest_fetch_.reset();
 
@@ skipping 537 matching lines @@
   std::set<std::string>::const_iterator i;
   for (i = ids.begin(); i != ids.end(); ++i)
     in_progress_ids_.insert(*i);
 }
 
 void ExtensionUpdater::RemoveFromInProgress(const std::set<std::string>& ids) {
   std::set<std::string>::const_iterator i;
   for (i = ids.begin(); i != ids.end(); ++i)
     in_progress_ids_.erase(*i);
 }