Add a component updater for the CLD2 data file.

chrome/browser/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 <string>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 125 matching lines @@
   return Verify() && Unzip() && BeginPatching();
 }
 
 void ComponentUnpacker::Unpack(const Callback& callback) {
   callback_ = callback;
   if (!UnpackInternal())
     Finish();
 }
 
 bool ComponentUnpacker::Verify() {
+  VLOG(1) << "Verifying component: " << path_.value();
   if (pk_hash_.empty() || path_.empty()) {
     error_ = kInvalidParams;
     return false;
   }
   // First, validate the CRX header and signature. As of today
   // this is SHA1 with RSA 1024.
   ScopedStdioHandle file(base::OpenFile(path_, "rb"));
   if (!file.get()) {
     error_ = kInvalidFile;
     return false;
   }
   CRXValidator validator(file.get());
   file.Close();
   if (!validator.valid()) {
     error_ = kInvalidFile;
     return false;
   }
   is_delta_ = validator.is_delta();
 
   // File is valid and the digital signature matches. Now make sure
   // the public key hash matches the expected hash. If they do we fully
   // trust this CRX.
   uint8 hash[32] = {};
   scoped_ptr<SecureHash> sha256(SecureHash::Create(SecureHash::SHA256));
   sha256->Update(&(validator.public_key()[0]), validator.public_key().size());
   sha256->Finish(hash, arraysize(hash));
 
   if (!std::equal(pk_hash_.begin(), pk_hash_.end(), hash)) {
+    VLOG(1) << "Hash mismatch: " << path_.value();
     error_ = kInvalidId;
     return false;
   }
+  VLOG(1) << "Verification successful: " << path_.value();
   return true;
 }
 
 bool ComponentUnpacker::Unzip() {
   base::FilePath& destination = is_delta_ ? unpack_diff_path_ : unpack_path_;
+  VLOG(1) << "Unpacking in: " << destination.value();
   if (!base::CreateNewTempDirectory(base::FilePath::StringType(),
                                     &destination)) {
+    VLOG(1) << "Unable to create temporary directory for unpacking.";
     error_ = kUnzipPathError;
     return false;
   }
   if (!zip::Unzip(path_, destination)) {
+    VLOG(1) << "Unzipping failed.";
     error_ = kUnzipFailed;
     return false;
   }
+  VLOG(1) << "Unpacked successfully";
   return true;
 }
 
 
 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;
@@ skipping 65 matching lines @@
     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