Introduce incognito preference settings.

chrome/browser/extensions/extension_updater_unittest.cc

 // Copyright (c) 2010 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/scoped_ptr.h"
 #include "base/stl_util-inl.h"
 #include "base/string_number_conversions.h"
@@ skipping 73 matching lines @@
     return false;
   }
 
   virtual ExtensionPrefs* extension_prefs() { return prefs_.prefs(); }
 
   PrefService* pref_service() { return prefs_.pref_service(); }
 
   // 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,
+  // The |id| is used to distinguish extension names and make sure that
+  // no two extensions share the same name.

[Mattias Nissler (ping if slow), 2011/01/05 12:08:07]

Out of curiosity: Why is this now required?

[battre, 2011/01/05 20:23:08]

Otherwise the two extensions receive the same hashed name and are
indistinguishable in the ExtensionPrefValueMap. I.e. the same key is installed
twice and removed twice.

The test cases do not break any more because I removed the DCHECK for double
registration/unregistration. Shall I revert this?

+  void CreateTestExtensions(int id, int count, ExtensionList *list,
                             const std::string* update_url,
                             Extension::Location location) {
     for (int i = 1; i <= count; i++) {
       DictionaryValue manifest;
       manifest.SetString(extension_manifest_keys::kVersion,
                          base::StringPrintf("%d.0.0.0", i));
       manifest.SetString(extension_manifest_keys::kName,
-                         base::StringPrintf("Extension %d", i));
+                         base::StringPrintf("Extension %d.%d", id, i));
       if (update_url)
         manifest.SetString(extension_manifest_keys::kUpdateURL, *update_url);
       scoped_refptr<Extension> e =
           prefs_.AddExtensionWithManifest(manifest, location);
       ASSERT_TRUE(e != NULL);
       list->push_back(e);
     }
   }
 
  protected:
@@ skipping 196 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 {
-      service.CreateTestExtensions(1, &extensions, &update_url,
+      service.CreateTestExtensions(1, 1, &extensions, &update_url,
                                    Extension::INTERNAL);
       service.set_extensions(extensions);
     }
 
     // Setup and start the updater.
     MessageLoop message_loop;
     BrowserThread io_thread(BrowserThread::IO);
     io_thread.Start();
 
     TestURLFetcherFactory factory;
@@ skipping 131 matching lines @@
               "%26v%3D1.0%26uc%26ap%3Da%253D1%2526b%253D2%2526c",
               fetch_data.full_url().spec());
   }
 
   static void TestUpdateUrlDataFromGallery(const std::string& gallery_url) {
     MockService service;
     ManifestFetchesBuilder builder(&service);
     ExtensionList extensions;
     std::string url(gallery_url);
 
-    service.CreateTestExtensions(1, &extensions, &url, Extension::INTERNAL);
+    service.CreateTestExtensions(1, 1, &extensions, &url, Extension::INTERNAL);
     builder.AddExtension(*extensions[0]);
     std::vector<ManifestFetchData*> fetches = builder.GetFetches();
     EXPECT_EQ(1u, fetches.size());
     scoped_ptr<ManifestFetchData> fetch(fetches[0]);
     fetches.clear();
 
     // Make sure that extensions that update from the gallery ignore any
     // update URL data.
     const std::string& update_url = fetch->full_url().spec();
     std::string::size_type x = update_url.find("x=");
     EXPECT_NE(std::string::npos, x);
     std::string::size_type ap = update_url.find("ap%3D", x);
     EXPECT_EQ(std::string::npos, ap);
   }
 
   static void TestDetermineUpdates() {
     // Create a set of test extensions
     ServiceForManifestTests service;
     ExtensionList tmp;
-    service.CreateTestExtensions(3, &tmp, NULL, Extension::INTERNAL);
+    service.CreateTestExtensions(1, 3, &tmp, NULL, Extension::INTERNAL);
     service.set_extensions(tmp);
 
     MessageLoop message_loop;
     scoped_refptr<ExtensionUpdater> updater(
         new ExtensionUpdater(&service, service.pref_service(),
                              kUpdateFrequencySecs));
     updater->Start();
 
     // Check passing an empty list of parse results to DetermineUpdates
     ManifestFetchData fetch_data(GURL("http://localhost/foo"));
@@ skipping 303 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");
-    service.CreateTestExtensions(1, &tmp, &url1.possibly_invalid_spec(),
+    service.CreateTestExtensions(1, 1, &tmp, &url1.possibly_invalid_spec(),
                                  Extension::INTERNAL);
-    service.CreateTestExtensions(1, &tmp, &url2.possibly_invalid_spec(),
+    service.CreateTestExtensions(2, 1, &tmp, &url2.possibly_invalid_spec(),
                                  Extension::INTERNAL);
     EXPECT_EQ(2u, tmp.size());
     service.set_extensions(tmp);
 
     Time now = Time::Now();
     if (ping_days == 0) {
       service.extension_prefs()->SetLastPingDay(
           tmp[0]->id(), now - TimeDelta::FromSeconds(15));
     } else if (ping_days > 0) {
       Time last_ping_day =
@@ skipping 56 matching lines @@
   static void TestHandleManifestResults() {
     ServiceForManifestTests service;
     MessageLoop message_loop;
     scoped_refptr<ExtensionUpdater> updater(
         new ExtensionUpdater(&service, service.pref_service(),
                              kUpdateFrequencySecs));
     updater->Start();
 
     GURL update_url("http://www.google.com/manifest");
     ExtensionList tmp;
-    service.CreateTestExtensions(1, &tmp, &update_url.spec(),
+    service.CreateTestExtensions(1, 1, &tmp, &update_url.spec(),
                                  Extension::INTERNAL);
     service.set_extensions(tmp);
 
     ManifestFetchData fetch_data(update_url);
     const Extension* extension = tmp[0];
     fetch_data.AddExtension(extension->id(), extension->VersionString(),
                             ManifestFetchData::kNeverPinged,
                             kEmptyUpdateUrlData);
     UpdateManifest::Results results;
     results.daystart_elapsed_seconds = 750;
@@ skipping 74 matching lines @@
   ExtensionUpdaterTest::TestHandleManifestResults();
 }
 
 TEST(ExtensionUpdaterTest, TestManifestFetchesBuilderAddExtension) {
   MockService service;
   ManifestFetchesBuilder builder(&service);
 
   // Non-internal non-external extensions should be rejected.
   {
     ExtensionList extensions;
-    service.CreateTestExtensions(1, &extensions, NULL, Extension::INVALID);
+    service.CreateTestExtensions(1, 1, &extensions, NULL, Extension::INVALID);
     ASSERT_FALSE(extensions.empty());
     builder.AddExtension(*extensions[0]);
     EXPECT_TRUE(builder.GetFetches().empty());
   }
 
   // Extensions with invalid update URLs should be rejected.
   builder.AddPendingExtension(
       GenerateId("foo"), PendingExtensionInfo(GURL("http:google.com:foo"),
                                               &ShouldInstallExtensionsOnly,
                                               false, false, true, false,
@@ skipping 64 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