Move Extension Location and Type enums to Manifest, and move InstallWarning to its own file.

chrome/browser/extensions/updater/extension_updater_unittest.cc

 // Copyright (c) 2012 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 <list>
 #include <map>
 #include <set>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 217 matching lines @@
 
   Blacklist* blacklist() { return &blacklist_; }
 
   // 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.
   // 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) {
+                            Manifest::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.%d", id, i));
       if (update_url)
         manifest.SetString(extension_manifest_keys::kUpdateURL, *update_url);
       scoped_refptr<Extension> e =
           prefs_->AddExtensionWithManifest(manifest, location);
@@ skipping 13 matching lines @@
 };
 
 
 std::string GenerateId(std::string input) {
   std::string result;
   EXPECT_TRUE(Extension::GenerateId(input, &result));
   return result;
 }
 
 bool ShouldInstallExtensionsOnly(const Extension& extension) {
-  return extension.GetType() == Extension::TYPE_EXTENSION;
+  return extension.GetType() == Manifest::TYPE_EXTENSION;
 }
 
 bool ShouldInstallThemesOnly(const Extension& extension) {
   return extension.is_theme();
 }
 
 bool ShouldAlwaysInstall(const Extension& extension) {
   return true;
 }
 
 // Loads some pending extension records into a pending extension manager.
 void SetupPendingExtensionManagerForTest(
     int count,
     const GURL& update_url,
     PendingExtensionManager* pending_extension_manager) {
   for (int i = 1; i <= count; ++i) {
     PendingExtensionInfo::ShouldAllowInstallPredicate should_allow_install =
         (i % 2 == 0) ? &ShouldInstallThemesOnly : &ShouldInstallExtensionsOnly;
     const bool kIsFromSync = true;
     const bool kInstallSilently = true;
     std::string id = GenerateId(base::StringPrintf("extension%i", i));
 
     pending_extension_manager->AddForTesting(
         PendingExtensionInfo(id,
                              update_url,
                              Version(),
                              should_allow_install,
                              kIsFromSync,
                              kInstallSilently,
-                             Extension::INTERNAL));
+                             Manifest::INTERNAL));
   }
 }
 
 class ServiceForManifestTests : public MockService {
  public:
   explicit ServiceForManifestTests(TestExtensionPrefs* prefs)
       : MockService(prefs) {
   }
 
   virtual ~ServiceForManifestTests() {}
@@ skipping 202 matching lines @@
     std::string update_url("http://foo.com/bar");
     ExtensionList extensions;
     NotificationsObserver observer;
     PendingExtensionManager* pending_extension_manager =
         service.pending_extension_manager();
     if (pending) {
       SetupPendingExtensionManagerForTest(1, GURL(update_url),
                                           pending_extension_manager);
     } else {
       service.CreateTestExtensions(1, 1, &extensions, &update_url,
-                                   Extension::INTERNAL);
+                                   Manifest::INTERNAL);
       service.set_extensions(extensions);
     }
 
     // Set up and start the updater.
     net::TestURLFetcherFactory factory;
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), service.blacklist(), 60*60*24);
     updater.Start();
     // Disable blacklist checks (tested elsewhere) so that we only see the
