Get rid of MessageLoop* caching in extensions code.

chrome/browser/extensions/user_script_master.cc

 // Copyright (c) 2008 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/user_script_master.h"
 
 #include <string>
 #include <vector>
 
 #include "base/file_path.h"
@@ skipping 18 matching lines @@
   if (!line.starts_with(prefix))
     return false;
 
   std::string temp(line.data() + prefix.length(),
                    line.length() - prefix.length());
   TrimWhitespaceASCII(temp, TRIM_ALL, value);
   return true;
 }
 
 UserScriptMaster::ScriptReloader::ScriptReloader(UserScriptMaster* master)
-    : master_(master),
-      master_message_loop_(MessageLoop::current()) {
+    : master_(master) {
+  CHECK(ChromeThread::GetCurrentThreadIdentifier(&master_thread_id_));
 }
 
 // static
 bool UserScriptMaster::ScriptReloader::ParseMetadataHeader(
       const base::StringPiece& script_text, UserScript* script) {
   // http://wiki.greasespot.net/Metadata_block
   base::StringPiece line;
   size_t line_start = 0;
   size_t line_end = 0;
   bool in_metadata = false;
@@ skipping 52 matching lines @@
 
   // If no patterns were specified, default to @include *. This is what
   // Greasemonkey does.
   if (script->globs().size() == 0 && script->url_patterns().size() == 0)
     script->add_glob("*");
 
   return true;
 }
 
 void UserScriptMaster::ScriptReloader::StartScan(
-    MessageLoop* work_loop, const FilePath& script_dir,
-    const UserScriptList& lone_scripts) {
+    const FilePath& script_dir, const UserScriptList& lone_scripts) {
   // Add a reference to ourselves to keep ourselves alive while we're running.
   // Balanced by NotifyMaster().
   AddRef();
-  work_loop->PostTask(FROM_HERE,
-      NewRunnableMethod(this,
-                        &UserScriptMaster::ScriptReloader::RunScan,
-                        script_dir, lone_scripts));
+  ChromeThread::PostTask(
+      ChromeThread::FILE, FROM_HERE,
+      NewRunnableMethod(
+          this, &UserScriptMaster::ScriptReloader::RunScan, script_dir,
+          lone_scripts));
 }
 
 void UserScriptMaster::ScriptReloader::NotifyMaster(
     base::SharedMemory* memory) {
   // The master went away, so these new scripts aren't useful anymore.
   if (!master_)
     delete memory;
   else
     master_->NewScriptsAvailable(memory);
 
@@ skipping 113 matching lines @@
   LoadLoneScripts(&lone_script);
 
   // Merge with the explicit scripts
   scripts.reserve(scripts.size() + lone_script.size());
   scripts.insert(scripts.end(),
       lone_script.begin(), lone_script.end());
 
   // Scripts now contains list of up-to-date scripts. Load the content in the
   // shared memory and let the master know it's ready. We need to post the task
   // back even if no scripts ware found to balance the AddRef/Release calls
-  master_message_loop_->PostTask(FROM_HERE,
-      NewRunnableMethod(this,
-                        &ScriptReloader::NotifyMaster,
-                        Serialize(scripts)));
+  ChromeThread::PostTask(
+      master_thread_id_, FROM_HERE,
+      NewRunnableMethod(
+          this, &ScriptReloader::NotifyMaster, Serialize(scripts)));
 }
 
 
-UserScriptMaster::UserScriptMaster(MessageLoop* worker_loop,
-                                   const FilePath& script_dir)
+UserScriptMaster::UserScriptMaster(const FilePath& script_dir)
     : user_script_dir_(script_dir),
-      worker_loop_(worker_loop),
       extensions_service_ready_(false),
       pending_scan_(false) {
   if (!user_script_dir_.value().empty())
     AddWatchedPath(script_dir);
 
   registrar_.Add(this, NotificationType::EXTENSIONS_READY,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_LOADED,
                  NotificationService::AllSources());
   registrar_.Add(this, NotificationType::EXTENSION_UNLOADED,
@@ skipping 100 matching lines @@
 
     default:
       DCHECK(false);
   }
 }
 
 void UserScriptMaster::StartScan() {
   if (!script_reloader_)
     script_reloader_ = new ScriptReloader(this);
 
-  script_reloader_->StartScan(worker_loop_, user_script_dir_, lone_scripts_);
+  script_reloader_->StartScan(user_script_dir_, lone_scripts_);
 }