Support asynchronous patching operations in the component updater.

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/file_util.h"
@@ skipping 16 matching lines @@
 
   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;
 }
 
 
 // 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.
-ComponentUnpacker::Error DifferentialUpdatePatch(
+void DifferentialUpdatePatch(
     const base::FilePath& input_dir,
     const base::FilePath& unpack_dir,
     ComponentPatcher* patcher,
     ComponentInstaller* installer,
-    int* error) {
-  *error = 0;
+    base::Callback<void(ComponentUnpacker::Error, int)> callback) {
+  int error = 0;
   scoped_ptr<base::ListValue> commands(ReadCommands(input_dir));
-  if (!commands.get())
-    return ComponentUnpacker::kDeltaBadCommands;
+  if (!commands.get()) {

[Sorin Jianu, 2014/01/25 02:30:21]

I wonder if some amount of code duplication here can be eliminated if we
delegate the implementation to a function DifferentialUpdatePatchInternal that
returns an std::pair and this function becomes:

void DifferentialUpdatePatch(... {
  std::pair<> result = DifferentialUpdatePatchInternal(...);
  callback.Run(...);
  return;
}

It's a small deal but it enforces the call back is called in all cases.

[waffles, 2014/01/28 21:06:31]

Yes, but I'll have to immediately undo that change in the next CL, since once
operation->Run() becomes asynchronous, DifferentialUpdatePatchInternal would
become asynchronous as well.

+    callback.Run(ComponentUnpacker::kDeltaBadCommands, error);
+    return;
+  }
 
   for (base::ValueVector::const_iterator command = commands->begin(),
       end = commands->end(); command != end; command++) {
-    if (!(*command)->IsType(base::Value::TYPE_DICTIONARY))
-      return ComponentUnpacker::kDeltaBadCommands;
+    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)
-      return ComponentUnpacker::kDeltaUnsupportedCommand;
+    if (!operation) {
+      callback.Run(ComponentUnpacker::kDeltaUnsupportedCommand, error);
+      return;
+    }
 
     ComponentUnpacker::Error result = operation->Run(
-        command_args, input_dir, unpack_dir, patcher, installer, error);
-    if (result != ComponentUnpacker::kNone)
-      return result;
+        command_args, input_dir, unpack_dir, patcher, installer, &error);
+    if (result != ComponentUnpacker::kNone) {
+      callback.Run(result, error);
+      return;
+    }
   }
 
-  return ComponentUnpacker::kNone;
+  callback.Run(ComponentUnpacker::kNone, error);
 }
 
 }  // namespace component_updater
-