Make ComponentInstaller refcounted.

components/update_client/component_patcher_operation.cc

 // 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 "components/update_client/component_patcher_operation.h"
 
 #include <stdint.h>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 25 matching lines @@
 }  // namespace
 
 const char kOp[] = "op";
 const char kBsdiff[] = "bsdiff";
 const char kCourgette[] = "courgette";
 const char kInput[] = "input";
 const char kPatch[] = "patch";
 
 DeltaUpdateOp* CreateDeltaUpdateOp(
     const std::string& operation,
-    scoped_refptr<OutOfProcessPatcher> out_of_process_patcher) {
+    const scoped_refptr<OutOfProcessPatcher>& out_of_process_patcher) {
   if (operation == "copy") {
     return new DeltaUpdateOpCopy();
   } else if (operation == "create") {
     return new DeltaUpdateOpCreate();
   } else if (operation == "bsdiff" || operation == "courgette") {
     return new DeltaUpdateOpPatch(operation, out_of_process_patcher);
   }
   return NULL;
 }
 
 DeltaUpdateOp::DeltaUpdateOp() {
 }
 
 DeltaUpdateOp::~DeltaUpdateOp() {
 }
 
-void DeltaUpdateOp::Run(const base::DictionaryValue* command_args,
-                        const base::FilePath& input_dir,
-                        const base::FilePath& unpack_dir,
-                        ComponentInstaller* installer,
-                        const ComponentUnpacker::Callback& callback,
-                        scoped_refptr<base::SequencedTaskRunner> task_runner) {
+void DeltaUpdateOp::Run(
+    const base::DictionaryValue* command_args,
+    const base::FilePath& input_dir,
+    const base::FilePath& unpack_dir,
+    const scoped_refptr<ComponentInstaller>& installer,
+    const ComponentUnpacker::Callback& callback,
+    const scoped_refptr<base::SequencedTaskRunner>& task_runner) {
   callback_ = callback;
   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;
   }
 
   output_abs_path_ =
@@ skipping 54 matching lines @@
 
 DeltaUpdateOpCopy::DeltaUpdateOpCopy() {
 }
 
 DeltaUpdateOpCopy::~DeltaUpdateOpCopy() {
 }
 
 ComponentUnpacker::Error DeltaUpdateOpCopy::DoParseArguments(
     const base::DictionaryValue* command_args,
     const base::FilePath& input_dir,
-    ComponentInstaller* installer) {
+    const scoped_refptr<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) {
+    const scoped_refptr<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;
 }
 
@@ skipping 10 matching lines @@
     : operation_(operation), out_of_process_patcher_(out_of_process_patcher) {
   DCHECK(operation == kBsdiff || operation == kCourgette);
 }
 
 DeltaUpdateOpPatch::~DeltaUpdateOpPatch() {
 }
 
 ComponentUnpacker::Error DeltaUpdateOpPatch::DoParseArguments(
     const base::DictionaryValue* command_args,
     const base::FilePath& input_dir,
-    ComponentInstaller* installer) {
+    const scoped_refptr<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_ =
@@ skipping 41 matching lines @@
     } else {
       callback.Run(ComponentUnpacker::kDeltaOperationFailure,
                    result + kCourgetteErrorOffset);
     }
   } else {
     NOTREACHED();
   }
 }
 
 }  // namespace update_client