Get rid of MessageLoop* caching in extensions code.

chrome/browser/extensions/sandboxed_extension_unpacker.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/sandboxed_extension_unpacker.h"
 
 #include <set>
 
 #include "app/gfx/codec/png_codec.h"
 #include "base/crypto/signature_verifier.h"
@@ skipping 11 matching lines @@
 #include "chrome/common/json_value_serializer.h"
 #include "net/base/base64.h"
 
 #include "third_party/skia/include/core/SkBitmap.h"
 
 const char SandboxedExtensionUnpacker::kExtensionHeaderMagic[] = "Cr24";
 
 SandboxedExtensionUnpacker::SandboxedExtensionUnpacker(
     const FilePath& crx_path, ResourceDispatcherHost* rdh,
     SandboxedExtensionUnpackerClient* client)
-      : crx_path_(crx_path), file_loop_(NULL), rdh_(rdh), client_(client),
-        got_response_(false) {
+      : crx_path_(crx_path), thread_identifier_(ChromeThread::ID_COUNT),
+        rdh_(rdh), client_(client), got_response_(false) {
 }
 
 void SandboxedExtensionUnpacker::Start() {
   // We assume that we are started on the thread that the client wants us to do
   // file IO on.
-  file_loop_ = MessageLoop::current();
+  CHECK(ChromeThread::GetCurrentThreadIdentifier(&thread_identifier_));
 
   // Create a temporary directory to work in.
   if (!temp_dir_.CreateUniqueTempDir()) {
     ReportFailure("Could not create temporary directory.");
     return;
   }
 
   // Initialize the path that will eventually contain the unpacked extension.
   extension_root_ = temp_dir_.path().AppendASCII("TEMP_INSTALL");
 
@@ skipping 34 matching lines @@
     ExtensionUnpacker unpacker(temp_crx_path);
     if (unpacker.Run() && unpacker.DumpImagesToFile())
       OnUnpackExtensionSucceeded(*unpacker.parsed_manifest());
     else
       OnUnpackExtensionFailed(unpacker.error_message());
   }
 }
 
 void SandboxedExtensionUnpacker::StartProcessOnIOThread(
     const FilePath& temp_crx_path) {
-  UtilityProcessHost* host = new UtilityProcessHost(rdh_, this, file_loop_);
+  UtilityProcessHost* host = new UtilityProcessHost(
+      rdh_, this, thread_identifier_);
   host->StartExtensionUnpacker(temp_crx_path);
 }
 
 void SandboxedExtensionUnpacker::OnUnpackExtensionSucceeded(
     const DictionaryValue& manifest) {
-  DCHECK(file_loop_ == MessageLoop::current());
+  DCHECK(ChromeThread::CurrentlyOn(thread_identifier_));
   got_response_ = true;
 
   ExtensionUnpacker::DecodedImages images;
   if (!ExtensionUnpacker::ReadImagesFromFile(temp_dir_.path(), &images)) {
     ReportFailure("Couldn't read image data from disk.");
     return;
   }
 
   // Add the public key extracted earlier to the parsed manifest and overwrite
   // the original manifest. We do this to ensure the manifest doesn't contain an
@@ skipping 80 matching lines @@
       ReportFailure("Error saving theme image.");
       return;
     }
   }
 
   ReportSuccess();
 }
 
 void SandboxedExtensionUnpacker::OnUnpackExtensionFailed(
     const std::string& error) {
-  DCHECK(file_loop_ == MessageLoop::current());
+  DCHECK(ChromeThread::CurrentlyOn(thread_identifier_));
   got_response_ = true;
   ReportFailure(error);
 }
 
 void SandboxedExtensionUnpacker::OnProcessCrashed() {
   // Don't report crashes if they happen after we got a response.
   if (got_response_)
     return;
 
   ReportFailure("Utility process crashed while trying to install.");
@@ skipping 90 matching lines @@
 
 void SandboxedExtensionUnpacker::ReportFailure(const std::string& error) {
   client_->OnUnpackFailure(error);
 }
 
 void SandboxedExtensionUnpacker::ReportSuccess() {
   // Client takes ownership of temporary directory and extension.
   client_->OnUnpackSuccess(temp_dir_.Take(), extension_root_,
                            extension_.release());
 }