@@ skipping 124 matching lines @@
 
   void TestUpdateUrlDataFromGallery(const std::string& gallery_url) {
     net::TestURLFetcherFactory factory;
 
     MockService service(prefs_.get());
     MockExtensionDownloaderDelegate delegate;
     ExtensionDownloader downloader(&delegate, service.request_context());
     ExtensionList extensions;
     std::string url(gallery_url);
 
-    service.CreateTestExtensions(1, 1, &extensions, &url, Extension::INTERNAL);
+    service.CreateTestExtensions(1, 1, &extensions, &url, Manifest::INTERNAL);
 
     const std::string& id = extensions[0]->id();
     EXPECT_CALL(delegate, GetPingDataForExtension(id, _));
 
     downloader.AddExtension(*extensions[0], 0);
     downloader.StartAllPending();
     net::TestURLFetcher* fetcher =
         factory.GetFetcherByID(ExtensionDownloader::kManifestFetcherId);
     ASSERT_TRUE(fetcher);
     // Make sure that extensions that update from the gallery ignore any
@@ skipping 316 matching lines @@
 
     if (pending) {
       const bool kIsFromSync = true;
       const bool kInstallSilently = true;
       PendingExtensionManager* pending_extension_manager =
           service->pending_extension_manager();
       pending_extension_manager->AddForTesting(
           PendingExtensionInfo(id, test_url, version,
                                &ShouldAlwaysInstall, kIsFromSync,
                                kInstallSilently,
-                               Extension::INTERNAL));
+                               Manifest::INTERNAL));
     }
 
     // Call back the ExtensionUpdater with a 200 response and some test data
     FilePath extension_file_path(FILE_PATH_LITERAL("/whatever"));
     fetcher = factory.GetFetcherByID(ExtensionDownloader::kExtensionFetcherId);
     EXPECT_TRUE(fetcher != NULL && fetcher->delegate() != NULL);
     EXPECT_TRUE(fetcher->GetLoadFlags() == kExpectedLoadFlags);
 
     if (retry) {
       // Reply with response code 500 to cause ExtensionDownloader to retry
@@ skipping 263 matching lines @@
     net::TestURLFetcherFactory factory;
 
     // Set up 2 mock extensions, one with a google.com update url and one
     // without.
     prefs_.reset(new TestExtensionPrefs(loop_.message_loop_proxy()));
     ServiceForManifestTests service(prefs_.get());
     ExtensionList tmp;
     GURL url1("http://clients2.google.com/service/update2/crx");
     GURL url2("http://www.somewebsite.com");
     service.CreateTestExtensions(1, 1, &tmp, &url1.possibly_invalid_spec(),
-                                 Extension::INTERNAL);
+                                 Manifest::INTERNAL);
     service.CreateTestExtensions(2, 1, &tmp, &url2.possibly_invalid_spec(),
-                                 Extension::INTERNAL);
+                                 Manifest::INTERNAL);
     EXPECT_EQ(2u, tmp.size());
     service.set_extensions(tmp);
 
     ExtensionPrefs* prefs = service.extension_prefs();
     const std::string& id = tmp[0]->id();
     Time now = Time::Now();
     if (rollcall_ping_days == 0) {
       prefs->SetLastPingDay(id, now - TimeDelta::FromSeconds(15));
     } else if (rollcall_ping_days > 0) {
       Time last_ping_day = now -
@@ skipping 98 matching lines @@
 
   // 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.
   void TestHandleManifestResults() {
     ServiceForManifestTests service(prefs_.get());
     GURL update_url("http://www.google.com/manifest");
     ExtensionList tmp;
     service.CreateTestExtensions(1, 1, &tmp, &update_url.spec(),
-                                 Extension::INTERNAL);
+                                 Manifest::INTERNAL);
     service.set_extensions(tmp);
 
     ExtensionUpdater updater(
         &service, service.extension_prefs(), service.pref_service(),
         service.profile(), service.blacklist(), kUpdateFrequencySecs);
     updater.Start();
     ResetDownloader(
         &updater,
         new ExtensionDownloader(&updater, service.request_context()));
 
@@ skipping 113 matching lines @@
                            service.blacklist(), kUpdateFrequencySecs);
   MockExtensionDownloaderDelegate delegate;
   // Set the downloader directly, so that all its events end up in the mock
   // |delegate|.
   ExtensionDownloader* downloader =
       new ExtensionDownloader(&delegate, service.request_context());
   ResetDownloader(&updater, downloader);
 
   // Non-internal non-external extensions should be rejected.
   ExtensionList extensions;
-  service.CreateTestExtensions(1, 1, &extensions, NULL, Extension::INVALID);
-  service.CreateTestExtensions(2, 1, &extensions, NULL, Extension::INTERNAL);
+  service.CreateTestExtensions(1, 1, &extensions, NULL,
+                               Manifest::INVALID_LOCATION);
+  service.CreateTestExtensions(2, 1, &extensions, NULL, Manifest::INTERNAL);
   ASSERT_EQ(2u, extensions.size());
   const std::string& updateable_id = extensions[1]->id();
 
   // These expectations fail if the delegate's methods are invoked for the
   // first extension, which has a non-matching id.
   EXPECT_CALL(delegate, GetUpdateUrlData(updateable_id)).WillOnce(Return(""));
   EXPECT_CALL(delegate, GetPingDataForExtension(updateable_id, _));
 
   service.set_extensions(extensions);
   ExtensionUpdater::CheckParams params;
@@ skipping 12 matching lines @@
   // Set the downloader directly, so that all its events end up in the mock
   // |delegate|.
   ExtensionDownloader* downloader =
       new ExtensionDownloader(&delegate, service.request_context());
   ResetDownloader(&updater, downloader);
 
   // Non-internal non-external extensions should be rejected.
   ExtensionList enabled_extensions;
   ExtensionList disabled_extensions;
   service.CreateTestExtensions(1, 1, &enabled_extensions, NULL,
-      Extension::INTERNAL);
+      Manifest::INTERNAL);
   service.CreateTestExtensions(2, 1, &disabled_extensions, NULL,
-      Extension::INTERNAL);
+      Manifest::INTERNAL);
   ASSERT_EQ(1u, enabled_extensions.size());
   ASSERT_EQ(1u, disabled_extensions.size());
   const std::string& enabled_id = enabled_extensions[0]->id();
   const std::string& disabled_id = disabled_extensions[0]->id();
 
   // We expect that both enabled and disabled extensions are auto-updated.
   EXPECT_CALL(delegate, GetUpdateUrlData(enabled_id)).WillOnce(Return(""));
   EXPECT_CALL(delegate, GetPingDataForExtension(enabled_id, _));
   EXPECT_CALL(delegate, GetUpdateUrlData(disabled_id)).WillOnce(Return(""));
   EXPECT_CALL(delegate, GetPingDataForExtension(disabled_id, _));
@@ skipping 99 matching lines @@
 // -prodversionmin (shouldn't update if browser version too old)
 // -manifests & updates arriving out of order / interleaved
 // -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
 
 }  // namespace extensions