Use UtilityProcessHost to patch files.

chrome/browser/component_updater/component_patcher.cc

 // Copyright 2013 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_patcher.h"
 
 #include <string>
 #include <vector>
 
+#include "base/basictypes.h"
 #include "base/file_util.h"
+#include "base/files/file_path.h"
 #include "base/json/json_file_value_serializer.h"
+#include "base/memory/weak_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/component_updater/component_patcher_operation.h"
 #include "chrome/browser/component_updater/component_updater_service.h"
+#include "content/public/browser/browser_thread.h"
 
 namespace component_updater {
 
 namespace {
 
 // Deserialize the commands file (present in delta update packages). The top
 // level must be a list.
 base::ListValue* ReadCommands(const base::FilePath& unpack_path) {
   const base::FilePath commands =
       unpack_path.Append(FILE_PATH_LITERAL("commands.json"));
   if (!base::PathExists(commands))
     return NULL;
 
   JSONFileValueSerializer serializer(commands);
   scoped_ptr<base::Value> root(serializer.Deserialize(NULL, NULL));
 
   return (root.get() && root->IsType(base::Value::TYPE_LIST)) ?
       static_cast<base::ListValue*>(root.release()) : NULL;
 }
 
 }  // namespace
 
-// The patching support is not cross-platform at the moment.
-ComponentPatcherCrossPlatform::ComponentPatcherCrossPlatform() {}
-
-ComponentUnpacker::Error ComponentPatcherCrossPlatform::Patch(
-    PatchType patch_type,
-    const base::FilePath& input_file,
-    const base::FilePath& patch_file,
-    const base::FilePath& output_file,
-    int* error) {
-  return ComponentUnpacker::kDeltaUnsupportedCommand;
+ComponentPatcher::ComponentPatcher(
+    const base::FilePath& input_dir,
+    const base::FilePath& unpack_dir,
+    ComponentInstaller* installer,
+    bool in_process,
+    scoped_refptr<base::SequencedTaskRunner> task_runner)
+    : input_dir_(input_dir),
+      unpack_dir_(unpack_dir),
+      installer_(installer),
+      in_process_(in_process),
+      task_runner_(task_runner) {
 }
 
+ComponentPatcher::~ComponentPatcher() {
+}
 
-// Takes the contents of a differential component update in input_dir
-// and produces the contents of a full component update in unpack_dir
-// using input_abs_path_ files that the installer knows about.
-void DifferentialUpdatePatch(
-    const base::FilePath& input_dir,
-    const base::FilePath& unpack_dir,
-    ComponentPatcher* patcher,
-    ComponentInstaller* installer,
-    base::Callback<void(ComponentUnpacker::Error, int)> callback) {
-  int error = 0;
-  scoped_ptr<base::ListValue> commands(ReadCommands(input_dir));
-  if (!commands.get()) {
-    callback.Run(ComponentUnpacker::kDeltaBadCommands, error);
+void ComponentPatcher::Start(
+    const base::Callback<void(ComponentUnpacker::Error, int)>& callback) {
+  callback_ = callback;
+  task_runner_->PostTask(FROM_HERE,
+                         base::Bind(&ComponentPatcher::StartPatching,
+                                    scoped_refptr<ComponentPatcher>(this)));
+}
+
+void ComponentPatcher::StartPatching() {
+  commands_.reset(ReadCommands(input_dir_));
+  if (!commands_.get()) {
+    DonePatching(ComponentUnpacker::kDeltaBadCommands, 0);
+  } else {
+    next_command_ = commands_->begin();
+    PatchNextFile();
+  }
+}
+
+void ComponentPatcher::PatchNextFile() {
+  if (next_command_ == commands_->end()) {
+    DonePatching(ComponentUnpacker::kNone, 0);
     return;
   }
+  if (!(*next_command_)->IsType(base::Value::TYPE_DICTIONARY)) {
+    DonePatching(ComponentUnpacker::kDeltaBadCommands, 0);
+    return;
+  }
+  base::DictionaryValue* command_args =

[Sorin Jianu, 2014/02/27 20:53:57]

can this be a pointer to const type? 

[waffles, 2014/02/28 00:52:43]

Done.

+      static_cast<base::DictionaryValue*>(*next_command_);
+  current_operation_ = CreateDeltaUpdateOp(*command_args);
+  if (!current_operation_) {
+    DonePatching(ComponentUnpacker::kDeltaUnsupportedCommand, 0);
+    return;
+  }
+  current_operation_->Run(
+      command_args,
+      input_dir_,
+      unpack_dir_,
+      installer_,
+      in_process_,
+      base::Bind(&ComponentPatcher::DonePatchingFile,
+                 scoped_refptr<ComponentPatcher>(this)),
+      task_runner_);
+}
 
-  for (base::ValueVector::const_iterator command = commands->begin(),
-      end = commands->end(); command != end; command++) {
-    if (!(*command)->IsType(base::Value::TYPE_DICTIONARY)) {
-      callback.Run(ComponentUnpacker::kDeltaBadCommands, error);
-      return;
-    }
-    base::DictionaryValue* command_args =
-        static_cast<base::DictionaryValue*>(*command);
-    scoped_ptr<DeltaUpdateOp> operation(CreateDeltaUpdateOp(command_args));
-    if (!operation) {
-      callback.Run(ComponentUnpacker::kDeltaUnsupportedCommand, error);
-      return;
-    }
+void ComponentPatcher::DonePatchingFile(ComponentUnpacker::Error error,
+                                        int extended_error) {
+  if (error != ComponentUnpacker::kNone) {

[Sorin Jianu, 2014/02/27 20:53:57]

This is definitely a matter of personal taste. I prefer dealing with the happy
case on the if branch of an if-else.

[waffles, 2014/02/28 00:52:43]

That's interesting. Elsewhere, we've used the pattern of having the failures be
higher in the function - I felt this was more consistent (e.g. could replace
with if(...){ DonePatching(...) return; } ++next_command; PatchNextFile();.

I kind of like it this way, too, since this is how I think about loops -
DonePatching() is like a break and ++next_commmand_ and PatchNextFile is the
final bumping up of the iterator.

Left it as it is for now.

[Sorin Jianu, 2014/02/28 01:53:53]

It's ok either way, and a matter of taste.
One of the idioms is dealing with the errors and use an early return.
if (error)
  return error;
bar();

This code is not using that idiom but an if-else statement. I am ok with the
code as is, although I would have reversed the condition of the branch. Not an
issue at all.

+    DonePatching(error, extended_error);
+  } else {
+    ++next_command_;
+    PatchNextFile();
+  }
+}
 
-    ComponentUnpacker::Error result = operation->Run(
-        command_args, input_dir, unpack_dir, patcher, installer, &error);
-    if (result != ComponentUnpacker::kNone) {
-      callback.Run(result, error);
-      return;
-    }
-  }
-
-  callback.Run(ComponentUnpacker::kNone, error);
+void ComponentPatcher::DonePatching(ComponentUnpacker::Error error,
+                                    int extended_error) {
+  callback_.Run(error, extended_error);
 }
 
 }  // namespace component_updater