Componentize component_updater: Decouple in-process DeltaUpdateOp from out-of-process version.

chrome/browser/component_updater/component_patcher_operation_out_of_process.h

-// Copyright 2013 The Chromium Authors. All rights reserved.
+// Copyright 2014 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_
+#ifndef CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_OUT_OF_PROCESS_H_
+#define CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_OUT_OF_PROCESS_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 "chrome/browser/component_updater/component_patcher_operation.h"
 #include "content/public/browser/utility_process_host_client.h"
 
 namespace base {
 class DictionaryValue;
 }  // namespace base
 
 namespace component_updater {
 
-class ComponentInstaller;
-
-class DeltaUpdateOp : public base::RefCountedThreadSafe<DeltaUpdateOp> {
- public:
-  DeltaUpdateOp();
-
-  // Parses, runs, and verifies the operation. Calls |callback| with the
-  // result of the operation. The callback is called using |task_runner|.
-  void Run(const base::DictionaryValue* command_args,
-           const base::FilePath& input_dir,
-           const base::FilePath& unpack_dir,
-           ComponentInstaller* installer,
-           bool in_process,
-           const ComponentUnpacker::Callback& callback,
-           scoped_refptr<base::SequencedTaskRunner> task_runner);
-
- protected:
-  virtual ~DeltaUpdateOp();
-
-  bool InProcess();
-
-  scoped_refptr<base::SequencedTaskRunner> GetTaskRunner();
-
-  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(
-      const base::DictionaryValue* command_args,
-      const base::FilePath& input_dir,
-      ComponentInstaller* installer) = 0;
-
-  // Subclasses must override DoRun to actually perform the patching operation.
-  // 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 ComponentUnpacker::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_;
-  ComponentUnpacker::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();
-
- private:
-  virtual ~DeltaUpdateOpCopy();
-
-  // Overrides of DeltaUpdateOp.
-  virtual ComponentUnpacker::Error DoParseArguments(
-      const base::DictionaryValue* command_args,
-      const base::FilePath& input_dir,
-      ComponentInstaller* installer) OVERRIDE;
-
-  virtual void DoRun(const ComponentUnpacker::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();
-
- private:
-  virtual ~DeltaUpdateOpCreate();
-
-  // Overrides of DeltaUpdateOp.
-  virtual ComponentUnpacker::Error DoParseArguments(
-      const base::DictionaryValue* command_args,
-      const base::FilePath& input_dir,
-      ComponentInstaller* installer) OVERRIDE;
-
-  virtual void DoRun(const ComponentUnpacker::Callback& callback) OVERRIDE;
-
-  base::FilePath patch_abs_path_;
-
-  DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpCreate);
-};
-
-class DeltaUpdateOpPatchStrategy {
- public:
-  virtual ~DeltaUpdateOpPatchStrategy();
-
-  // Returns an integer to add to error codes to disambiguate their source.
-  virtual int GetErrorOffset() const = 0;
-
-  // Returns the "error code" that is expected in the successful install case.
-  virtual int GetSuccessCode() const = 0;
-
-  // Returns an IPC message that will start patching if it is sent to a
-  // UtilityProcessClient.
-  virtual scoped_ptr<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;
-};
-
-class DeltaUpdateOpPatch;
-
-class DeltaUpdateOpPatchHost : public content::UtilityProcessHostClient {
- public:
-  DeltaUpdateOpPatchHost(scoped_refptr<DeltaUpdateOpPatch> patcher,
-                         scoped_refptr<base::SequencedTaskRunner> task_runner);
-
-  void StartProcess(scoped_ptr<IPC::Message> message);
-
- private:
-  virtual ~DeltaUpdateOpPatchHost();
-
-  void OnPatchSucceeded();
-
-  void OnPatchFailed(int error_code);
-
-  // Overrides of content::UtilityProcessHostClient.
-  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
-
-  virtual void OnProcessCrashed(int exit_code) OVERRIDE;
-
-  scoped_refptr<DeltaUpdateOpPatch> patcher_;
-  scoped_refptr<base::SequencedTaskRunner> task_runner_;
-};
+class DeltaUpdateOpPatchHost;
 
 // 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 {
+class DeltaUpdateOpPatchOutOfProcess : public DeltaUpdateOp {
  public:
-  explicit DeltaUpdateOpPatch(scoped_ptr<DeltaUpdateOpPatchStrategy> strategy);
+  explicit DeltaUpdateOpPatchOutOfProcess(const std::string& operation);
 
   void DonePatching(ComponentUnpacker::Error error, int error_code);
 
  private:
-  virtual ~DeltaUpdateOpPatch();
+  virtual ~DeltaUpdateOpPatchOutOfProcess();
 
   // Overrides of DeltaUpdateOp.
   virtual ComponentUnpacker::Error DoParseArguments(
       const base::DictionaryValue* command_args,
       const base::FilePath& input_dir,
       ComponentInstaller* installer) OVERRIDE;
 
   virtual void DoRun(const ComponentUnpacker::Callback& callback) OVERRIDE;
 
+  std::string operation_;
   ComponentUnpacker::Callback callback_;
   base::FilePath patch_abs_path_;
   base::FilePath input_abs_path_;
-  scoped_ptr<DeltaUpdateOpPatchStrategy> strategy_;
   scoped_refptr<DeltaUpdateOpPatchHost> host_;
 
-  DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpPatch);
+  DISALLOW_COPY_AND_ASSIGN(DeltaUpdateOpPatchOutOfProcess);
 };
 
-// Factory functions to create DeltaUpdateOp instances.
-DeltaUpdateOp* CreateDeltaUpdateOp(const base::DictionaryValue& command);
-
-DeltaUpdateOp* CreateDeltaUpdateOp(const std::string& operation);
+// Creates an in-process DeltaUpdateOpFactory.
+DeltaUpdateOpFactory* CreateOutOfProcessDeltaUpdateOpFactory();
 
 }  // namespace component_updater
 
-#endif  // CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_H_
+#endif  // CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_PATCHER_OPERATION_OUT_OF_PROCESS_H_