Move most of the component updater artifacts to update_client.

components/update_client/component_unpacker.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_unpacker.h"
+#include "components/update_client/component_unpacker.h"
 
 #include <stdint.h>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
-#include "components/component_updater/component_patcher.h"
-#include "components/component_updater/component_patcher_operation.h"
-#include "components/component_updater/component_updater_service.h"
 #include "components/crx_file/constants.h"
 #include "components/crx_file/crx_file.h"
+#include "components/update_client/component_patcher.h"
+#include "components/update_client/component_patcher_operation.h"
+#include "components/update_client/update_client.h"
 #include "crypto/secure_hash.h"
 #include "crypto/signature_verifier.h"
 #include "third_party/zlib/google/zip.h"
 
 using crypto::SecureHash;
 
-namespace component_updater {
+namespace update_client {
 
 namespace {
 
 // This class makes sure that the CRX digital signature is valid
 // and well formed.
 class CRXValidator {
  public:
   explicit CRXValidator(FILE* crx_file) : valid_(false), is_delta_(false) {
     crx_file::CrxFile::Header header;
     size_t len = fread(&header, 1, sizeof(header), crx_file);
     if (len < sizeof(header))
       return;
 
     crx_file::CrxFile::Error error;
-    scoped_ptr<crx_file::CrxFile> crx(
-        crx_file::CrxFile::Parse(header, &error));
+    scoped_ptr<crx_file::CrxFile> crx(crx_file::CrxFile::Parse(header, &error));
     if (!crx.get())
       return;
     is_delta_ = crx_file::CrxFile::HeaderIsDelta(header);
 
     std::vector<uint8_t> key(header.key_size);
     len = fread(&key[0], sizeof(uint8_t), header.key_size, crx_file);
     if (len < header.key_size)
       return;
 
     std::vector<uint8_t> signature(header.signature_size);
     len =
         fread(&signature[0], sizeof(uint8_t), header.signature_size, crx_file);
     if (len < header.signature_size)
       return;
 
     crypto::SignatureVerifier verifier;
-    if (!verifier.VerifyInit(crx_file::kSignatureAlgorithm,
-                             base::checked_cast<int>(
-                                 sizeof(crx_file::kSignatureAlgorithm)),
-                             &signature[0],
-                             base::checked_cast<int>(signature.size()),
-                             &key[0],
-                             base::checked_cast<int>(key.size()))) {
+    if (!verifier.VerifyInit(
+            crx_file::kSignatureAlgorithm,
+            base::checked_cast<int>(sizeof(crx_file::kSignatureAlgorithm)),
+            &signature[0], base::checked_cast<int>(signature.size()), &key[0],
+            base::checked_cast<int>(key.size()))) {
       // Signature verification initialization failed. This is most likely
       // caused by a public key in the wrong format (should encode algorithm).
       return;
     }
 
     const size_t kBufSize = 8 * 1024;
     scoped_ptr<uint8_t[]> buf(new uint8_t[kBufSize]);
     while ((len = fread(buf.get(), 1, kBufSize, crx_file)) > 0)
       verifier.VerifyUpdate(buf.get(), base::checked_cast<int>(len));
 
@@ skipping 16 matching lines @@
   std::vector<uint8_t> public_key_;
 };
 
 }  // namespace
 
 ComponentUnpacker::ComponentUnpacker(
     const std::vector<uint8_t>& pk_hash,
     const base::FilePath& path,
     const std::string& fingerprint,
     ComponentInstaller* installer,
-    scoped_refptr<OutOfProcessPatcher> out_of_process_patcher,
+    scoped_refptr<OutOfProcessPatcher> oop_patcher,
     scoped_refptr<base::SequencedTaskRunner> task_runner)
     : pk_hash_(pk_hash),
       path_(path),
       is_delta_(false),
       fingerprint_(fingerprint),
       installer_(installer),
-      out_of_process_patcher_(out_of_process_patcher),
+      oop_patcher_(oop_patcher),
       error_(kNone),
       extended_error_(0),
       task_runner_(task_runner) {
 }
 
 // TODO(cpu): add a specific attribute check to a component json that the
 // extension unpacker will reject, so that a component cannot be installed
 // as an extension.
 scoped_ptr<base::DictionaryValue> ReadManifest(
     const base::FilePath& unpack_path) {
@@ skipping 79 matching lines @@
 }
 
 bool ComponentUnpacker::BeginPatching() {
   if (is_delta_) {  // Package is a diff package.
     // Use a different temp directory for the patch output files.
     if (!base::CreateNewTempDirectory(base::FilePath::StringType(),
                                       &unpack_path_)) {
       error_ = kUnzipPathError;
       return false;
     }
-    patcher_ = new ComponentPatcher(unpack_diff_path_,
-                                    unpack_path_,
-                                    installer_,
-                                    out_of_process_patcher_,
-                                    task_runner_);
+    patcher_ = new ComponentPatcher(unpack_diff_path_, unpack_path_, installer_,
+                                    oop_patcher_, task_runner_);
     task_runner_->PostTask(
         FROM_HERE,
-        base::Bind(&ComponentPatcher::Start,
-                   patcher_,
+        base::Bind(&ComponentPatcher::Start, patcher_,
                    base::Bind(&ComponentUnpacker::EndPatching,
                               scoped_refptr<ComponentUnpacker>(this))));
   } else {
-    task_runner_->PostTask(FROM_HERE,
-                           base::Bind(&ComponentUnpacker::EndPatching,
-                                      scoped_refptr<ComponentUnpacker>(this),
-                                      kNone,
-                                      0));
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&ComponentUnpacker::EndPatching,
+                   scoped_refptr<ComponentUnpacker>(this), kNone, 0));
   }
   return true;
 }
 
 void ComponentUnpacker::EndPatching(Error error, int extended_error) {
   error_ = error;
   extended_error_ = extended_error;
   patcher_ = NULL;
   if (error_ != kNone) {
     Finish();
     return;
   }
   // Optimization: clean up patch files early, in case disk space is too low to
   // install otherwise.
   if (!unpack_diff_path_.empty()) {
     base::DeleteFile(unpack_diff_path_, true);
     unpack_diff_path_.clear();
   }
   Install();
   Finish();
 }
 
 void ComponentUnpacker::Install() {
   // Write the fingerprint to disk.
   if (static_cast<int>(fingerprint_.size()) !=
       base::WriteFile(
           unpack_path_.Append(FILE_PATH_LITERAL("manifest.fingerprint")),
-          fingerprint_.c_str(),
-          base::checked_cast<int>(fingerprint_.size()))) {
+          fingerprint_.c_str(), base::checked_cast<int>(fingerprint_.size()))) {
     error_ = kFingerprintWriteFailed;
     return;
   }
   scoped_ptr<base::DictionaryValue> manifest(ReadManifest(unpack_path_));
   if (!manifest.get()) {
     error_ = kBadManifest;
     return;
   }
   DCHECK(error_ == kNone);
   if (!installer_->Install(*manifest, unpack_path_)) {
     error_ = kInstallerError;
     return;
   }
 }
 
 void ComponentUnpacker::Finish() {
   if (!unpack_diff_path_.empty())
     base::DeleteFile(unpack_diff_path_, true);
   if (!unpack_path_.empty())
     base::DeleteFile(unpack_path_, true);
   callback_.Run(error_, extended_error_);
 }
 
 ComponentUnpacker::~ComponentUnpacker() {
 }
 
-}  // namespace component_updater
+}  // namespace update_client