Validate hash_sha256 checksum on .crx update.

chrome/browser/extensions/updater/extension_updater.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/extensions/updater/extension_updater.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 172 matching lines @@
 namespace extensions {
 
 ExtensionUpdater::CheckParams::CheckParams()
     : install_immediately(false) {}
 
 ExtensionUpdater::CheckParams::~CheckParams() {}
 
 ExtensionUpdater::FetchedCRXFile::FetchedCRXFile(
     const std::string& i,
     const base::FilePath& p,
+    const std::string& h,
     bool file_ownership_passed,
     const std::set<int>& request_ids)
     : extension_id(i),
       path(p),
+      hash(h),
       file_ownership_passed(file_ownership_passed),
-      request_ids(request_ids) {}
+      request_ids(request_ids) {
+}
 
 ExtensionUpdater::FetchedCRXFile::FetchedCRXFile()
     : path(), file_ownership_passed(true) {}
 
 ExtensionUpdater::FetchedCRXFile::~FetchedCRXFile() {}
 
 ExtensionUpdater::InProgressCheck::InProgressCheck()
     : install_immediately(false) {}
 
 ExtensionUpdater::InProgressCheck::~InProgressCheck() {}
@@ skipping 376 matching lines @@
   // check might have queued an update for this extension already. If a
   // current update check has |install_immediately| set the previously
   // queued update should be installed now.
   if (install_immediately && service_->GetPendingExtensionUpdate(id))
     service_->FinishDelayedInstallation(id);
 }
 
 void ExtensionUpdater::OnExtensionDownloadFinished(
     const std::string& id,
     const base::FilePath& path,
+    const std::string& hash,
     bool file_ownership_passed,
     const GURL& download_url,
     const std::string& version,
     const PingResult& ping,
     const std::set<int>& request_ids) {
   DCHECK(alive_);
   UpdatePingData(id, ping);
 
   VLOG(2) << download_url << " written to " << path.value();
 
-  FetchedCRXFile fetched(id, path, file_ownership_passed, request_ids);
+  FetchedCRXFile fetched(id, path, hash, file_ownership_passed, request_ids);
   fetched_crx_files_.push(fetched);
 
   // MaybeInstallCRXFile() removes extensions from |in_progress_ids_| after
   // starting the crx installer.
   MaybeInstallCRXFile();
 }
 
 bool ExtensionUpdater::GetPingDataForExtension(
     const std::string& id,
     ManifestFetchData::PingData* ping_data) {
@@ skipping 64 matching lines @@
 
   while (!fetched_crx_files_.empty() && !crx_install_is_running_) {
     const FetchedCRXFile& crx_file = fetched_crx_files_.top();
 
     VLOG(2) << "updating " << crx_file.extension_id
             << " with " << crx_file.path.value();
 
     // The ExtensionService is now responsible for cleaning up the temp file
     // at |crx_file.path|.
     CrxInstaller* installer = NULL;
-    if (service_->UpdateExtension(crx_file.extension_id,
-                                  crx_file.path,
-                                  crx_file.file_ownership_passed,
-                                  &installer)) {
+    if (service_->CheckAndUpdateExtension(
+            crx_file.extension_id, crx_file.path, crx_file.hash,
+            crx_file.file_ownership_passed, &installer)) {
       crx_install_is_running_ = true;
       current_crx_file_ = crx_file;
 
       for (std::set<int>::const_iterator it = crx_file.request_ids.begin();
           it != crx_file.request_ids.end(); ++it) {
         InProgressCheck& request = requests_in_progress_[*it];
         if (request.install_immediately) {
           installer->set_install_immediately(true);
           break;
         }
@@ skipping 63 matching lines @@
   const InProgressCheck& request = requests_in_progress_[request_id];
   if (request.in_progress_ids_.empty()) {
     VLOG(2) << "Finished update check " << request_id;
     if (!request.callback.is_null())
       request.callback.Run();
     requests_in_progress_.erase(request_id);
   }
 }
 
 }  // namespace extensions