Install CRX updates one at a time.

chrome/browser/extensions/extension_updater_unittest.cc

 // Copyright (c) 2011 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 <map>
 
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/version.h"
+#include "chrome/browser/extensions/crx_installer.h"
 #include "chrome/browser/extensions/extension_error_reporter.h"
 #include "chrome/browser/extensions/extension_sync_data.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/test_extension_prefs.h"
 #include "chrome/browser/extensions/test_extension_service.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/net/test_url_fetcher_factory.h"
 #include "chrome/common/pref_names.h"
@@ skipping 142 matching lines @@
   void set_extensions(ExtensionList extensions) {
     extensions_ = extensions;
   }
 
  private:
   ExtensionList extensions_;
 };
 
 class ServiceForDownloadTests : public MockService {
  public:
-  virtual void UpdateExtension(const std::string& id,
-                               const FilePath& extension_path,
-                               const GURL& download_url) {
+  ServiceForDownloadTests()
+      : MockService() {
+  }
+
+  // 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(std::string& id,
+                           CrxInstaller* crx_installer) {
+    fake_crx_installers_[id] = crx_installer;
+  }
+
+  bool UpdateExtension(
+      const std::string& id,
+      const FilePath& extension_path,
+      const GURL& download_url,
+      Source<CrxInstaller>* out_install_notification_source) OVERRIDE {
     extension_id_ = id;
     install_path_ = extension_path;
     download_url_ = download_url;
+
+    if (ContainsKey(fake_crx_installers_, id)) {
+      *out_install_notification_source =
+          Source<CrxInstaller>(fake_crx_installers_[id]);
+      return true;
+    }
+
+    return false;
   }
 
   virtual PendingExtensionManager* pending_extension_manager() OVERRIDE {
     return &pending_extension_manager_;
   }
 
   virtual const Extension* GetExtensionById(
       const std::string& id, bool) const OVERRIDE {
     last_inquired_extension_id_ = id;
     return NULL;
   }
 
   const std::string& extension_id() const { return extension_id_; }
   const FilePath& install_path() const { return install_path_; }
   const GURL& download_url() const { return download_url_; }
   const std::string& last_inquired_extension_id() const {
     return last_inquired_extension_id_;
   }
 
  private:
+  // Hold the set of ids that UpdateExtension() should fake success on.
+  // UpdateExtension(id, ...) will return true iff fake_crx_installers_
+  // contains key |id|.  |out_install_notification_source| will be set
+  // to Source<CrxInstaller(fake_crx_installers_[i]).
+  std::map<std::string, CrxInstaller*> fake_crx_installers_;
+
   std::string extension_id_;
   FilePath install_path_;
   GURL download_url_;
 
   // The last extension ID that GetExtensionById was called with.
   // Mutable because the method that sets it (GetExtensionById) is const
   // in the actual extension service, but must record the last extension
   // ID in this test class.
   mutable std::string last_inquired_extension_id_;
 };
