Validate hash_sha256 checksum on .crx update.

chrome/browser/chromeos/app_mode/kiosk_external_updater.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 "chrome/browser/chromeos/app_mode/kiosk_external_updater.h"
 
 #include "base/bind.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
@@ skipping 75 matching lines @@
     return true;
   else
     return false;
 }
 
 }  // namespace
 
 KioskExternalUpdater::ExternalUpdate::ExternalUpdate() {
 }
 
+KioskExternalUpdater::ExternalUpdate::~ExternalUpdate() {
+}
+
 KioskExternalUpdater::KioskExternalUpdater(
     const scoped_refptr<base::SequencedTaskRunner>& backend_task_runner,
     const base::FilePath& crx_cache_dir,
     const base::FilePath& crx_unpack_dir)
     : backend_task_runner_(backend_task_runner),
       crx_cache_dir_(crx_cache_dir),
       crx_unpack_dir_(crx_unpack_dir),
       weak_factory_(this) {
   // Subscribe to DiskMountManager.
   DCHECK(disks::DiskMountManager::GetInstance());
@@ skipping 83 matching lines @@
   if (!ShouldDoExternalUpdate(app_id, version, min_browser_version)) {
     external_updates_[app_id].update_status = FAILED;
     MaybeValidateNextExternalUpdate();
     return;
   }
 
   // User might pull out the usb stick before updating is completed.
   if (CheckExternalUpdateInterrupted())
     return;
 
-  base::FilePath external_crx_path = external_updates_[app_id].external_crx;
+  base::FilePath external_crx_path =
+      external_updates_[app_id].external_crx.path;
   base::FilePath temp_crx_path =
       crx_unpack_dir_.Append(external_crx_path.BaseName());
   bool* success = new bool;
   backend_task_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&CopyExternalCrxAndDeleteTempDir,
                  external_crx_path,
                  temp_crx_path,
                  temp_dir,
                  success),
@@ skipping 74 matching lines @@
       }
     }
 
     ExternalUpdate update;
     KioskAppManager::App app;
     if (KioskAppManager::Get()->GetApp(app_id, &app)) {
       update.app_name = app.name;
     } else {
       NOTREACHED();
     }
-    update.external_crx = external_update_path_.AppendASCII(external_crx_str);
+    update.external_crx = extensions::CRXFileInfo(
+        app_id, external_update_path_.AppendASCII(external_crx_str));
     update.update_status = PENDING;
     external_updates_[app_id] = update;
   }
 
   if (external_updates_.empty()) {
     NotifyKioskUpdateProgress(
         ui::ResourceBundle::GetSharedInstance().GetLocalizedString(
             IDS_KIOSK_EXTERNAL_UPDATE_NO_UPDATES));
     KioskAppManager::Get()->OnKioskAppExternalUpdateComplete(false);
     return;
@@ skipping 14 matching lines @@
   return false;
 }
 
 void KioskExternalUpdater::ValidateExternalUpdates() {
   for (ExternalUpdateMap::iterator it = external_updates_.begin();
        it != external_updates_.end();
        ++it) {
     if (it->second.update_status == PENDING) {
       scoped_refptr<KioskExternalUpdateValidator> crx_validator =
           new KioskExternalUpdateValidator(backend_task_runner_,
-                                           it->first,
                                            it->second.external_crx,
                                            crx_unpack_dir_,
                                            weak_factory_.GetWeakPtr());
       crx_validator->Start();
       break;
     }
   }
 }
 
 bool KioskExternalUpdater::IsExternalUpdatePending() {
@@ skipping 82 matching lines @@
 void KioskExternalUpdater::OnPutValidatedExtension(const std::string& app_id,
                                                    bool success) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (CheckExternalUpdateInterrupted())
     return;
 
   if (!success) {
     external_updates_[app_id].update_status = FAILED;
     external_updates_[app_id].error = l10n_util::GetStringFUTF16(
         IDS_KIOSK_EXTERNAL_UPDATE_CANNOT_INSTALL_IN_LOCAL_CACHE,
-        base::UTF8ToUTF16(external_updates_[app_id].external_crx.value()));
+        base::UTF8ToUTF16(external_updates_[app_id].external_crx.path.value()));
   } else {
     external_updates_[app_id].update_status = SUCCESS;
   }
 
   // Validate the next pending external update.
   MaybeValidateNextExternalUpdate();
 }
 
 void KioskExternalUpdater::MaybeValidateNextExternalUpdate() {
   if (IsExternalUpdatePending())
@@ skipping 78 matching lines @@
   if (failed) {
     failed_app_msg = ui::ResourceBundle::GetSharedInstance().GetLocalizedString(
                          IDS_KIOSK_EXTERNAL_UPDATE_FAILED_UPDATED_APPS) +
                      base::ASCIIToUTF16("\n") + failed_apps;
     message = message + base::ASCIIToUTF16("\n") + failed_app_msg;
   }
   return message;
 }
 
 }  // namespace chromeos