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

chrome/browser/component_updater/component_patcher_operation_out_of_process.cc

-// 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.
 
-#include "chrome/browser/component_updater/component_patcher_operation.h"
+#include "chrome/browser/component_updater/component_patcher_operation_out_of_process.h"
 
-#include <string>
 #include <vector>
 
 #include "base/bind.h"
-#include "base/file_util.h"
-#include "base/files/memory_mapped_file.h"
-#include "base/json/json_file_value_serializer.h"
-#include "base/path_service.h"
-#include "base/strings/string_number_conversions.h"
-#include "chrome/browser/component_updater/component_patcher.h"
 #include "chrome/browser/component_updater/component_updater_service.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/utility_process_host.h"
 #include "courgette/courgette.h"
 #include "courgette/third_party/bsdiff.h"
-#include "crypto/secure_hash.h"
-#include "crypto/sha2.h"
-#include "crypto/signature_verifier.h"
-#include "extensions/common/crx_file.h"
 #include "ipc/ipc_message_macros.h"
 
-using crypto::SecureHash;
-
 namespace component_updater {
 
 namespace {
 
-const char kInput[] = "input";
-const char kOp[] = "op";
-const char kOutput[] = "output";
-const char kPatch[] = "patch";
-const char kSha256[] = "sha256";
-
-// The integer offset disambiguates between overlapping error ranges.
-const int kCourgetteErrorOffset = 300;
-const int kBsdiffErrorOffset = 600;
-
-class CourgetteTraits : public DeltaUpdateOpPatchStrategy {
+class OutOfProcessProcessDeltaUpdateOpFactory : public DeltaUpdateOpFactory {
  public:
-  virtual int GetErrorOffset() const OVERRIDE;
-  virtual int GetSuccessCode() const OVERRIDE;
-  virtual scoped_ptr<IPC::Message> GetPatchMessage(
-      base::FilePath input_abs_path,
-      base::FilePath patch_abs_path,
-      base::FilePath output_abs_path) OVERRIDE;
-  virtual int Patch(base::FilePath input_abs_path,
-                    base::FilePath patch_abs_path,
-                    base::FilePath output_abs_path) OVERRIDE;
+  virtual DeltaUpdateOp* CreateDeltaUpdateOp(
+      const std::string& operation) const OVERRIDE {
+    if (operation == "copy") {
+      return new DeltaUpdateOpCopy();
+    } else if (operation == "create") {
+      return new DeltaUpdateOpCreate();
+    } else if (operation == kBsdiff || operation == kCourgette) {
+      return new DeltaUpdateOpPatchOutOfProcess(operation);
+    }
+    return NULL;
+  }
 };
 
-int CourgetteTraits::GetErrorOffset() const {
-  return kCourgetteErrorOffset;
-}
-
-int CourgetteTraits::GetSuccessCode() const {
-  return courgette::C_OK;
-}
-
-scoped_ptr<IPC::Message> CourgetteTraits::GetPatchMessage(
-    base::FilePath input_abs_path,
-    base::FilePath patch_abs_path,
-    base::FilePath output_abs_path) {
-  return scoped_ptr<IPC::Message>(
-      new ChromeUtilityMsg_PatchFileCourgette(input_abs_path,
-                                              patch_abs_path,
-                                              output_abs_path));
-}
-
-int CourgetteTraits::Patch(base::FilePath input_abs_path,
-                           base::FilePath patch_abs_path,
-                           base::FilePath output_abs_path) {
-  return courgette::ApplyEnsemblePatch(input_abs_path.value().c_str(),
-                                       patch_abs_path.value().c_str(),
-                                       output_abs_path.value().c_str());
-}
-
-class BsdiffTraits : public DeltaUpdateOpPatchStrategy {
- public:
-  virtual int GetErrorOffset() const OVERRIDE;
-  virtual int GetSuccessCode() const OVERRIDE;
-  virtual scoped_ptr<IPC::Message> GetPatchMessage(
-      base::FilePath input_abs_path,
-      base::FilePath patch_abs_path,
-      base::FilePath output_abs_path) OVERRIDE;
-  virtual int Patch(base::FilePath input_abs_path,
-                    base::FilePath patch_abs_path,
-                    base::FilePath output_abs_path) OVERRIDE;
-};
-
-int BsdiffTraits::GetErrorOffset() const {
-  return kBsdiffErrorOffset;
-}
-
-int BsdiffTraits::GetSuccessCode() const {
-  return courgette::OK;
-}
-
-scoped_ptr<IPC::Message> BsdiffTraits::GetPatchMessage(
-    base::FilePath input_abs_path,
-    base::FilePath patch_abs_path,
-    base::FilePath output_abs_path) {
-  return scoped_ptr<IPC::Message>(
-      new ChromeUtilityMsg_PatchFileBsdiff(input_abs_path,
-                                           patch_abs_path,
-                                           output_abs_path));
-}
-
-int BsdiffTraits::Patch(base::FilePath input_abs_path,
-                        base::FilePath patch_abs_path,
-                        base::FilePath output_abs_path) {
-  return courgette::ApplyBinaryPatch(input_abs_path,
-                                     patch_abs_path,
-                                     output_abs_path);
-}
-
 }  // namespace
 
-DeltaUpdateOpPatchStrategy::~DeltaUpdateOpPatchStrategy() {
+DeltaUpdateOpFactory* CreateOutOfProcessDeltaUpdateOpFactory() {
+  return new OutOfProcessProcessDeltaUpdateOpFactory();
 }
 
-DeltaUpdateOp* CreateDeltaUpdateOp(const std::string& operation) {
-  if (operation == "copy") {
-    return new DeltaUpdateOpCopy();
-  } else if (operation == "create") {
-    return new DeltaUpdateOpCreate();
-  } else if (operation == "bsdiff") {
-    scoped_ptr<DeltaUpdateOpPatchStrategy> strategy(new BsdiffTraits());
-    return new DeltaUpdateOpPatch(strategy.Pass());
-  } else if (operation == "courgette") {
-    scoped_ptr<DeltaUpdateOpPatchStrategy> strategy(new CourgetteTraits());
-    return new DeltaUpdateOpPatch(strategy.Pass());
-  }
-  return NULL;
-}
+class DeltaUpdateOpPatchHost : public content::UtilityProcessHostClient {
+ public:
+  DeltaUpdateOpPatchHost(scoped_refptr<DeltaUpdateOpPatchOutOfProcess> patcher,
+                         scoped_refptr<base::SequencedTaskRunner> task_runner);
 
-DeltaUpdateOp* CreateDeltaUpdateOp(const base::DictionaryValue& command) {
-  std::string operation;
-  if (!command.GetString(kOp, &operation))
-    return NULL;
-  return CreateDeltaUpdateOp(operation);
-}
+  void StartProcess(scoped_ptr<IPC::Message> message);
 
-DeltaUpdateOp::DeltaUpdateOp() : in_process_(false) {
-}
+ private:
+  virtual ~DeltaUpdateOpPatchHost();
 
-DeltaUpdateOp::~DeltaUpdateOp() {
-}
+  void OnPatchSucceeded();
 
-void DeltaUpdateOp::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) {
-  callback_ = callback;
-  in_process_ = in_process;
-  task_runner_ = task_runner;
-  std::string output_rel_path;
-  if (!command_args->GetString(kOutput, &output_rel_path) ||
-      !command_args->GetString(kSha256, &output_sha256_)) {
-    DoneRunning(ComponentUnpacker::kDeltaBadCommands, 0);
-    return;
-  }
+  void OnPatchFailed(int error_code);
 
-  output_abs_path_ =
-      unpack_dir.Append(base::FilePath::FromUTF8Unsafe(output_rel_path));
-  ComponentUnpacker::Error parse_result =
-      DoParseArguments(command_args, input_dir, installer);
-  if (parse_result != ComponentUnpacker::kNone) {
-    DoneRunning(parse_result, 0);
-    return;
-  }
+  // Overrides of content::UtilityProcessHostClient.
+  virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
 
-  const base::FilePath parent = output_abs_path_.DirName();
-  if (!base::DirectoryExists(parent)) {
-    if (!base::CreateDirectory(parent)) {
-      DoneRunning(ComponentUnpacker::kIoError, 0);
-      return;
-    }
-  }
+  virtual void OnProcessCrashed(int exit_code) OVERRIDE;
 
-  DoRun(base::Bind(&DeltaUpdateOp::DoneRunning,
-                   scoped_refptr<DeltaUpdateOp>(this)));
-}
-
-void DeltaUpdateOp::DoneRunning(ComponentUnpacker::Error error,
-                                int extended_error) {
-  if (error == ComponentUnpacker::kNone)
-    error = CheckHash();
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(callback_, error, extended_error));
-  callback_.Reset();
-}
-
-// Uses the hash as a checksum to confirm that the file now residing in the
-// output directory probably has the contents it should.
-ComponentUnpacker::Error DeltaUpdateOp::CheckHash() {
-  std::vector<uint8> expected_hash;
-  if (!base::HexStringToBytes(output_sha256_, &expected_hash) ||
-      expected_hash.size() != crypto::kSHA256Length)
-    return ComponentUnpacker::kDeltaVerificationFailure;
-
-  base::MemoryMappedFile output_file_mmapped;
-  if (!output_file_mmapped.Initialize(output_abs_path_))
-    return ComponentUnpacker::kDeltaVerificationFailure;
-
-  uint8 actual_hash[crypto::kSHA256Length] = {0};
-  const scoped_ptr<SecureHash> hasher(SecureHash::Create(SecureHash::SHA256));
-  hasher->Update(output_file_mmapped.data(), output_file_mmapped.length());
-  hasher->Finish(actual_hash, sizeof(actual_hash));
-  if (memcmp(actual_hash, &expected_hash[0], sizeof(actual_hash)))
-    return ComponentUnpacker::kDeltaVerificationFailure;
-
-  return ComponentUnpacker::kNone;
-}
-
-bool DeltaUpdateOp::InProcess() {
-  return in_process_;
-}
-
-scoped_refptr<base::SequencedTaskRunner> DeltaUpdateOp::GetTaskRunner() {
-  return task_runner_;
-}
-
-DeltaUpdateOpCopy::DeltaUpdateOpCopy() {
-}
-
-DeltaUpdateOpCopy::~DeltaUpdateOpCopy() {
-}
-
-ComponentUnpacker::Error DeltaUpdateOpCopy::DoParseArguments(
-    const base::DictionaryValue* command_args,
-    const base::FilePath& input_dir,
-    ComponentInstaller* installer) {
-  std::string input_rel_path;
-  if (!command_args->GetString(kInput, &input_rel_path))
-    return ComponentUnpacker::kDeltaBadCommands;
-
-  if (!installer->GetInstalledFile(input_rel_path, &input_abs_path_))
-    return ComponentUnpacker::kDeltaMissingExistingFile;
-
-  return ComponentUnpacker::kNone;
-}
-
-void DeltaUpdateOpCopy::DoRun(const ComponentUnpacker::Callback& callback) {
-  if (!base::CopyFile(input_abs_path_, output_abs_path_))
-    callback.Run(ComponentUnpacker::kDeltaOperationFailure, 0);
-  else
-    callback.Run(ComponentUnpacker::kNone, 0);
-}
-
-DeltaUpdateOpCreate::DeltaUpdateOpCreate() {
-}
-
-DeltaUpdateOpCreate::~DeltaUpdateOpCreate() {
-}
-
-ComponentUnpacker::Error DeltaUpdateOpCreate::DoParseArguments(
-    const base::DictionaryValue* command_args,
-    const base::FilePath& input_dir,
-    ComponentInstaller* installer) {
-  std::string patch_rel_path;
-  if (!command_args->GetString(kPatch, &patch_rel_path))
-    return ComponentUnpacker::kDeltaBadCommands;
-
-  patch_abs_path_ =
-      input_dir.Append(base::FilePath::FromUTF8Unsafe(patch_rel_path));
-
-  return ComponentUnpacker::kNone;
-}
-
-void DeltaUpdateOpCreate::DoRun(const ComponentUnpacker::Callback& callback) {
-  if (!base::Move(patch_abs_path_, output_abs_path_))
-    callback.Run(ComponentUnpacker::kDeltaOperationFailure, 0);
-  else
-    callback.Run(ComponentUnpacker::kNone, 0);
-}
+  scoped_refptr<DeltaUpdateOpPatchOutOfProcess> patcher_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
+};
 
 DeltaUpdateOpPatchHost::DeltaUpdateOpPatchHost(
-    scoped_refptr<DeltaUpdateOpPatch> patcher,
+    scoped_refptr<DeltaUpdateOpPatchOutOfProcess> patcher,
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : patcher_(patcher), task_runner_(task_runner) {
 }
 
 DeltaUpdateOpPatchHost::~DeltaUpdateOpPatchHost() {
 }
 
 void DeltaUpdateOpPatchHost::StartProcess(scoped_ptr<IPC::Message> message) {
   // The DeltaUpdateOpPatchHost is not responsible for deleting the
   // UtilityProcessHost object.
   content::UtilityProcessHost* host = content::UtilityProcessHost::Create(
       this, base::MessageLoopProxy::current().get());
   host->DisableSandbox();
   host->Send(message.release());
 }
 
 bool DeltaUpdateOpPatchHost::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(DeltaUpdateOpPatchHost, message)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_PatchFile_Succeeded,
                         OnPatchSucceeded)
     IPC_MESSAGE_HANDLER(ChromeUtilityHostMsg_PatchFile_Failed,
                         OnPatchFailed)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void DeltaUpdateOpPatchHost::OnPatchSucceeded() {
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&DeltaUpdateOpPatch::DonePatching,
-                                    patcher_,
-                                    ComponentUnpacker::kNone,
-                                    0));
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&DeltaUpdateOpPatchOutOfProcess::DonePatching,
+                 patcher_,
+                 ComponentUnpacker::kNone,
+                 0));
   task_runner_ = NULL;
   patcher_ = NULL;
 }
 
 void DeltaUpdateOpPatchHost::OnPatchFailed(int error_code) {
-  task_runner_->PostTask(FROM_HERE,
-                         base::Bind(&DeltaUpdateOpPatch::DonePatching,
-                                    patcher_,
-                                    ComponentUnpacker::kDeltaOperationFailure,
-                                    error_code));
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&DeltaUpdateOpPatchOutOfProcess::DonePatching,
+                 patcher_,
+                 ComponentUnpacker::kDeltaOperationFailure,
+                 error_code));
   task_runner_ = NULL;
   patcher_ = NULL;
 }
 
 void DeltaUpdateOpPatchHost::OnProcessCrashed(int exit_code) {
   task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&DeltaUpdateOpPatch::DonePatching,
+      base::Bind(&DeltaUpdateOpPatchOutOfProcess::DonePatching,
                  patcher_,
                  ComponentUnpacker::kDeltaPatchProcessFailure,
                  exit_code));
   task_runner_ = NULL;
   patcher_ = NULL;
 }
 
