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

chrome/browser/extensions/extension_special_storage_policy_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 "base/message_loop.h"
 #include "base/values.h"
 #include "chrome/browser/content_settings/cookie_settings.h"
 #include "chrome/browser/extensions/extension_special_storage_policy.h"
 #include "chrome/common/content_settings.h"
 #include "chrome/common/content_settings_types.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
+#include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/web_intents_handler.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using extensions::Extension;
+using extensions::Manifest;
 
 namespace keys = extension_manifest_keys;
 
 class ExtensionSpecialStoragePolicyTest : public testing::Test {
  public:
   virtual void SetUp() {
     policy_ = new ExtensionSpecialStoragePolicy(NULL);
     extensions::ManifestHandler::Register(keys::kIntents,
                                           new extensions::WebIntentsHandler);
   }
 
  protected:
   scoped_refptr<Extension> CreateProtectedApp() {
 #if defined(OS_WIN)
     FilePath path(FILE_PATH_LITERAL("c:\\foo"));
 #elif defined(OS_POSIX)
     FilePath path(FILE_PATH_LITERAL("/foo"));
 #endif
     DictionaryValue manifest;
     manifest.SetString(keys::kName, "Protected");
     manifest.SetString(keys::kVersion, "1");
     manifest.SetString(keys::kLaunchWebURL, "http://explicit/protected/start");
     ListValue* list = new ListValue();
     list->Append(Value::CreateStringValue("http://explicit/protected"));
     list->Append(Value::CreateStringValue("*://*.wildcards/protected"));
     manifest.Set(keys::kWebURLs, list);
     std::string error;
     scoped_refptr<Extension> protected_app = Extension::Create(
-        path, Extension::INVALID, manifest, Extension::NO_FLAGS, &error);
+        path, Manifest::INVALID_LOCATION, manifest,
+        Extension::NO_FLAGS, &error);
     EXPECT_TRUE(protected_app.get()) << error;
     return protected_app;
   }
 
   scoped_refptr<Extension> CreateUnlimitedApp() {
 #if defined(OS_WIN)
     FilePath path(FILE_PATH_LITERAL("c:\\bar"));
 #elif defined(OS_POSIX)
     FilePath path(FILE_PATH_LITERAL("/bar"));
 #endif
     DictionaryValue manifest;
     manifest.SetString(keys::kName, "Unlimited");
     manifest.SetString(keys::kVersion, "1");
     manifest.SetString(keys::kLaunchWebURL, "http://explicit/unlimited/start");
     ListValue* list = new ListValue();
     list->Append(Value::CreateStringValue("unlimitedStorage"));
     manifest.Set(keys::kPermissions, list);
     list = new ListValue();
     list->Append(Value::CreateStringValue("http://explicit/unlimited"));
     list->Append(Value::CreateStringValue("*://*.wildcards/unlimited"));
     manifest.Set(keys::kWebURLs, list);
     std::string error;
     scoped_refptr<Extension> unlimited_app = Extension::Create(
-        path, Extension::INVALID, manifest, Extension::NO_FLAGS, &error);
+        path, Manifest::INVALID_LOCATION, manifest,
+        Extension::NO_FLAGS, &error);
     EXPECT_TRUE(unlimited_app.get()) << error;
     return unlimited_app;
   }
 
   scoped_refptr<Extension> CreateComponentApp() {
 #if defined(OS_WIN)
     FilePath path(FILE_PATH_LITERAL("c:\\component"));
 #elif defined(OS_POSIX)
     FilePath path(FILE_PATH_LITERAL("/component"));
 #endif
     DictionaryValue manifest;
     manifest.SetString(keys::kName, "Component");
     manifest.SetString(keys::kVersion, "1");
     manifest.SetString(keys::kPublicKey,
         "MIGdMA0GCSqGSIb3DQEBAQUAA4GLADCBhwKBgQDOuXEIuoK1kAkBe0SKiJn/N9oNn3oU" \
         "xGa4dwj40MnJqPn+w0aR2vuyocm0R4Drp67aYwtLjOVPF4CICRq6ICP6eU07gGwQxGdZ" \
         "7HJASXV8hm0tab5I70oJmRLfFJyVAMCeWlFaOGq05v2i6EbifZM0qO5xALKNGQt+yjXi" \
         "5INM5wIBIw==");
     ListValue* list = new ListValue();
     list->Append(Value::CreateStringValue("unlimitedStorage"));
     list->Append(Value::CreateStringValue("fileSystem"));
     list->Append(Value::CreateStringValue("fileBrowserPrivate"));
     manifest.Set(keys::kPermissions, list);
     std::string error;
     scoped_refptr<Extension> component_app = Extension::Create(
-        path, Extension::COMPONENT, manifest, Extension::NO_FLAGS, &error);
+        path, Manifest::COMPONENT, manifest, Extension::NO_FLAGS, &error);
     EXPECT_TRUE(component_app.get()) << error;
     return component_app;
   }
 
   scoped_refptr<Extension> CreateHandlerApp() {
 #if defined(OS_WIN)
     FilePath path(FILE_PATH_LITERAL("c:\\handler"));
 #elif defined(OS_POSIX)
     FilePath path(FILE_PATH_LITERAL("/handler"));
 #endif
     DictionaryValue manifest;
     manifest.SetString(keys::kName, "Handler");
     manifest.SetString(keys::kVersion, "1");
     manifest.SetString(keys::kPublicKey,
         "MIGdMA0GCSqGSIb3DQEBAQUAA4GLADCBhwKBgQChptAQ0n4R56N03nWQ1ogR7DVRBjGo" \
         "80Vw6G9KLjzZv44D8rq5Q5IkeQrtKgWyZfXevlsCe3LaLo18rcz8iZx6lK2xhLdUR+OR" \
         "jsjuBfdEL5a5cWeRTSxf75AcqndQsmpwMBdrMTCZ8jQNusUI+XlrihLNNJuI5TM4vNIN" \
         "I5bYFQIBIw==");
     ListValue* list = new ListValue();
     list->Append(Value::CreateStringValue("unlimitedStorage"));
     list->Append(Value::CreateStringValue("fileSystem"));
     manifest.Set(keys::kPermissions, list);
     std::string error;
     scoped_refptr<Extension> handler_app = Extension::Create(
-        path, Extension::INVALID, manifest, Extension::NO_FLAGS, &error);
+        path, Manifest::INVALID_LOCATION, manifest,
+        Extension::NO_FLAGS, &error);
     EXPECT_TRUE(handler_app.get()) << error;
     return handler_app;
   }
 
   scoped_refptr<Extension> CreateWebIntentViewApp() {
 #if defined(OS_WIN)
     FilePath path(FILE_PATH_LITERAL("c:\\bar"));
 #elif defined(OS_POSIX)
     FilePath path(FILE_PATH_LITERAL("/bar"));
 #endif
@@ skipping 12 matching lines @@
     ListValue* view_intent_list = new ListValue;
     view_intent_list->Append(view_intent);
 
     DictionaryValue* intents = new DictionaryValue;
     intents->SetWithoutPathExpansion("http://webintents.org/view",
                                      view_intent_list);
     manifest.Set(keys::kIntents, intents);
 
     std::string error;
     scoped_refptr<Extension> intent_app = Extension::Create(
-        path, Extension::INVALID, manifest, Extension::NO_FLAGS, &error);
+        path, Manifest::INVALID_LOCATION, manifest,
+        Extension::NO_FLAGS, &error);
     EXPECT_TRUE(intent_app.get()) << error;
     return intent_app;
   }
 
   // Verifies that the set of extensions protecting |url| is *exactly* equal to
   // |expected_extensions|. Pass in an empty set to verify that an origin is not
   // protected.
   void ExpectProtectedBy(const ExtensionSet& expected_extensions,
                          const GURL& url) {
     const ExtensionSet* extensions = policy_->ExtensionsProtectingOrigin(url);
@@ skipping 149 matching lines @@
                                     CONTENT_SETTING_SESSION_ONLY);
 
   EXPECT_TRUE(policy_->HasSessionOnlyOrigins());
 
   // Clearing an origin-specific rule.
   cookie_settings->ResetCookieSetting(pattern,
                                       ContentSettingsPattern::Wildcard());
 
   EXPECT_FALSE(policy_->HasSessionOnlyOrigins());
 }