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_METHOD8(OnExtensionDownloadFinished,
+               void(const std::string&,
+                    const base::FilePath&,
+                    const std::string&,
+                    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 316 matching lines @@
     install_path_ = extension_path;
 
     if (ContainsKey(fake_crx_installers_, id)) {
       *out_crx_installer = fake_crx_installers_[id];
       return true;
     }
 
     return false;
   }
 
+  bool CheckAndUpdateExtension(const std::string& id,
+                               const base::FilePath& extension_path,
+                               const std::string& hash,
+                               bool file_ownership_passed,
+                               CrxInstaller** out_crx_installer) override {
+    return UpdateExtension(
+        id, extension_path, file_ownership_passed, out_crx_installer);
+  }
+
   PendingExtensionManager* pending_extension_manager() override {
     return &pending_extension_manager_;
   }
 
   const Extension* GetExtensionById(const std::string& id,
                                     bool) const override {
     last_inquired_extension_id_ = id;
     return NULL;
   }
 
@@ skipping 686 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));
+      EXPECT_CALL(delegate,
+                  OnExtensionDownloadFinished(
+                      id, _, _, _, _, 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