Move most of the component updater artifacts to update_client.

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/component_updater/component_patcher_operation.h"
+#include "components/update_client/component_patcher_operation.h"
 
 #include <stdint.h>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/memory_mapped_file.h"
 #include "base/location.h"
 #include "base/strings/string_number_conversions.h"
-#include "components/component_updater/component_patcher.h"
-#include "components/component_updater/component_updater_service.h"
+#include "components/update_client/component_patcher.h"
+#include "components/update_client/update_client.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"
 
 using crypto::SecureHash;
 
-namespace component_updater {
+namespace update_client {
 
 namespace {
 
 const char kOutput[] = "output";
 const char kSha256[] = "sha256";
 
 // The integer offset disambiguates between overlapping error ranges.
 const int kCourgetteErrorOffset = 300;
 const int kBsdiffErrorOffset = 600;
 
@@ skipping 174 matching lines @@
 
   patch_abs_path_ =
       input_dir.Append(base::FilePath::FromUTF8Unsafe(patch_rel_path));
 
   return ComponentUnpacker::kNone;
 }
 
 void DeltaUpdateOpPatch::DoRun(const ComponentUnpacker::Callback& callback) {
   if (out_of_process_patcher_.get()) {
     out_of_process_patcher_->Patch(
-        operation_,
-        GetTaskRunner(),
-        input_abs_path_,
-        patch_abs_path_,
+        operation_, GetTaskRunner(), input_abs_path_, patch_abs_path_,
         output_abs_path_,
         base::Bind(&DeltaUpdateOpPatch::DonePatching, this, callback));
     return;
   }
 
   if (operation_ == kBsdiff) {
     DonePatching(callback,
-                 courgette::ApplyBinaryPatch(
-                     input_abs_path_, patch_abs_path_, output_abs_path_));
+                 courgette::ApplyBinaryPatch(input_abs_path_, patch_abs_path_,
+                                             output_abs_path_));
   } else if (operation_ == kCourgette) {
-    DonePatching(
-        callback,
-        courgette::ApplyEnsemblePatch(input_abs_path_.value().c_str(),
-                                      patch_abs_path_.value().c_str(),
-                                      output_abs_path_.value().c_str()));
+    DonePatching(callback, courgette::ApplyEnsemblePatch(
+                               input_abs_path_.value().c_str(),
+                               patch_abs_path_.value().c_str(),
+                               output_abs_path_.value().c_str()));
   } else {
     NOTREACHED();
   }
 }
 
 void DeltaUpdateOpPatch::DonePatching(
     const ComponentUnpacker::Callback& callback,
     int result) {
   if (operation_ == kBsdiff) {
     if (result == courgette::OK) {
       callback.Run(ComponentUnpacker::kNone, 0);
     } else {
       callback.Run(ComponentUnpacker::kDeltaOperationFailure,
                    result + kBsdiffErrorOffset);
     }
   } else if (operation_ == kCourgette) {
     if (result == courgette::C_OK) {
       callback.Run(ComponentUnpacker::kNone, 0);
     } else {
       callback.Run(ComponentUnpacker::kDeltaOperationFailure,
                    result + kCourgetteErrorOffset);
     }
   } else {
     NOTREACHED();
   }
 }
 
-}  // namespace component_updater
+}  // namespace update_client