Get rid of MessageLoop* caching in extensions code.

chrome/browser/extensions/extension_updater.cc

 // Copyright (c) 2009 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/logging.h"
@@ skipping 42 matching lines @@
 const int kStartupWaitSeconds = 60 * 5;
 
 // For sanity checking on update frequency - enforced in release mode only.
 static const int kMinUpdateFrequencySeconds = 30;
 static const int kMaxUpdateFrequencySeconds = 60 * 60 * 24 * 7;  // 7 days
 
 // A utility class to do file handling on the file I/O thread.
 class ExtensionUpdaterFileHandler
     : public base::RefCountedThreadSafe<ExtensionUpdaterFileHandler> {
  public:
-  ExtensionUpdaterFileHandler(MessageLoop* updater_loop,
-                              MessageLoop* file_io_loop)
-      : updater_loop_(updater_loop), file_io_loop_(file_io_loop) {}
-
   // Writes crx file data into a tempfile, and calls back the updater.
   void WriteTempFile(const std::string& extension_id, const std::string& data,
                      scoped_refptr<ExtensionUpdater> updater) {
     // Make sure we're running in the right thread.
-    DCHECK(MessageLoop::current() == file_io_loop_);
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
 
     FilePath path;
     if (!file_util::CreateTemporaryFile(&path)) {
       LOG(WARNING) << "Failed to create temporary file path";
       return;
     }
     if (file_util::WriteFile(path, data.c_str(), data.length()) !=
         static_cast<int>(data.length())) {
       // TODO(asargent) - It would be nice to back off updating alltogether if
       // the disk is full. (http://crbug.com/12763).
       LOG(ERROR) << "Failed to write temporary file";
       file_util::Delete(path, false);
       return;
     }
 
     // The ExtensionUpdater is now responsible for cleaning up the temp file
     // from disk.
-    updater_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        updater.get(), &ExtensionUpdater::OnCRXFileWritten, extension_id,
-        path));
+    ChromeThread::PostTask(
+        ChromeThread::UI, FROM_HERE,
+        NewRunnableMethod(
+            updater.get(), &ExtensionUpdater::OnCRXFileWritten, extension_id,
+            path));
   }
 
   void DeleteFile(const FilePath& path) {
-    DCHECK(MessageLoop::current() == file_io_loop_);
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
     if (!file_util::Delete(path, false)) {
       LOG(WARNING) << "Failed to delete temp file " << path.value();
     }
   }
-
- private:
-  // The MessageLoop we use to call back the ExtensionUpdater.
-  MessageLoop* updater_loop_;
-
-  // The MessageLoop we should be operating on for file operations.
-  MessageLoop* file_io_loop_;
 };
 
 
 ExtensionUpdater::ExtensionUpdater(ExtensionUpdateService* service,
                                    PrefService* prefs,
-                                   int frequency_seconds,
-                                   MessageLoop* file_io_loop,
-                                   MessageLoop* io_loop)
+                                   int frequency_seconds)
     : service_(service), frequency_seconds_(frequency_seconds),
