Ever closer. Extract a client interface out of CrxInstaller and

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 "base/crypto/signature_verifier.h"
 #include "base/file_util.h"
@@ skipping 10 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), client_loop_(MessageLoop::current()), rdh_(rdh),
-        client_(client), got_response_(false) {
+      : crx_path_(crx_path), file_loop_(NULL), 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();
+
   // 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");
 
   // Extract the public key and validate the package.
@@ skipping 19 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,
-                                                    MessageLoop::current());
+  UtilityProcessHost* host = new UtilityProcessHost(rdh_, this, file_loop_);
   host->StartExtensionUnpacker(temp_crx_path);
 }
 
 void SandboxedExtensionUnpacker::OnUnpackExtensionSucceeded(
     const DictionaryValue& manifest) {
+  DCHECK(file_loop_ == MessageLoop::current());
   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 65 matching lines @@
       ReportFailure("Error saving theme image.");
       return;
     }
   }
 
   ReportSuccess();
 }
 
 void SandboxedExtensionUnpacker::OnUnpackExtensionFailed(
     const std::string& error) {
+  DCHECK(file_loop_ == MessageLoop::current());
   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());
 }