Componentize component_updater: Move over a bunch of files to the component.

components/component_updater/component_unpacker.cc

 // Copyright (c) 2012 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_unpacker.h"
+#include "components/component_updater/component_unpacker.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/files/file_path.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 "chrome/browser/component_updater/component_patcher.h"
-#include "chrome/browser/component_updater/component_patcher_operation.h"
-#include "chrome/browser/component_updater/component_updater_service.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 "crypto/secure_hash.h"
 #include "crypto/signature_verifier.h"
 #include "third_party/zlib/google/zip.h"
 
 using crypto::SecureHash;
 
 namespace component_updater {
 
@@ skipping 21 matching lines @@
     if (len < header.key_size)
       return;
 
     std::vector<uint8> signature(header.signature_size);
     len = fread(&signature[0], sizeof(uint8), header.signature_size, crx_file);
     if (len < header.signature_size)
       return;
 
     crypto::SignatureVerifier verifier;
     if (!verifier.VerifyInit(crx_file::kSignatureAlgorithm,
-                             sizeof(crx_file::kSignatureAlgorithm),
+                             base::checked_cast<int>(
+                                 sizeof(crx_file::kSignatureAlgorithm)),
                              &signature[0],
-                             signature.size(),
+                             base::checked_cast<int>(signature.size()),
                              &key[0],
-                             key.size())) {
+                             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[]> buf(new uint8[kBufSize]);
     while ((len = fread(buf.get(), 1, kBufSize, crx_file)) > 0)
-      verifier.VerifyUpdate(buf.get(), len);
+      verifier.VerifyUpdate(buf.get(), base::checked_cast<int>(len));
 
     if (!verifier.VerifyFinal())
       return;
 
     public_key_.swap(key);
     valid_ = true;
   }
 
   bool valid() const { return valid_; }
 
@@ skipping 159 matching lines @@
   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(),
-          fingerprint_.size())) {
+          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