Introduce incognito preference settings.

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/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.
+  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 57 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