Adding ExtensionPrefs methods for storing update-when-idle data....

chrome/browser/extensions/extension_updater_unittest.cc

 // Copyright (c) 2009 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/file_util.h"
 #include "base/rand_util.h"
 #include "base/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "base/thread.h"
 #include "base/version.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/browser/extensions/extension_updater.h"
 #include "chrome/browser/extensions/extensions_service.h"
-#include "chrome/browser/json_pref_store.h"
+#include "chrome/browser/extensions/test_extension_prefs.h"
 #include "chrome/browser/net/test_url_fetcher_factory.h"
 #include "chrome/browser/pref_service.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/extensions/extension_error_reporter.h"
 #include "chrome/common/pref_names.h"
 #include "net/base/escape.h"
 #include "net/base/load_flags.h"
 #include "net/url_request/url_request_status.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "libxml/globals.h"
 
 #if defined(OS_MACOSX)
 // These tests crash frequently on Mac 10.5 Tests debug. http://crbug.com/26035.
 #define MAYBE_TestBlacklistDownloading DISABLED_TestBlacklistDownloading
 #define MAYBE_TestBlacklistUpdateCheckRequests DISABLED_TestBlacklistUpdateCheckRequests
 #else
 #define MAYBE_TestBlacklistDownloading TestBlacklistDownloading
 #define MAYBE_TestBlacklistUpdateCheckRequests TestBlacklistUpdateCheckRequests
 #endif
 
 using base::Time;
 using base::TimeDelta;
 
 static int expected_load_flags =
     net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SAVE_COOKIES;
 
