Validate hash_sha256 checksum on .crx update.

chrome/browser/extensions/updater/extension_updater_unittest.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 <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 127 matching lines @@
     ManifestFetchData::kNeverPinged,
     true,
     0);
 
 class MockExtensionDownloaderDelegate : public ExtensionDownloaderDelegate {
  public:
   MOCK_METHOD4(OnExtensionDownloadFailed, void(const std::string&,
                                                Error,
                                                const PingResult&,
                                                const std::set<int>&));
-  MOCK_METHOD7(OnExtensionDownloadFinished, void(const std::string&,
-                                                 const base::FilePath&,
-                                                 bool,
-                                                 const GURL&,
-                                                 const std::string&,
-                                                 const PingResult&,
-                                                 const std::set<int>&));
+  MOCK_METHOD6(OnExtensionDownloadFinished,
+               void(const extensions::CRXFileInfo&,
+                    bool,
+                    const GURL&,
+                    const std::string&,
+                    const PingResult&,
+                    const std::set<int>&));
   MOCK_METHOD2(GetPingDataForExtension,
                bool(const std::string&, ManifestFetchData::PingData*));
   MOCK_METHOD1(GetUpdateUrlData, std::string(const std::string&));
   MOCK_METHOD1(IsExtensionPending, bool(const std::string&));
   MOCK_METHOD2(GetExtensionExistingVersion,
                bool(const std::string&, std::string*));
 
   void Wait() {
     scoped_refptr<content::MessageLoopRunner> runner =
         new content::MessageLoopRunner;
     quit_closure_ = runner->QuitClosure();
     runner->Run();
     quit_closure_.Reset();
   }
 
   void Quit() {
     quit_closure_.Run();
   }
 
   void DelegateTo(ExtensionDownloaderDelegate* delegate) {
     ON_CALL(*this, OnExtensionDownloadFailed(_, _, _, _))
         .WillByDefault(Invoke(delegate,
             &ExtensionDownloaderDelegate::OnExtensionDownloadFailed));
-    ON_CALL(*this, OnExtensionDownloadFinished(_, _, _, _, _, _, _))
-        .WillByDefault(Invoke(delegate,
-            &ExtensionDownloaderDelegate::OnExtensionDownloadFinished));
+    ON_CALL(*this, OnExtensionDownloadFinished(_, _, _, _, _, _))
+        .WillByDefault(
+            Invoke(delegate,
+                   &ExtensionDownloaderDelegate::OnExtensionDownloadFinished));
     ON_CALL(*this, GetPingDataForExtension(_, _))
         .WillByDefault(Invoke(delegate,
             &ExtensionDownloaderDelegate::GetPingDataForExtension));
     ON_CALL(*this, GetUpdateUrlData(_))
         .WillByDefault(Invoke(delegate,
             &ExtensionDownloaderDelegate::GetUpdateUrlData));
     ON_CALL(*this, IsExtensionPending(_))
         .WillByDefault(Invoke(delegate,
             &ExtensionDownloaderDelegate::IsExtensionPending));
     ON_CALL(*this, GetExtensionExistingVersion(_, _))
@@ skipping 301 matching lines @@
   explicit ServiceForDownloadTests(TestExtensionPrefs* prefs)
       : MockService(prefs) {
   }
 
   // Add a fake crx installer to be returned by a call to UpdateExtension()
   // with a specific ID.  Caller keeps ownership of |crx_installer|.
   void AddFakeCrxInstaller(const std::string& id, CrxInstaller* crx_installer) {
     fake_crx_installers_[id] = crx_installer;
   }
 
-  bool UpdateExtension(const std::string& id,
-                       const base::FilePath& extension_path,
+  bool UpdateExtension(const CRXFileInfo& file,
                        bool file_ownership_passed,
                        CrxInstaller** out_crx_installer) override {
-    extension_id_ = id;
-    install_path_ = extension_path;
+    extension_id_ = file.extension_id;
+    install_path_ = file.path;
 
-    if (ContainsKey(fake_crx_installers_, id)) {
-      *out_crx_installer = fake_crx_installers_[id];
+    if (ContainsKey(fake_crx_installers_, extension_id_)) {
+      *out_crx_installer = fake_crx_installers_[extension_id_];
       return true;
     }
 
     return false;
   }
 
   PendingExtensionManager* pending_extension_manager() override {
     return &pending_extension_manager_;
   }
 
@@ skipping 693 matching lines @@
 
     fetcher->set_url(test_url);
     fetcher->set_status(net::URLRequestStatus());
     if (fail) {
       fetcher->set_response_code(404);
       EXPECT_CALL(delegate, OnExtensionDownloadFailed(id, _, _, requests));
     } else {
       fetcher->set_response_code(200);
       fetcher->SetResponseFilePath(extension_file_path);
       EXPECT_CALL(delegate, OnExtensionDownloadFinished(
-          id, _, _, _, version.GetString(), _, requests));
+                                CRXFileInfo(id, extension_file_path, hash), _,
+                                _, version.GetString(), _, requests));
     }
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     RunUntilIdle();
 
     if (fail) {
       // Don't expect any extension to have been installed.
       EXPECT_TRUE(service->extension_id().empty());
     } else {
       // Expect that ExtensionUpdater asked the mock extensions service to
@@ skipping 1009 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -malformed update url (empty, file://, has query, has a # fragment, etc.)
 // -An extension gets uninstalled while updates are in progress (so it doesn't
 //  "come back from the dead")
 // -An extension gets manually updated to v3 while we're downloading v2 (ie
 //  you don't get downgraded accidentally)
 // -An update manifest mentions multiple updates
 
 }  // namespace extensions