-      file_io_loop_(file_io_loop), io_loop_(io_loop), prefs_(prefs),
-      file_handler_(new ExtensionUpdaterFileHandler(MessageLoop::current(),
-                                                    file_io_loop_)),
+      prefs_(prefs), file_handler_(new ExtensionUpdaterFileHandler()),
       blacklist_checks_enabled_(true) {
   Init();
 }
 
 void ExtensionUpdater::Init() {
-  // Unless we're in a unit test, expect that the file_io_loop_ is on the
-  // browser file thread.
-  if (g_browser_process->file_thread() != NULL) {
-    DCHECK(file_io_loop_ == g_browser_process->file_thread()->message_loop());
-  }
-
   DCHECK_GE(frequency_seconds_, 5);
   DCHECK(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
   frequency_seconds_ = std::min(frequency_seconds_, kMaxUpdateFrequencySeconds);
 }
 
 ExtensionUpdater::~ExtensionUpdater() {}
@@ skipping 78 matching lines @@
   } else if (source == extension_fetcher_.get()) {
     OnCRXFetchComplete(url, status, response_code, data);
   } else {
     NOTREACHED();
   }
 }
 
 // Utility class to handle doing xml parsing in a sandboxed utility process.
 class SafeManifestParser : public UtilityProcessHost::Client {
  public:
-  SafeManifestParser(const std::string& xml, ExtensionUpdater* updater,
-                     MessageLoop* updater_loop, MessageLoop* io_loop)
-      : xml_(xml), updater_loop_(updater_loop), io_loop_(io_loop),
-        updater_(updater) {
+  SafeManifestParser(const std::string& xml, ExtensionUpdater* updater)
+      : xml_(xml), updater_(updater) {
   }
 
   ~SafeManifestParser() {}
 
   // Posts a task over to the IO loop to start the parsing of xml_ in a
   // utility process.
   void Start() {
-    DCHECK(MessageLoop::current() == updater_loop_);
-    io_loop_->PostTask(FROM_HERE,
-        NewRunnableMethod(this, &SafeManifestParser::ParseInSandbox,
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+    ChromeThread::PostTask(
+        ChromeThread::IO, FROM_HERE,
+        NewRunnableMethod(
+            this, &SafeManifestParser::ParseInSandbox,
             g_browser_process->resource_dispatcher_host()));
   }
 
   // Creates the sandboxed utility process and tells it to start parsing.
   void ParseInSandbox(ResourceDispatcherHost* rdh) {
-    DCHECK(MessageLoop::current() == io_loop_);
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::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 &&
         !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess);
 
 #if defined(OS_POSIX)
     // TODO(port): Don't use a utility process on linux (crbug.com/22703) or
     // MacOS (crbug.com/8102) until problems related to autoupdate are fixed.
     use_utility_process = false;
 #endif
 
     if (use_utility_process) {
       UtilityProcessHost* host = new UtilityProcessHost(
-          rdh, this, updater_loop_);
+          rdh, this, ChromeThread::UI);
       host->StartUpdateManifestParse(xml_);
     } else {
       UpdateManifest manifest;
       if (manifest.Parse(xml_)) {
-        updater_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-            &SafeManifestParser::OnParseUpdateManifestSucceeded,
-            manifest.results()));
+        ChromeThread::PostTask(
+            ChromeThread::UI, FROM_HERE,
+            NewRunnableMethod(
+                this, &SafeManifestParser::OnParseUpdateManifestSucceeded,
+                manifest.results()));
       } else {
-        updater_loop_->PostTask(FROM_HERE, NewRunnableMethod(this,
-            &SafeManifestParser::OnParseUpdateManifestFailed,
-            manifest.errors()));
+        ChromeThread::PostTask(
+            ChromeThread::UI, FROM_HERE,
+            NewRunnableMethod(
+                this, &SafeManifestParser::OnParseUpdateManifestFailed,
+                manifest.errors()));
       }
     }
   }
 
   // Callback from the utility process when parsing succeeded.
   virtual void OnParseUpdateManifestSucceeded(
       const UpdateManifest::ResultList& list) {
-    DCHECK(MessageLoop::current() == updater_loop_);
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
     updater_->HandleManifestResults(list);
   }
 
   // Callback from the utility process when parsing failed.
   virtual void OnParseUpdateManifestFailed(const std::string& error_message) {
-    DCHECK(MessageLoop::current() == updater_loop_);
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
     LOG(WARNING) << "Error parsing update manifest:\n" << error_message;
   }
 
  private:
   const std::string& xml_;
 