-DeltaUpdateOpPatch::DeltaUpdateOpPatch(
-    scoped_ptr<DeltaUpdateOpPatchStrategy> strategy) {
-  strategy_ = strategy.Pass();
+DeltaUpdateOpPatchOutOfProcess::DeltaUpdateOpPatchOutOfProcess(
+    const std::string& operation)
+    : operation_(operation) {
+  DCHECK(operation == kBsdiff || operation == kCourgette);
 }
 
-DeltaUpdateOpPatch::~DeltaUpdateOpPatch() {
+DeltaUpdateOpPatchOutOfProcess::~DeltaUpdateOpPatchOutOfProcess() {
 }
 
-ComponentUnpacker::Error DeltaUpdateOpPatch::DoParseArguments(
+ComponentUnpacker::Error DeltaUpdateOpPatchOutOfProcess::DoParseArguments(
     const base::DictionaryValue* command_args,
     const base::FilePath& input_dir,
     ComponentInstaller* installer) {
   std::string patch_rel_path;
   std::string input_rel_path;
   if (!command_args->GetString(kPatch, &patch_rel_path) ||
       !command_args->GetString(kInput, &input_rel_path))
     return ComponentUnpacker::kDeltaBadCommands;
 
   if (!installer->GetInstalledFile(input_rel_path, &input_abs_path_))
     return ComponentUnpacker::kDeltaMissingExistingFile;
 
   patch_abs_path_ =
       input_dir.Append(base::FilePath::FromUTF8Unsafe(patch_rel_path));
 
   return ComponentUnpacker::kNone;
 }
 
-void DeltaUpdateOpPatch::DoRun(const ComponentUnpacker::Callback& callback) {
+void DeltaUpdateOpPatchOutOfProcess::DoRun(
+    const ComponentUnpacker::Callback& callback) {
   callback_ = callback;
-  if (!InProcess()) {
-    host_ = new DeltaUpdateOpPatchHost(scoped_refptr<DeltaUpdateOpPatch>(this),
-                                       GetTaskRunner());
-    content::BrowserThread::PostTask(
-        content::BrowserThread::IO,
-        FROM_HERE,
-        base::Bind(&DeltaUpdateOpPatchHost::StartProcess,
-                   host_,
-                   base::Passed(strategy_->GetPatchMessage(input_abs_path_,
-                                                           patch_abs_path_,
-                                                           output_abs_path_))));
-    return;
+  host_ = new DeltaUpdateOpPatchHost(
+      scoped_refptr<DeltaUpdateOpPatchOutOfProcess>(this), GetTaskRunner());
+  scoped_ptr<IPC::Message> patch_message;
+  if (operation_ == kBsdiff) {
+    patch_message.reset(new ChromeUtilityMsg_PatchFileBsdiff(
+        input_abs_path_, patch_abs_path_, output_abs_path_));
+  } else if (operation_ == kCourgette) {
+    patch_message.reset(new ChromeUtilityMsg_PatchFileCourgette(
+        input_abs_path_, patch_abs_path_, output_abs_path_));
+  } else {
+    NOTREACHED();
   }
-  const int result = strategy_->Patch(input_abs_path_,
-                                      patch_abs_path_,
-                                      output_abs_path_);
-  if (result == strategy_->GetSuccessCode())
-    DonePatching(ComponentUnpacker::kNone, 0);
-  else
-    DonePatching(ComponentUnpacker::kDeltaOperationFailure, result);
+
+  content::BrowserThread::PostTask(
+      content::BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&DeltaUpdateOpPatchHost::StartProcess,
+                 host_,
+                 base::Passed(&patch_message)));
 }
 
-void DeltaUpdateOpPatch::DonePatching(ComponentUnpacker::Error error,
-                                      int error_code) {
+void DeltaUpdateOpPatchOutOfProcess::DonePatching(
+    ComponentUnpacker::Error error,
+    int error_code) {
   host_ = NULL;
   if (error != ComponentUnpacker::kNone) {
-    error_code += strategy_->GetErrorOffset();
+    if (operation_ == kBsdiff) {
+      error_code += kBsdiffErrorOffset;
+    } else if (operation_ == kCourgette) {
+      error_code += kCourgetteErrorOffset;
+    } else {
+      NOTREACHED();
+    }
   }
   callback_.Run(error, error_code);
   // The callback is no longer needed - it is best to release it in case it
   // contains a reference to this object.
   callback_.Reset();
 }
 
 }  // namespace component_updater