Use UtilityProcessHost to patch files.

chrome/browser/component_updater/component_patcher_operation.h

 // 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.
 
 #ifndef CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_H_
 #define CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_H_
 
 #include <string>
+
 #include "base/basictypes.h"
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
+#include "base/memory/ref_counted.h"
+#include "chrome/browser/component_updater/component_patcher.h"
 #include "chrome/browser/component_updater/component_unpacker.h"
+#include "content/public/browser/utility_process_host_client.h"
 
 namespace base {
 class DictionaryValue;
 }  // namespace base
 
 namespace component_updater {
 
 class ComponentInstaller;
-class ComponentPatcher;
 
-class DeltaUpdateOp {
+class DeltaUpdateOp : public base::RefCountedThreadSafe<DeltaUpdateOp> {
  public:
+  DeltaUpdateOp();
 
-  DeltaUpdateOp();
+  // Parses, runs, and verifies the operation. Calls |callback| with the
+  // result of the operation. The callback is called using |task_runner|.
+  void Run(base::DictionaryValue* command_args,
+           const base::FilePath& input_dir,
+           const base::FilePath& unpack_dir,
+           ComponentInstaller* installer,
+           bool in_process,
+           const base::Callback<void(ComponentUnpacker::Error, int)>& callback,
+           scoped_refptr<base::SequencedTaskRunner> task_runner);
+
+ protected:
+  typedef base::Callback<void(ComponentUnpacker::Error, int)> Callback;

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

This type could be a typedef in ComponentUnpacker. This typedef here already has
a dependency on the ComponentUnpacker and this compilation unit is including the
header for that type. The idea is that there are too many of the callback types.
At the first glance, they all serve the same function: get called with an
unpacking error and an int.

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

Done.

+
   virtual ~DeltaUpdateOp();
 
-  // Parses, runs, and verifies the operation, returning an error code if an
-  // error is encountered, and DELTA_OK otherwise. In case of errors,
-  // extended error information can be returned in the |error| parameter.
-  ComponentUnpacker::Error Run(base::DictionaryValue* command_args,
-                               const base::FilePath& input_dir,
-                               const base::FilePath& unpack_dir,
-                               ComponentPatcher* patcher,
-                               ComponentInstaller* installer,
-                               int* error);
+  bool InProcess();

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

Is there a way to remove some of the protected members here. For example,
InProcess could be public. This is not exposing any implementation detail since
in_process is an argument that the caller already knows about.

InProcess can be const.

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

Let's leave this one to a later CL if you don't mind tolerating it for a little
while longer.

 
- protected:
   std::string output_sha256_;
   base::FilePath output_abs_path_;
 
  private:
+  friend class base::RefCountedThreadSafe<DeltaUpdateOp>;
+
   ComponentUnpacker::Error CheckHash();
 
   // Subclasses must override DoParseArguments to parse operation-specific
   // arguments. DoParseArguments returns DELTA_OK on success; any other code
   // represents failure.
   virtual ComponentUnpacker::Error DoParseArguments(
       base::DictionaryValue* command_args,
       const base::FilePath& input_dir,
       ComponentInstaller* installer) = 0;
 
   // Subclasses must override DoRun to actually perform the patching operation.
-  // DoRun returns DELTA_OK on success; any other code represents failure.
-  // Additional error information can be returned in the |error| parameter.
-  virtual ComponentUnpacker::Error DoRun(ComponentPatcher* patcher,
-                                         int* error) = 0;
+  // They must call the provided callback when they have completed their
+  // operations. In practice, the provided callback is always for "DoneRunning".
+  virtual void DoRun(const Callback& callback) = 0;
+
+  // Callback given to subclasses for when they complete their operation.
+  // Validates the output, and posts a task to the patching operation's
+  // callback.
+  void DoneRunning(ComponentUnpacker::Error error, int extended_error);
+
+  bool in_process_;
+  Callback callback_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOp);
 };
 
 // A 'copy' operation takes a file currently residing on the disk and moves it
 // into the unpacking directory: this represents "no change" in the file being
 // installed.
 class DeltaUpdateOpCopy : public DeltaUpdateOp {
  public:
   DeltaUpdateOpCopy();
 
+ protected:
+  virtual ~DeltaUpdateOpCopy();
+
  private:
   // Overrides of DeltaUpdateOp.
   virtual ComponentUnpacker::Error DoParseArguments(
       base::DictionaryValue* command_args,
       const base::FilePath& input_dir,
       ComponentInstaller* installer) OVERRIDE;
 
-  virtual ComponentUnpacker::Error DoRun(ComponentPatcher* patcher,
-                                         int* error) OVERRIDE;
+  virtual void DoRun(const Callback& callback) OVERRIDE;
 
   base::FilePath input_abs_path_;
 
   DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpCopy);
 };
 
 // A 'create' operation takes a full file that was sent in the delta update
 // archive and moves it into the unpacking directory: this represents the
 // addition of a new file, or a file so different that no bandwidth could be
 // saved by transmitting a differential update.
 class DeltaUpdateOpCreate : public DeltaUpdateOp {
  public:
   DeltaUpdateOpCreate();
 
+ protected:
+  virtual ~DeltaUpdateOpCreate();
+
  private:
   // Overrides of DeltaUpdateOp.
   virtual ComponentUnpacker::Error DoParseArguments(
       base::DictionaryValue* command_args,
       const base::FilePath& input_dir,
       ComponentInstaller* installer) OVERRIDE;
 
-  virtual ComponentUnpacker::Error DoRun(ComponentPatcher* patcher,
-                                         int* error) OVERRIDE;
+  virtual void DoRun(const Callback& callback) OVERRIDE;
 
   base::FilePath patch_abs_path_;
 
   DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpCreate);
 };
 
