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

chrome/browser/extensions/extension_function_test_utils.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 "chrome/browser/extensions/extension_function_test_utils.h"
 
 #include <string>
 
 #include "base/file_path.h"
 #include "base/json/json_reader.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::WebContents;
 using extensions::Extension;
+using extensions::Manifest;
 namespace keys = extensions::tabs_constants;
 
 namespace {
 
 class TestFunctionDispatcherDelegate
     : public ExtensionFunctionDispatcher::Delegate {
  public:
   explicit TestFunctionDispatcherDelegate(Browser* browser) :
       browser_(browser) {}
   virtual ~TestFunctionDispatcherDelegate() {}
@@ skipping 63 matching lines @@
   return static_cast<base::DictionaryValue*>(val);
 }
 
 base::ListValue* ToList(base::Value* val) {
   EXPECT_TRUE(val);
   EXPECT_EQ(base::Value::TYPE_LIST, val->GetType());
   return static_cast<base::ListValue*>(val);
 }
 
 scoped_refptr<Extension> CreateEmptyExtension() {
-  return CreateEmptyExtensionWithLocation(Extension::INTERNAL);
+  return CreateEmptyExtensionWithLocation(Manifest::INTERNAL);
 }
 
 scoped_refptr<Extension> CreateEmptyExtensionWithLocation(
-    Extension::Location location) {
+    Manifest::Location location) {
   scoped_ptr<base::DictionaryValue> test_extension_value(
       ParseDictionary("{\"name\": \"Test\", \"version\": \"1.0\"}"));
   return CreateExtension(location, test_extension_value.get(), std::string());
 }
 
 scoped_refptr<Extension> CreateEmptyExtension(
     const std::string& id_input) {
   scoped_ptr<base::DictionaryValue> test_extension_value(
       ParseDictionary("{\"name\": \"Test\", \"version\": \"1.0\"}"));
-  return CreateExtension(Extension::INTERNAL, test_extension_value.get(),
+  return CreateExtension(Manifest::INTERNAL, test_extension_value.get(),
                          id_input);
 }
 
 scoped_refptr<Extension> CreateExtension(
     base::DictionaryValue* test_extension_value) {
-  return CreateExtension(Extension::INTERNAL, test_extension_value,
+  return CreateExtension(Manifest::INTERNAL, test_extension_value,
                          std::string());
 }
 
 scoped_refptr<Extension> CreateExtension(
-    Extension::Location location,
+    Manifest::Location location,
     base::DictionaryValue* test_extension_value,
     const std::string& id_input) {
   std::string error;
   const FilePath test_extension_path;
   std::string id;
   if (!id_input.empty())
     CHECK(Extension::GenerateId(id_input, &id));
   scoped_refptr<Extension> extension(Extension::Create(
       test_extension_path,
       location,
@@ skipping 120 matching lines @@
   if (!response_delegate.HasResponse()) {
     response_delegate.set_should_post_quit(true);
     content::RunMessageLoop();
   }
 
   EXPECT_TRUE(response_delegate.HasResponse());
   return response_delegate.GetResponse();
 }
 
 } // namespace extension_function_test_utils