@@ skipping 331 matching lines @@
     BrowserThread ui_thread(BrowserThread::UI, &ui_loop);
     BrowserThread file_thread(BrowserThread::FILE);
     file_thread.Start();
     BrowserThread io_thread(BrowserThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
     URLFetcher::set_factory(&factory);
     scoped_ptr<ServiceForDownloadTests> service(new ServiceForDownloadTests);
-    ExtensionUpdater updater(service.get(), service->extension_prefs(),
+    ExtensionUpdater updater(service.get(),
+                             service->extension_prefs(),
                              service->pref_service(),
                              service->profile(),
                              kUpdateFrequencySecs);
     updater.Start();
 
     GURL url1("http://localhost/manifest1");
     GURL url2("http://localhost/manifest2");
 
     // Request 2 update checks - the first should begin immediately and the
     // second one should be queued up.
@@ skipping 165 matching lines @@
     // The updater should have called extension service to process the
     // blacklist.
     EXPECT_TRUE(service.processed_blacklist());
 
     EXPECT_EQ(version, service.pref_service()->
       GetString(prefs::kExtensionBlacklistUpdateVersion));
 
     URLFetcher::set_factory(NULL);
   }
 
-  static void TestMultipleExtensionDownloading() {
+  // Two extensions are updated.  If |updates_start_running| is true, the
+  // mock extensions service has UpdateExtension(...) return true, and
+  // the test is responsible for creating fake CrxInstallers.  Otherwise,
+  // UpdateExtension() returns false, signaling install failures.
+  static void TestMultipleExtensionDownloading(bool updates_start_running) {
     MessageLoopForUI message_loop;
     BrowserThread ui_thread(BrowserThread::UI, &message_loop);
     BrowserThread file_thread(BrowserThread::FILE, &message_loop);
     BrowserThread io_thread(BrowserThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
     URLFetcher::set_factory(&factory);
     ServiceForDownloadTests service;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), kUpdateFrequencySecs);
     updater.Start();
 
+    EXPECT_FALSE(updater.crx_install_is_running_);
+
     GURL url1("http://localhost/extension1.crx");
     GURL url2("http://localhost/extension2.crx");
 
     std::string id1 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string id2 = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb";
 
     std::string hash1 = "";
     std::string hash2 = "";
 
     std::string version1 = "0.1";
     std::string version2 = "0.1";
     // Start two fetches
     updater.FetchUpdatedExtension(id1, url1, hash1, version1);
     updater.FetchUpdatedExtension(id2, url2, hash2, version2);
 
     // Make the first fetch complete.
     FilePath extension_file_path(FILE_PATH_LITERAL("/whatever"));
 
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
 
+    const base::WeakPtr<ExtensionService> kNullExtensionsService;
+    scoped_refptr<CrxInstaller> fake_crx1(
+        new CrxInstaller(kNullExtensionsService, NULL));
+    scoped_refptr<CrxInstaller> fake_crx2(
+        new CrxInstaller(kNullExtensionsService, NULL));
+
+    if (updates_start_running) {
+      // Add fake CrxInstaller to be returned by service.UpdateExtension().
+      service.AddFakeCrxInstaller(id1, fake_crx1.get());
+      service.AddFakeCrxInstaller(id2, fake_crx2.get());
+    } else {
+      // If we don't add fake CRX installers, the mock service fakes a failure
+      // starting the install.
+    }
+
     fetcher->set_url(url1);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(200);
     fetcher->SetResponseFilePath(extension_file_path);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
 
     message_loop.RunAllPending();
 
     // Expect that the service was asked to do an install with the right data.
     FilePath tmpfile_path = service.install_path();
     EXPECT_FALSE(tmpfile_path.empty());
     EXPECT_EQ(id1, service.extension_id());
     EXPECT_EQ(url1, service.download_url());
     message_loop.RunAllPending();
 
     // Make sure the second fetch finished and asked the service to do an
     // update.
     FilePath extension_file_path2(FILE_PATH_LITERAL("/whatever2"));
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
 
     fetcher->set_url(url2);
     fetcher->set_status(net::URLRequestStatus());
     fetcher->set_response_code(200);
     fetcher->SetResponseFilePath(extension_file_path2);
     fetcher->delegate()->OnURLFetchComplete(fetcher);
     message_loop.RunAllPending();
+
+    if (updates_start_running) {
+      EXPECT_TRUE(updater.crx_install_is_running_);
+
+      // The second install should not have run, because the first has not
+      // sent a notification that it finished.
+      EXPECT_EQ(id1, service.extension_id());
+      EXPECT_EQ(url1, service.download_url());
+
+      // Fake install notice.  This should start the second installation,
+      // which will be checked below.
+      fake_crx1->NotifyCrxInstallComplete();
+
+      EXPECT_TRUE(updater.crx_install_is_running_);
+    }
+
     EXPECT_EQ(id2, service.extension_id());
     EXPECT_EQ(url2, service.download_url());
     EXPECT_FALSE(service.install_path().empty());
 
     // Make sure the correct crx contents were passed for the update call.
     EXPECT_EQ(extension_file_path2, service.install_path());
+
+    if (updates_start_running) {
+      EXPECT_TRUE(updater.crx_install_is_running_);
+      fake_crx2->NotifyCrxInstallComplete();
+    }
+    EXPECT_FALSE(updater.crx_install_is_running_);
   }
 
   // Test requests to both a Google server and a non-google server. This allows
   // us to test various combinations of installed (ie roll call) and active
   // (ie app launch) ping scenarios. The invariant is that each type of ping
   // value should be present at most once per day, and can be calculated based
   // on the delta between now and the last ping time (or in the case of active
   // pings, that delta plus whether the app has been active).
   static void TestGalleryRequests(int rollcall_ping_days,
                                   int active_ping_days,
@@ skipping 187 matching lines @@
 
 TEST(ExtensionUpdaterTest, TestSingleExtensionDownloadingPending) {
   ExtensionUpdaterTest::TestSingleExtensionDownloading(true);
 }
 
 // This test is disabled on Mac, see http://crbug.com/26035.
 TEST(ExtensionUpdaterTest, TestBlacklistDownloading) {
   ExtensionUpdaterTest::TestBlacklistDownloading();
 }
 
-TEST(ExtensionUpdaterTest, TestMultipleExtensionDownloading) {
-  ExtensionUpdaterTest::TestMultipleExtensionDownloading();
+TEST(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesFail) {
+  ExtensionUpdaterTest::TestMultipleExtensionDownloading(false);
+}
+TEST(ExtensionUpdaterTest, TestMultipleExtensionDownloadingUpdatesSucceed) {
+  ExtensionUpdaterTest::TestMultipleExtensionDownloading(true);
 }
 
 TEST(ExtensionUpdaterTest, TestGalleryRequests) {
   // We want to test a variety of combinations of expected ping conditions for
   // rollcall and active pings.
   int ping_cases[] = { ManifestFetchData::kNeverPinged, 0, 1, 5 };
 
   for (size_t i = 0; i < arraysize(ping_cases); i++) {
     for (size_t j = 0; j < arraysize(ping_cases); j++) {
       for (size_t k = 0; k < 2; k++) {
@@ skipping 121 matching lines @@
 
 // TODO(asargent) - (http://crbug.com/12780) add tests for:
 // -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