Use UtilityProcessHost to patch files.

chrome/browser/component_updater/component_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/component_updater/component_unpacker.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 80 matching lines @@
   bool is_delta_;
   std::vector<uint8> public_key_;
 };
 
 }  // namespace
 
 ComponentUnpacker::ComponentUnpacker(
     const std::vector<uint8>& pk_hash,
     const base::FilePath& path,
     const std::string& fingerprint,
-    ComponentPatcher* patcher,
     ComponentInstaller* installer,
+    bool in_process,
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : pk_hash_(pk_hash),
       path_(path),
       is_delta_(false),
       fingerprint_(fingerprint),
-      patcher_(patcher),
       installer_(installer),
+      in_process_(in_process),
       error_(kNone),
       extended_error_(0),
       ptr_factory_(this),
       task_runner_(task_runner) {
 }
 
 // TODO(cpu): add a specific attribute check to a component json that the
 // extension unpacker will reject, so that a component cannot be installed
 // as an extension.
 scoped_ptr<base::DictionaryValue> ReadManifest(
@@ skipping 77 matching lines @@
 
 
 bool ComponentUnpacker::BeginPatching() {
   if (is_delta_) {  // Package is a diff package.
     // Use a different temp directory for the patch output files.
     if (!base::CreateNewTempDirectory(base::FilePath::StringType(),
                                       &unpack_path_)) {
       error_ = kUnzipPathError;
       return false;
     }
+    patcher_.reset(new ComponentPatcher(unpack_diff_path_,
+                                        unpack_path_,
+                                        installer_,
+                                        in_process_,
+                                        task_runner_));
     task_runner_->PostTask(
-        FROM_HERE, base::Bind(&DifferentialUpdatePatch,
-                              unpack_diff_path_,
-                              unpack_path_,
-                              patcher_,
-                              installer_,
+        FROM_HERE, base::Bind(&ComponentPatcher::Start,
+                              patcher_->GetWeakPtr(),
                               base::Bind(&ComponentUnpacker::EndPatching,
                                          GetWeakPtr())));
   } else {
     task_runner_->PostTask(
         FROM_HERE, base::Bind(&ComponentUnpacker::EndPatching,
                               GetWeakPtr(),
                               kNone,
                               0));
   }
   return true;
 }
 
 void ComponentUnpacker::EndPatching(Error error, int extended_error) {
+  patcher_.reset();
   error_ = error;
   extended_error_ = extended_error;
   if (error_ != kNone) {
     Finish();
     return;
   }
   // Optimization: clean up patch files early, in case disk space is too low to
   // install otherwise.
   if (!unpack_diff_path_.empty()) {
     base::DeleteFile(unpack_diff_path_, true);
@@ skipping 33 matching lines @@
 }
 
 base::WeakPtr<ComponentUnpacker> ComponentUnpacker::GetWeakPtr() {
   return ptr_factory_.GetWeakPtr();
 }
 
 ComponentUnpacker::~ComponentUnpacker() {
 }
 
 }  // namespace component_updater