-  // The MessageLoop we use to call back the ExtensionUpdater.
-  MessageLoop* updater_loop_;
-
-  // The MessageLoop where we create the utility process.
-  MessageLoop* io_loop_;
-
   scoped_refptr<ExtensionUpdater> updater_;
 };
 
 
 void ExtensionUpdater::OnManifestFetchComplete(const GURL& url,
                                                const 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() == URLRequestStatus::SUCCESS && response_code == 200) {
-    scoped_refptr<SafeManifestParser>  safe_parser =
-        new SafeManifestParser(data, this, MessageLoop::current(), io_loop_);
+    scoped_refptr<SafeManifestParser> safe_parser =
+        new SafeManifestParser(data, this);
     safe_parser->Start();
   } else {
     // TODO(asargent) Do exponential backoff here. (http://crbug.com/12546).
     LOG(INFO) << "Failed to fetch manifst '" << url.possibly_invalid_spec() <<
         "' response code:" << response_code;
   }
   manifest_fetcher_.reset();
 
   // If we have any pending manifest requests, fire off the next one.
   if (!manifests_pending_.empty()) {
@@ skipping 45 matching lines @@
     LOG(ERROR) << "Called with unexpected url:'" << url.spec()
                << "' expected:'" << current_extension_fetch_.url.spec() << "'";
     NOTREACHED();
   } else if (status.status() == URLRequestStatus::SUCCESS &&
              response_code == 200) {
     if (current_extension_fetch_.id == kBlacklistAppID) {
       ProcessBlacklist(data);
     } else {
       // Successfully fetched - now write crx to a file so we can have the
       // ExtensionsService install it.
-      file_io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-        file_handler_.get(), &ExtensionUpdaterFileHandler::WriteTempFile,
-        current_extension_fetch_.id, data, this));
+      ChromeThread::PostTask(
+          ChromeThread::FILE, FROM_HERE,
+          NewRunnableMethod(
+              file_handler_.get(), &ExtensionUpdaterFileHandler::WriteTempFile,
+              current_extension_fetch_.id, data, this));
     }
   } else {
     // TODO(asargent) do things like exponential backoff, handling
     // 503 Service Unavailable / Retry-After headers, etc. here.
     // (http://crbug.com/12546).
     LOG(INFO) << "Failed to fetch extension '" <<
         url.possibly_invalid_spec() << "' response code:" << response_code;
   }
   extension_fetcher_.reset();
   current_extension_fetch_ = ExtensionFetch();
 
   // If there are any pending downloads left, start one.
   if (extensions_pending_.size() > 0) {
     ExtensionFetch next = extensions_pending_.front();
     extensions_pending_.pop_front();
     FetchUpdatedExtension(next.id, next.url, next.package_hash, next.version);
   }
 }
 
 void ExtensionUpdater::OnCRXFileWritten(const std::string& id,
                                         const FilePath& path) {
   service_->UpdateExtension(id, path);
 }
 
 void ExtensionUpdater::OnExtensionInstallFinished(const FilePath& path,
                                                   Extension* extension) {
   // Have the file_handler_ delete the temp file on the file I/O thread.
-  file_io_loop_->PostTask(FROM_HERE, NewRunnableMethod(
-    file_handler_.get(), &ExtensionUpdaterFileHandler::DeleteFile, path));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          file_handler_.get(), &ExtensionUpdaterFileHandler::DeleteFile, path));
 }
 
 
 // Helper function for building up request parameters in update check urls. It
 // appends information about one extension to a request parameter string. The
 // format for request parameters in update checks is:
 //
 //   ?x=EXT1_INFO&x=EXT2_INFO
 //
 // where EXT1_INFO and EXT2_INFO are url-encoded strings of the form:
@@ skipping 217 matching lines @@
     extension_fetcher_.reset(
         URLFetcher::Create(kExtensionFetcherId, url, URLFetcher::GET, this));
     extension_fetcher_->set_request_context(
         Profile::GetDefaultRequestContext());
     extension_fetcher_->set_load_flags(net::LOAD_DO_NOT_SEND_COOKIES |
                                        net::LOAD_DO_NOT_SAVE_COOKIES);
     extension_fetcher_->Start();
     current_extension_fetch_ = ExtensionFetch(id, url, hash, version);
   }
 }