Added support for pending extensions to ExtensionsService and

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/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"
@@ skipping 21 matching lines @@
 class MockService : public ExtensionUpdateService {
  public:
   MockService() {}
   virtual ~MockService() {}
 
   virtual const ExtensionList* extensions() const {
     EXPECT_TRUE(false);
     return NULL;
   }
 
+  virtual const PendingExtensionMap& pending_extensions() const {
+    EXPECT_TRUE(false);
+    return pending_extensions_;
+  }
+
   virtual void UpdateExtension(const std::string& id,
                                const FilePath& extension_path,
                                const GURL& download_url) {
     EXPECT_TRUE(false);
   }
 
   virtual Extension* GetExtensionById(const std::string& id, bool) {
     EXPECT_TRUE(false);
     return NULL;
   }
@@ skipping 15 matching lines @@
 
   virtual Time LastPingDay(const std::string& extension_id) {
     std::map<std::string, Time>::iterator i =
         last_ping_days_.find(extension_id);
     if (i != last_ping_days_.end())
       return i->second;
 
     return Time();
   }
 
+ protected:
+  PendingExtensionMap pending_extensions_;
+
  private:
   std::map<std::string, Time> last_ping_days_;
   DISALLOW_COPY_AND_ASSIGN(MockService);
 };
 
 // Class that contains a PrefService and handles cleanup of a temporary file
 // backing it.
 class ScopedTempPrefService {
  public:
   ScopedTempPrefService() {
@@ skipping 35 matching lines @@
     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);
   }
 }
 
+// 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)] =
+        PendingExtensionInfo(update_url, *version,
+                             is_theme, kInstallSilently);
+  }
+}
+
 class ServiceForManifestTests : public MockService {
  public:
   ServiceForManifestTests() : has_installed_extensions_(false) {}
 
   virtual ~ServiceForManifestTests() {}
 
   virtual Extension* GetExtensionById(const std::string& id, bool) {
     for (ExtensionList::iterator iter = extensions_.begin();
         iter != extensions_.end(); ++iter) {
      if ((*iter)->id() == id) {
        return *iter;
      }
     }
     return NULL;
   }
 
   virtual const ExtensionList* extensions() const { return &extensions_; }
 
+  virtual const PendingExtensionMap& pending_extensions() const {
+    return pending_extensions_;
+  }
+
   void set_extensions(ExtensionList extensions) {
     extensions_ = extensions;
   }
 
+  void set_pending_extensions(
+      const PendingExtensionMap& pending_extensions) {
+    pending_extensions_ = pending_extensions;
+  }
+
   virtual bool HasInstalledExtensions() {
     return has_installed_extensions_;
   }
 
   void set_has_installed_extensions(bool value) {
     has_installed_extensions_ = value;
   }
 
  private:
   ExtensionList extensions_;
   bool has_installed_extensions_;
 };
 
 class ServiceForDownloadTests : public MockService {
  public:
   virtual void UpdateExtension(const std::string& id,
                                const FilePath& extension_path,
                                const GURL& download_url) {
     extension_id_ = id;
     install_path_ = extension_path;
     download_url_ = download_url;
   }
 
+  virtual const PendingExtensionMap& pending_extensions() const {
+    return pending_extensions_;
+  }
+
   virtual Extension* GetExtensionById(const std::string& id, bool) {
     last_inquired_extension_id_ = id;
     return NULL;
   }
 
+  void set_pending_extensions(
+      const PendingExtensionMap& pending_extensions) {
+    pending_extensions_ = pending_extensions;
+  }
+
   const std::string& extension_id() { return extension_id_; }
   const FilePath& install_path() { return install_path_; }
   const GURL& download_url() { return download_url_; }
   const std::string& last_inquired_extension_id() {
     return last_inquired_extension_id_;
   }
 
  private:
   std::string extension_id_;
   FilePath install_path_;
@@ skipping 62 matching lines @@
       const std::string& version,
       const std::string& url,
       UpdateManifest::Results* results) {
     UpdateManifest::Result result;
     result.extension_id = id;
     result.version = version;
     result.crx_url = GURL(url);
     results->list.push_back(result);
   }
 
