Reworked ExtensionsService::AddPendingExtension().

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"
@@ skipping 97 matching lines @@
   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());
+    const Extension::State kInitialState = Extension::ENABLED;
+    const bool kInitialIncognitoEnabled = false;
     std::string id = GenerateId(StringPrintf("extension%i", i));
     (*pending_extensions)[id] =
-        PendingExtensionInfo(update_url, *version,
-                             is_theme, kInstallSilently);
+        PendingExtensionInfo(update_url, is_theme, kInstallSilently,
+                             kInitialState, kInitialIncognitoEnabled);
   }
 }
 
 class ServiceForManifestTests : public MockService {
  public:
   ServiceForManifestTests() : has_installed_extensions_(false) {}
 
   virtual ~ServiceForManifestTests() {}
 
   virtual Extension* GetExtensionById(const std::string& id, bool) {
@@ skipping 184 matching lines @@
     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);
     if (pending) {
       EXPECT_EQ(pending_extensions.begin()->first, params["id"]);
-      EXPECT_EQ("1.0.0.0", params["v"]);
+      EXPECT_EQ("0.0.0.0", params["v"]);
     } else {
       EXPECT_EQ(extensions[0]->id(), params["id"]);
       EXPECT_EQ(extensions[0]->VersionString(), params["v"]);
     }
     EXPECT_EQ("", params["uc"]);
 
     if (!pending) {
       STLDeleteElements(&extensions);
     }
   }
@@ skipping 99 matching lines @@
 
     MessageLoop message_loop;
     scoped_refptr<ExtensionUpdater> updater =
         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(),
+      fetch_data.AddExtension(it->first, "1.0.0.0",
                               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());
+    // All the apps should be updateable.
+    EXPECT_EQ(3u, 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();
@@ skipping 76 matching lines @@
 
     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) {
       const bool kIsTheme = false;
       const bool kInstallSilently = true;
+      const Extension::State kInitialState = Extension::ENABLED;
+      const bool kInitialIncognitoEnabled = false;
       PendingExtensionMap pending_extensions;
       pending_extensions[id] =
-          PendingExtensionInfo(test_url, *version,
-                               kIsTheme, kInstallSilently);
+          PendingExtensionInfo(test_url, kIsTheme, kInstallSilently,
+                               kInitialState, kInitialIncognitoEnabled);
       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(),
@@ skipping 304 matching lines @@
   {
     ExtensionList extensions;
     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(
       GenerateId("foo"), PendingExtensionInfo(GURL("http:google.com:foo"),
-                                              *version, false, false));
+                                              false, false, true, false));
   EXPECT_TRUE(builder.GetFetches().empty());
 
   // Extensions with empty IDs should be rejected.
   builder.AddPendingExtension(
-      "", PendingExtensionInfo(GURL(), *version, false, false));
+      "", PendingExtensionInfo(GURL(), false, false, true, 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(
-      GenerateId("foo"), PendingExtensionInfo(GURL(), *version, false, false));
+      GenerateId("foo"), PendingExtensionInfo(GURL(),
+                                              false, false, true, 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