-// Do-nothing base class for further specialized test classes.
+// Base class for further specialized test classes.
 class MockService : public ExtensionUpdateService {
  public:
   MockService() {}
   virtual ~MockService() {}
 
   virtual const ExtensionList* extensions() const {
     EXPECT_TRUE(false);
     return NULL;
   }
 
@@ skipping 16 matching lines @@
   virtual void UpdateExtensionBlacklist(
     const std::vector<std::string>& blacklist) {
     EXPECT_TRUE(false);
   }
 
   virtual bool HasInstalledExtensions() {
     EXPECT_TRUE(false);
     return false;
   }
 
-  virtual void SetLastPingDay(const std::string& extension_id,
-                              const Time& time) {
-    last_ping_days_[extension_id] = time;
-  }
+  virtual ExtensionPrefs* extension_prefs() { return prefs_.prefs(); }
 
-  virtual Time LastPingDay(const std::string& extension_id) const {
-    std::map<std::string, Time>::const_iterator i =
-        last_ping_days_.find(extension_id);
-    if (i != last_ping_days_.end())
-      return i->second;
+  PrefService* pref_service() { return prefs_.pref_service(); }
 
-    return Time();
-  }
-
-  virtual void SetBlacklistLastPingDay(const Time& time) {
-    blacklist_last_ping_day_ = time;
-  }
-
-  virtual Time BlacklistLastPingDay() const {
-    return blacklist_last_ping_day_;
+  // Creates test extensions and inserts them into list. The name and
+  // version are all based on their index. If |update_url| is non-null, it
+  // will be used as the update_url for each extension.
+  void CreateTestExtensions(int count, ExtensionList *list,
+                            const std::string* update_url) {
+    for (int i = 1; i <= count; i++) {
+      DictionaryValue manifest;
+      manifest.SetString(extension_manifest_keys::kVersion,
+                         StringPrintf("%d.0.0.0", i));
+      manifest.SetString(extension_manifest_keys::kName,
+                         StringPrintf("Extension %d", i));
+      if (update_url)
+        manifest.SetString(extension_manifest_keys::kUpdateURL, *update_url);
+      Extension* e = prefs_.AddExtensionWithManifest(manifest);
+      ASSERT_TRUE(e != NULL);
+      list->push_back(e);
+    }
   }
 
  protected:
   PendingExtensionMap pending_extensions_;
+  TestExtensionPrefs prefs_;
 
  private:
-  std::map<std::string, Time> last_ping_days_;
-  Time blacklist_last_ping_day_;
   DISALLOW_COPY_AND_ASSIGN(MockService);
 };
 
-// Class that contains a PrefService and handles cleanup of a temporary file
-// backing it.
-class ScopedTempPrefService {
- public:
-  ScopedTempPrefService() {
-    // Make sure different tests won't use the same prefs file. It will cause
-    // problem when different tests are running in parallel.
-    temp_dir_.CreateUniqueTempDir();
-    FilePath pref_file = temp_dir_.path().AppendASCII("prefs");
-    prefs_.reset(new PrefService(new JsonPrefStore(pref_file)));
-  }
 
-  ~ScopedTempPrefService() {}
-
-  PrefService* get() {
-    return prefs_.get();
-  }
-
- private:
-  // Ordering matters, we want |prefs_| to be destroyed before |temp_dir_|.
-  ScopedTempDir temp_dir_;
-  scoped_ptr<PrefService> prefs_;
-};
-
-// Creates test extensions and inserts them into list. The name and
-// version are all based on their index. If |update_url| is non-null, it
-// will be used as the update_url for each extension.
-void CreateTestExtensions(int count, ExtensionList *list,
-                          const std::string* update_url) {
-  for (int i = 1; i <= count; i++) {
-    DictionaryValue input;
-#if defined(OS_WIN)
-    FilePath path(StringPrintf(L"c:\\extension%i", i));
-#else
-    FilePath path(StringPrintf("/extension%i", i));
-#endif
-    Extension* e = new Extension(path);
-    e->set_location(Extension::INTERNAL);
-    input.SetString(extension_manifest_keys::kVersion,
-                    StringPrintf("%d.0.0.0", i));
-    input.SetString(extension_manifest_keys::kName,
-                    StringPrintf("Extension %d", i));
-    if (update_url)
-      input.SetString(extension_manifest_keys::kUpdateURL, *update_url);
-    std::string error;
-    EXPECT_TRUE(e->InitFromValue(input, false, &error));
-    list->push_back(e);
-  }
+std::string GenerateId(std::string input) {
+  std::string result;
+  EXPECT_TRUE(Extension::GenerateId(input, &result));
+  return result;
 }
 
 // Creates test pending extensions and inserts them into list. The
 // name and version are all based on their index.
 void CreateTestPendingExtensions(int count, const GURL& update_url,
                                  PendingExtensionMap* pending_extensions) {
   for (int i = 1; i <= count; i++) {
     bool is_theme = (i % 2) == 0;
     const bool kInstallSilently = true;
     scoped_ptr<Version> version(
         Version::GetVersionFromString(StringPrintf("%d.0.0.0", i)));
     ASSERT_TRUE(version.get());
-    (*pending_extensions)[StringPrintf("extension%i", i)] =
+    std::string id = GenerateId(StringPrintf("extension%i", i));
+    (*pending_extensions)[id] =
         PendingExtensionInfo(update_url, *version,
                              is_theme, kInstallSilently);
   }
 }
 
 class ServiceForManifestTests : public MockService {
  public:
   ServiceForManifestTests() : has_installed_extensions_(false) {}
 
   virtual ~ServiceForManifestTests() {}
@@ skipping 145 matching lines @@
   static void TestExtensionUpdateCheckRequests(bool pending) {
     // Create an extension with an update_url.
     ServiceForManifestTests service;
     std::string update_url("http://foo.com/bar");
     ExtensionList extensions;
     PendingExtensionMap pending_extensions;
     if (pending) {
       CreateTestPendingExtensions(1, GURL(update_url), &pending_extensions);
       service.set_pending_extensions(pending_extensions);
     } else {
-      CreateTestExtensions(1, &extensions, &update_url);
+      service.CreateTestExtensions(1, &extensions, &update_url);
       service.set_extensions(extensions);
     }
 
     // Setup and start the updater.
     MessageLoop message_loop;
     ChromeThread io_thread(ChromeThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     URLFetcher::set_factory(&factory);
-    ScopedTempPrefService prefs;
     scoped_refptr<ExtensionUpdater> updater =
-        new ExtensionUpdater(&service, prefs.get(), 60*60*24);
+        new ExtensionUpdater(&service, service.pref_service(), 60*60*24);
     updater->Start();
 
     // Tell the update that it's time to do update checks.
     SimulateTimerFired(updater.get());
 
     // Get the url our mock fetcher was asked to fetch.
     TestURLFetcher* fetcher =
         factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     const GURL& url = fetcher->original_url();
     EXPECT_FALSE(url.is_empty());
@@ skipping 30 matching lines @@
   static void TestBlacklistUpdateCheckRequests() {
     ServiceForManifestTests service;
 
     // Setup and start the updater.
     MessageLoop message_loop;
     ChromeThread io_thread(ChromeThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     URLFetcher::set_factory(&factory);
-    ScopedTempPrefService prefs;
     scoped_refptr<ExtensionUpdater> updater =
-        new ExtensionUpdater(&service, prefs.get(), 60*60*24);
+        new ExtensionUpdater(&service, service.pref_service(), 60*60*24);
     updater->Start();
 
     // Tell the updater that it's time to do update checks.
     SimulateTimerFired(updater.get());
 
     // No extensions installed, so nothing should have been fetched.
     TestURLFetcher* fetcher =
         factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     EXPECT_TRUE(fetcher == NULL);
 
@@ skipping 26 matching lines @@
     EXPECT_EQ("com.google.crx.blacklist", params["id"]);
     EXPECT_EQ("0", params["v"]);
     EXPECT_EQ("", params["uc"]);
     EXPECT_TRUE(ContainsKey(params, "ping"));
   }
 
   static void TestDetermineUpdates() {
     // Create a set of test extensions
     ServiceForManifestTests service;
     ExtensionList tmp;
-    CreateTestExtensions(3, &tmp, NULL);
+    service.CreateTestExtensions(3, &tmp, NULL);
     service.set_extensions(tmp);
 
     MessageLoop message_loop;
-    ScopedTempPrefService prefs;
     scoped_refptr<ExtensionUpdater> updater =
-        new ExtensionUpdater(&service, prefs.get(), kUpdateFrequencySecs);
+        new ExtensionUpdater(&service, service.pref_service(),
+                             kUpdateFrequencySecs);
 
     // Check passing an empty list of parse results to DetermineUpdates
     ManifestFetchData fetch_data(GURL("http://localhost/foo"));
     UpdateManifest::Results updates;
     std::vector<int> updateable = updater->DetermineUpdates(fetch_data,
                                                             updates);
     EXPECT_TRUE(updateable.empty());
 
     // Create two updates - expect that DetermineUpdates will return the first
     // one (v1.0 installed, v1.1 available) but not the second one (both
@@ skipping 15 matching lines @@
   }
 
   static void TestDetermineUpdatesPending() {
     // Create a set of test extensions
     ServiceForManifestTests service;
     PendingExtensionMap pending_extensions;
     CreateTestPendingExtensions(3, GURL(), &pending_extensions);
     service.set_pending_extensions(pending_extensions);
 
     MessageLoop message_loop;
-    ScopedTempPrefService prefs;
     scoped_refptr<ExtensionUpdater> updater =
-        new ExtensionUpdater(&service, prefs.get(), kUpdateFrequencySecs);
+        new ExtensionUpdater(&service, service.pref_service(),
+                             kUpdateFrequencySecs);
 
     ManifestFetchData fetch_data(GURL("http://localhost/foo"));
     UpdateManifest::Results updates;
     for (PendingExtensionMap::const_iterator it = pending_extensions.begin();
          it != pending_extensions.end(); ++it) {
       fetch_data.AddExtension(it->first,
                               it->second.version.GetString(),
                               ManifestFetchData::kNeverPinged);
       AddParseResult(it->first,
                      "1.1", "http://localhost/e1_1.1.crx", &updates);
@@ skipping 12 matching lines @@
     ChromeThread ui_thread(ChromeThread::UI, &ui_loop);
     ChromeThread file_thread(ChromeThread::FILE);
     file_thread.Start();
     ChromeThread io_thread(ChromeThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
     URLFetcher::set_factory(&factory);
     ServiceForDownloadTests service;
-    ScopedTempPrefService prefs;
     scoped_refptr<ExtensionUpdater> updater =
-        new ExtensionUpdater(&service, prefs.get(), kUpdateFrequencySecs);
+        new ExtensionUpdater(&service, service.pref_service(),
+                             kUpdateFrequencySecs);
 
     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.
     ManifestFetchData* fetch1 = new ManifestFetchData(url1);
     ManifestFetchData* fetch2 = new ManifestFetchData(url2);
     fetch1->AddExtension("1111", "1.0", 0);
     fetch2->AddExtension("12345", "2.0", ManifestFetchData::kNeverPinged);
@@ skipping 41 matching lines @@
     ChromeThread ui_thread(ChromeThread::UI, &ui_loop);
     ChromeThread file_thread(ChromeThread::FILE);
     file_thread.Start();
     ChromeThread io_thread(ChromeThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
     URLFetcher::set_factory(&factory);
     ServiceForDownloadTests service;
-    ScopedTempPrefService prefs;
     scoped_refptr<ExtensionUpdater> updater =
-        new ExtensionUpdater(&service, prefs.get(), kUpdateFrequencySecs);
+        new ExtensionUpdater(&service, service.pref_service(),
+                             kUpdateFrequencySecs);
 
     GURL test_url("http://localhost/extension.crx");
 
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string hash = "";
     scoped_ptr<Version> version(Version::GetVersionFromString("0.0.1"));
     ASSERT_TRUE(version.get());
     updater->FetchUpdatedExtension(id, test_url, hash, version->GetString());
 
     if (pending) {
@@ skipping 35 matching lines @@
   static void TestBlacklistDownloading() {
     MessageLoop message_loop;
     ChromeThread ui_thread(ChromeThread::UI, &message_loop);
     ChromeThread io_thread(ChromeThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
     URLFetcher::set_factory(&factory);
     ServiceForBlacklistTests service;
-    ScopedTempPrefService prefs;
     scoped_refptr<ExtensionUpdater> updater =
-        new ExtensionUpdater(&service, prefs.get(), kUpdateFrequencySecs);
-    prefs.get()->
+        new ExtensionUpdater(&service, service.pref_service(),
+                             kUpdateFrequencySecs);
+    service.pref_service()->
       RegisterStringPref(prefs::kExtensionBlacklistUpdateVersion, L"0");
     GURL test_url("http://localhost/extension.crx");
 
     std::string id = "com.google.crx.blacklist";
 
     std::string hash =
       "2CE109E9D0FAF820B2434E166297934E6177B65AB9951DBC3E204CAD4689B39C";
 
     std::string version = "0.0.1";
-
     updater->FetchUpdatedExtension(id, test_url, hash, version);
 
     // Call back the ExtensionUpdater with a 200 response and some test data
     std::string extension_data("aaabbb");
     fetcher = factory.GetFetcherByID(ExtensionUpdater::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->load_flags() == expected_load_flags);
     fetcher->delegate()->OnURLFetchComplete(
         fetcher, test_url, URLRequestStatus(), 200, ResponseCookies(),
         extension_data);
 
     message_loop.RunAllPending();
 
     // The updater should have called extension service to process the
     // blacklist.
     EXPECT_TRUE(service.processed_blacklist());
 
-    EXPECT_EQ(version, WideToASCII(prefs.get()->
+    EXPECT_EQ(version, WideToASCII(service.pref_service()->
       GetString(prefs::kExtensionBlacklistUpdateVersion)));
 
     URLFetcher::set_factory(NULL);
   }
 
   static void TestMultipleExtensionDownloading() {
     MessageLoopForUI message_loop;
     ChromeThread ui_thread(ChromeThread::UI, &message_loop);
     ChromeThread file_thread(ChromeThread::FILE, &message_loop);
     ChromeThread io_thread(ChromeThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
     TestURLFetcher* fetcher = NULL;
     URLFetcher::set_factory(&factory);
     ServiceForDownloadTests service;
-    ScopedTempPrefService prefs;
     scoped_refptr<ExtensionUpdater> updater =
-        new ExtensionUpdater(&service, prefs.get(), kUpdateFrequencySecs);
+        new ExtensionUpdater(&service, service.pref_service(),
+                             kUpdateFrequencySecs);
 
     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 = "";
 
@@ skipping 46 matching lines @@
   static void TestGalleryRequests(int ping_days) {
     TestURLFetcherFactory factory;
     URLFetcher::set_factory(&factory);
 
     // Set up 2 mock extensions, one with a google.com update url and one
     // without.
     ServiceForManifestTests service;
     ExtensionList tmp;
     GURL url1("http://clients2.google.com/service/update2/crx");
     GURL url2("http://www.somewebsite.com");
-    CreateTestExtensions(1, &tmp, &url1.possibly_invalid_spec());
-    CreateTestExtensions(1, &tmp, &url2.possibly_invalid_spec());
+    service.CreateTestExtensions(1, &tmp, &url1.possibly_invalid_spec());
+    service.CreateTestExtensions(1, &tmp, &url2.possibly_invalid_spec());
     EXPECT_EQ(2u, tmp.size());
     service.set_extensions(tmp);
 
     Time now = Time::Now();
     if (ping_days == 0) {
-      service.SetLastPingDay(tmp[0]->id(), now - TimeDelta::FromSeconds(15));
+      service.extension_prefs()->SetLastPingDay(
+          tmp[0]->id(), now - TimeDelta::FromSeconds(15));
     } else if (ping_days > 0) {
       Time last_ping_day =
           now - TimeDelta::FromDays(ping_days) - TimeDelta::FromSeconds(15);
-      service.SetLastPingDay(tmp[0]->id(), last_ping_day);
+      service.extension_prefs()->SetLastPingDay(tmp[0]->id(), last_ping_day);
     }
 
     MessageLoop message_loop;
-    ScopedTempPrefService prefs;
     scoped_refptr<ExtensionUpdater> updater =
-      new ExtensionUpdater(&service, prefs.get(), kUpdateFrequencySecs);
+      new ExtensionUpdater(&service, service.pref_service(),
+                           kUpdateFrequencySecs);
     updater->set_blacklist_checks_enabled(false);
 
     // Make the updater do manifest fetching, and note the urls it tries to
     // fetch.
     std::vector<GURL> fetched_urls;
     updater->CheckNow();
     TestURLFetcher* fetcher =
       factory.GetFetcherByID(ExtensionUpdater::kManifestFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     fetched_urls.push_back(fetcher->original_url());
@@ skipping 31 matching lines @@
 
     STLDeleteElements(&tmp);
   }
 
   // This makes sure that the extension updater properly stores the results
   // of a <daystart> tag from a manifest fetch in one of two cases: 1) This is
   // the first time we fetched the extension, or 2) We sent a ping value of
   // >= 1 day for the extension.
   static void TestHandleManifestResults() {
     ServiceForManifestTests service;
-    ScopedTempPrefService prefs;
     scoped_refptr<ExtensionUpdater> updater =
-        new ExtensionUpdater(&service, prefs.get(), kUpdateFrequencySecs);
+        new ExtensionUpdater(&service, service.pref_service(),
+                             kUpdateFrequencySecs);
 
     GURL update_url("http://www.google.com/manifest");
     ExtensionList tmp;
-    CreateTestExtensions(1, &tmp, &update_url.spec());
+    service.CreateTestExtensions(1, &tmp, &update_url.spec());
     service.set_extensions(tmp);
 
     ManifestFetchData fetch_data(update_url);
     Extension* extension = tmp[0];
     fetch_data.AddExtension(extension->id(), extension->VersionString(),
                             ManifestFetchData::kNeverPinged);
     UpdateManifest::Results results;
     results.daystart_elapsed_seconds = 750;
 
     updater->HandleManifestResults(fetch_data, results);
-    Time last_ping_day = service.LastPingDay(extension->id());
+    Time last_ping_day =
+        service.extension_prefs()->LastPingDay(extension->id());
     EXPECT_FALSE(last_ping_day.is_null());
     int64 seconds_diff = (Time::Now() - last_ping_day).InSeconds();
     EXPECT_LT(seconds_diff - results.daystart_elapsed_seconds, 5);
 
     STLDeleteElements(&tmp);
   }
 };
 
 // Because we test some private methods of ExtensionUpdater, it's easer for the
 // actual test code to live in ExtenionUpdaterTest methods instead of TEST_F
@@ skipping 52 matching lines @@
   ExtensionUpdaterTest::TestHandleManifestResults();
 }
 
 TEST(ExtensionUpdaterTest, TestManifestFetchesBuilderAddExtension) {
   MockService service;
   ManifestFetchesBuilder builder(&service);
 
   // Non-internal non-external extensions should be rejected.
   {
     ExtensionList extensions;
-    CreateTestExtensions(1, &extensions, NULL);
+    service.CreateTestExtensions(1, &extensions, NULL);
     ASSERT_FALSE(extensions.empty());
     extensions[0]->set_location(Extension::INVALID);
     builder.AddExtension(*extensions[0]);
     EXPECT_TRUE(builder.GetFetches().empty());
     STLDeleteElements(&extensions);
   }
 
   scoped_ptr<Version> version(Version::GetVersionFromString("0"));
   ASSERT_TRUE(version.get());
 
   // Extensions with invalid update URLs should be rejected.
   builder.AddPendingExtension(
-      "id", PendingExtensionInfo(GURL("http:google.com:foo"),
-                                 *version, false, false));
+      GenerateId("foo"), PendingExtensionInfo(GURL("http:google.com:foo"),
+                                              *version, false, false));
   EXPECT_TRUE(builder.GetFetches().empty());
 
   // Extensions with empty IDs should be rejected.
   builder.AddPendingExtension(
       "", PendingExtensionInfo(GURL(), *version, false, false));
   EXPECT_TRUE(builder.GetFetches().empty());
 
   // TODO(akalin): Test that extensions with empty update URLs
   // converted from user scripts are rejected.
 
   // Extensions with empty update URLs should have a default one
   // filled in.
   builder.AddPendingExtension(
-      "id", PendingExtensionInfo(GURL(), *version, false, false));
+      GenerateId("foo"), PendingExtensionInfo(GURL(), *version, false, false));
   std::vector<ManifestFetchData*> fetches = builder.GetFetches();
   ASSERT_EQ(1u, fetches.size());
   scoped_ptr<ManifestFetchData> fetch(fetches[0]);
   fetches.clear();
   EXPECT_FALSE(fetch->base_url().is_empty());
   EXPECT_FALSE(fetch->full_url().is_empty());
 }
 
 // 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
 // -Profile::GetDefaultRequestContext() returning null
 //  (should not crash, but just do check later)
 // -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