Make utility process run in-process when running in single-process mode.

chrome/browser/extensions/sandboxed_unpacker.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/sandboxed_unpacker.h"
 
 #include <set>
 
 #include "base/base64.h"
 #include "base/bind.h"
@@ skipping 160 matching lines @@
              << "remote drives or read-only. Installation can not complete!";
   return false;
 }
 
 }  // namespace
 
 namespace extensions {
 
 SandboxedUnpacker::SandboxedUnpacker(
     const base::FilePath& crx_path,
-    bool run_out_of_process,
     Manifest::Location location,
     int creation_flags,
     const base::FilePath& extensions_dir,
     base::SequencedTaskRunner* unpacker_io_task_runner,
     SandboxedUnpackerClient* client)
     : crx_path_(crx_path),
-      run_out_of_process_(run_out_of_process),
       client_(client),
       extensions_dir_(extensions_dir),
       got_response_(false),
       location_(location),
       creation_flags_(creation_flags),
       unpacker_io_task_runner_(unpacker_io_task_runner) {
 }
 
 bool SandboxedUnpacker::CreateTempDirectory() {
   CHECK(unpacker_io_task_runner_->RunsTasksOnCurrentThread());
@@ skipping 50 matching lines @@
   if (!file_util::CopyFile(crx_path_, temp_crx_path)) {
     // Failed to copy extension file to temporary directory.
     ReportFailure(
         FAILED_TO_COPY_EXTENSION_FILE_TO_TEMP_DIRECTORY,
         l10n_util::GetStringFUTF16(
             IDS_EXTENSION_PACKAGE_INSTALL_ERROR,
             ASCIIToUTF16("FAILED_TO_COPY_EXTENSION_FILE_TO_TEMP_DIRECTORY")));
     return;
   }
 
-  // If we are supposed to use a subprocess, kick off the subprocess.
-  //
-  // 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 = run_out_of_process_ &&
-      !CommandLine::ForCurrentProcess()->HasSwitch(switches::kSingleProcess);
-  if (use_utility_process) {
-    // The utility process will have access to the directory passed to
-    // SandboxedUnpacker.  That directory should not contain a symlink or NTFS
-    // reparse point.  When the path is used, following the link/reparse point
-    // will cause file system access outside the sandbox path, and the sandbox
-    // will deny the operation.
-    base::FilePath link_free_crx_path;
-    if (!file_util::NormalizeFilePath(temp_crx_path, &link_free_crx_path)) {
-      LOG(ERROR) << "Could not get the normalized path of "
-                 << temp_crx_path.value();
-      ReportFailure(
-          COULD_NOT_GET_SANDBOX_FRIENDLY_PATH,
-          l10n_util::GetStringUTF16(IDS_EXTENSION_UNPACK_FAILED));
-      return;
-    }
-    PATH_LENGTH_HISTOGRAM("Extensions.SandboxUnpackLinkFreeCrxPathLength",
-                          link_free_crx_path);
+  // The utility process will have access to the directory passed to
+  // SandboxedUnpacker.  That directory should not contain a symlink or NTFS
+  // reparse point.  When the path is used, following the link/reparse point
+  // will cause file system access outside the sandbox path, and the sandbox
+  // will deny the operation.
+  base::FilePath link_free_crx_path;
+  if (!file_util::NormalizeFilePath(temp_crx_path, &link_free_crx_path)) {
+    LOG(ERROR) << "Could not get the normalized path of "
+               << temp_crx_path.value();
+    ReportFailure(
+        COULD_NOT_GET_SANDBOX_FRIENDLY_PATH,
+        l10n_util::GetStringUTF16(IDS_EXTENSION_UNPACK_FAILED));
+    return;
+  }
+  PATH_LENGTH_HISTOGRAM("Extensions.SandboxUnpackLinkFreeCrxPathLength",
+                        link_free_crx_path);
 
-    BrowserThread::PostTask(
-        BrowserThread::IO, FROM_HERE,
-        base::Bind(
-            &SandboxedUnpacker::StartProcessOnIOThread,
-            this,
-            link_free_crx_path));
-  } else {
-    // Otherwise, unpack the extension in this process.
-    Unpacker unpacker(temp_crx_path, extension_id_, location_, creation_flags_);
-    if (unpacker.Run() && unpacker.DumpImagesToFile() &&
-        unpacker.DumpMessageCatalogsToFile()) {
-      OnUnpackExtensionSucceeded(*unpacker.parsed_manifest());
-    } else {
-      OnUnpackExtensionFailed(unpacker.error_message());
-    }
-  }
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(
+          &SandboxedUnpacker::StartProcessOnIOThread,
+          this,
+          link_free_crx_path));
 }
 
 SandboxedUnpacker::~SandboxedUnpacker() {
 }
 
 bool SandboxedUnpacker::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(SandboxedUnpacker, message)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_UnpackExtension_Succeeded,
                         OnUnpackExtensionSucceeded)
@@ skipping 483 matching lines @@
 
 void SandboxedUnpacker::Cleanup() {
   DCHECK(unpacker_io_task_runner_->RunsTasksOnCurrentThread());
   if (!temp_dir_.Delete()) {
     LOG(WARNING) << "Can not delete temp directory at "
                  << temp_dir_.path().value();
   }
 }
 
 }  // namespace extensions