-  static void TestExtensionUpdateCheckRequests() {
+  static void TestExtensionUpdateCheckRequests(bool pending) {
     // Create an extension with an update_url.
     ServiceForManifestTests service;
-    ExtensionList tmp;
     std::string update_url("http://foo.com/bar");
-    CreateTestExtensions(1, &tmp, &update_url);
-    service.set_extensions(tmp);
+    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.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 =
@@ skipping 17 matching lines @@
     // look something like "?x=id%3D<id>%26v%3D<version>%26uc".
     EXPECT_TRUE(url.has_query());
     std::vector<std::string> parts;
     SplitString(url.query(), '=', &parts);
     EXPECT_EQ(2u, parts.size());
     EXPECT_EQ("x", parts[0]);
     std::string decoded = UnescapeURLComponent(parts[1],
                                                UnescapeRule::URL_SPECIAL_CHARS);
     std::map<std::string, std::string> params;
     ExtractParameters(decoded, &params);
-    EXPECT_EQ(tmp[0]->id(), params["id"]);
-    EXPECT_EQ(tmp[0]->VersionString(), params["v"]);
+    if (pending) {
+      EXPECT_EQ(pending_extensions.begin()->first, params["id"]);
+      EXPECT_EQ("1.0.0.0", params["v"]);
+    } else {
+      EXPECT_EQ(extensions[0]->id(), params["id"]);
+      EXPECT_EQ(extensions[0]->VersionString(), params["v"]);
+    }
     EXPECT_EQ("", params["uc"]);
 
-    STLDeleteElements(&tmp);
+    if (!pending) {
+      STLDeleteElements(&extensions);
+    }
   }
 
   static void TestBlacklistUpdateCheckRequests() {
     ServiceForManifestTests service;
 
     // Setup and start the updater.
     MessageLoop message_loop;
     ChromeThread io_thread(ChromeThread::IO);
     io_thread.Start();
 
@@ skipping 74 matching lines @@
     fetch_data.AddExtension(tmp[1]->id(), tmp[1]->VersionString(),
                             ManifestFetchData::kNeverPinged);
     AddParseResult(tmp[1]->id(),
         tmp[1]->VersionString(), "http://localhost/e2_2.0.crx", &updates);
     updateable = updater->DetermineUpdates(fetch_data, updates);
     EXPECT_EQ(1u, updateable.size());
     EXPECT_EQ(0, updateable[0]);
     STLDeleteElements(&tmp);
   }
 
+  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);
+
+    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);
+    }
+    std::vector<int> updateable =
+        updater->DetermineUpdates(fetch_data, updates);
+    // Only the first one is updateable.
+    EXPECT_EQ(1u, updateable.size());
+    for (std::vector<int>::size_type i = 0; i < updateable.size(); ++i) {
+      EXPECT_EQ(static_cast<int>(i), updateable[i]);
+    }
+  }
+
   static void TestMultipleManifestDownloading() {
     MessageLoop ui_loop;
     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;
@@ skipping 44 matching lines @@
     // This should run the manifest parsing, then we want to make sure that our
     // service was called with GetExtensionById with the matching id from
     // kValidXml.
     file_thread.Stop();
     io_thread.Stop();
     ui_loop.RunAllPending();
     EXPECT_EQ("12345", service.last_inquired_extension_id());
     xmlCleanupGlobals();
   }
 
-  static void TestSingleExtensionDownloading() {
+  static void TestSingleExtensionDownloading(bool pending) {
     MessageLoop ui_loop;
     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);
 
     GURL test_url("http://localhost/extension.crx");
 
     std::string id = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
     std::string hash = "";
-    std::string version = "0.0.1";
+    scoped_ptr<Version> version(Version::GetVersionFromString("0.0.1"));
+    ASSERT_TRUE(version.get());
+    updater->FetchUpdatedExtension(id, test_url, hash, version->GetString());
 
-    updater->FetchUpdatedExtension(id, test_url, hash, version);
+    if (pending) {
+      const bool kIsTheme = false;
+      const bool kInstallSilently = true;
+      PendingExtensionMap pending_extensions;
+      pending_extensions[id] =
+          PendingExtensionInfo(test_url, *version,
+                               kIsTheme, kInstallSilently);
+      service.set_pending_extensions(pending_extensions);
+    }
 
     // Call back the ExtensionUpdater with a 200 response and some test data
     std::string extension_data("whatever");
     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);
 
@@ skipping 234 matching lines @@
 
     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
 // subclasses where friendship with ExtenionUpdater is not inherited.
 
 TEST(ExtensionUpdaterTest, TestExtensionUpdateCheckRequests) {
-  ExtensionUpdaterTest::TestExtensionUpdateCheckRequests();
+  ExtensionUpdaterTest::TestExtensionUpdateCheckRequests(false);
+}
+
+TEST(ExtensionUpdaterTest, TestExtensionUpdateCheckRequestsPending) {
+  ExtensionUpdaterTest::TestExtensionUpdateCheckRequests(true);
 }
 
 // This test is disabled on Mac, see http://crbug.com/26035.
 TEST(ExtensionUpdaterTest, MAYBE_TestBlacklistUpdateCheckRequests) {
   ExtensionUpdaterTest::TestBlacklistUpdateCheckRequests();
 }
 
 TEST(ExtensionUpdaterTest, TestDetermineUpdates) {
   ExtensionUpdaterTest::TestDetermineUpdates();
 }
 
+TEST(ExtensionUpdaterTest, TestDetermineUpdatesPending) {
+  ExtensionUpdaterTest::TestDetermineUpdatesPending();
+}
+
 TEST(ExtensionUpdaterTest, TestMultipleManifestDownloading) {
   ExtensionUpdaterTest::TestMultipleManifestDownloading();
 }
 
 TEST(ExtensionUpdaterTest, TestSingleExtensionDownloading) {
-  ExtensionUpdaterTest::TestSingleExtensionDownloading();
+  ExtensionUpdaterTest::TestSingleExtensionDownloading(false);
+}
+
+TEST(ExtensionUpdaterTest, TestSingleExtensionDownloadingPending) {
+  ExtensionUpdaterTest::TestSingleExtensionDownloading(true);
 }
 
 // This test is disabled on Mac, see http://crbug.com/26035.
 TEST(ExtensionUpdaterTest, MAYBE_TestBlacklistDownloading) {
   ExtensionUpdaterTest::TestBlacklistDownloading();
 }
 
 TEST(ExtensionUpdaterTest, TestMultipleExtensionDownloading) {
   ExtensionUpdaterTest::TestMultipleExtensionDownloading();
 }
@@ skipping 13 matching lines @@
 // -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