-// A 'bsdiff' operation takes an existing file on disk, and a bsdiff-
-// format patch file provided in the delta update package, and runs bsdiff
-// to construct an output file in the unpacking directory.
-class DeltaUpdateOpPatchBsdiff : public DeltaUpdateOp {
+class DeltaUpdateOpPatchTraits {

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

Let's rename that Traits to something else, with the idea that the terminology
for traits in C++ is relevant to type traits. A couple of related patterns here
are Bridge or Strategy.

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

Done.

  public:
-  DeltaUpdateOpPatchBsdiff();
+  virtual ~DeltaUpdateOpPatchTraits();
+
+  // Returns an integer to add to error codes to disambiguate their source.

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

can any of these be const?

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

Done.

+  virtual int GetErrorOffset() = 0;
+
+  // Returns the "error code" that is expected in the successful install case.
+  virtual int GetSuccessCode() = 0;
+
+  // Returns an IPC message that will start patching if it is sent to a
+  // UtilityProcessClient.
+  virtual IPC::Message* GetPatchMessage(base::FilePath input_abs_path,
+                                        base::FilePath patch_abs_path,
+                                        base::FilePath output_abs_path) = 0;
+
+  // Does the actual patching operation, and returns an error code.
+  virtual int Patch(base::FilePath input_abs_path,
+                    base::FilePath patch_abs_path,
+                    base::FilePath output_abs_path) = 0;
+};
+
+// Both 'bsdiff' and 'courgette' operations take an existing file on disk,
+// and a bsdiff- or Courgette-format patch file provided in the delta update
+// package, and run bsdiff or Courgette to construct an output file in the
+// unpacking directory.
+class DeltaUpdateOpPatch : public DeltaUpdateOp,
+                           public content::UtilityProcessHostClient {
+ public:
+  explicit DeltaUpdateOpPatch(scoped_ptr<DeltaUpdateOpPatchTraits> traits);
+
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;

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

Can we make these two virtuals private and add the boilerplate comment
//Overrides of...

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

Done.

+
+  virtual void OnProcessCrashed(int exit_code) OVERRIDE;
+
+ protected:
+  virtual ~DeltaUpdateOpPatch();
 
  private:
+  void DonePatching(ComponentUnpacker::Error error, int error_code);
+
+  void OnPatchSucceeded();
+
+  void OnPatchFailed(int error_code);
+
   // Overrides of DeltaUpdateOp.
   virtual ComponentUnpacker::Error DoParseArguments(
       base::DictionaryValue* command_args,
       const base::FilePath& input_dir,
       ComponentInstaller* installer) OVERRIDE;
 
-  virtual ComponentUnpacker::Error DoRun(ComponentPatcher* patcher,
-                                         int* error) OVERRIDE;
+  virtual void DoRun(const Callback& callback) OVERRIDE;
 
+  void StartProcess();
+
+  Callback callback_;
   base::FilePath patch_abs_path_;
   base::FilePath input_abs_path_;
+  scoped_ptr<DeltaUpdateOpPatchTraits> traits_;
 
-  DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpPatchBsdiff);
+  DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpPatch);
 };
 
-// A 'courgette' operation takes an existing file on disk, and a Courgette-
-// format patch file provided in the delta update package, and runs Courgette
-// to construct an output file in the unpacking directory.
-class DeltaUpdateOpPatchCourgette : public DeltaUpdateOp {
- public:
-  DeltaUpdateOpPatchCourgette();
+// Factory functions to create DeltaUpdateOp instances.
+DeltaUpdateOp* CreateDeltaUpdateOp(const base::DictionaryValue& command);
 
- private:
-  // Overrides of DeltaUpdateOp.
-  virtual ComponentUnpacker::Error DoParseArguments(
-      base::DictionaryValue* command_args,
-      const base::FilePath& input_dir,
-      ComponentInstaller* installer) OVERRIDE;
-
-  virtual ComponentUnpacker::Error DoRun(ComponentPatcher* patcher,
-                                         int* error) OVERRIDE;
-
-  base::FilePath patch_abs_path_;
-  base::FilePath input_abs_path_;
-
-  DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpPatchCourgette);
-};
-
-// Factory function to create DeltaUpdateOp instances.
-DeltaUpdateOp* CreateDeltaUpdateOp(base::DictionaryValue* command);
+DeltaUpdateOp* CreateDeltaUpdateOp(const std::string& operation);
 
 }  // namespace component_updater
 
 #endif  // CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_H_