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

chrome/browser/intents/web_intents_registry_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/bind.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/test_extension_service.h"
 #include "chrome/browser/intents/default_web_intent_service.h"
 #include "chrome/browser/intents/web_intents_registry.h"
 #include "chrome/browser/webdata/web_data_service.h"
 #include "chrome/common/chrome_paths.h"
+#include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_set.h"
+#include "chrome/common/extensions/manifest.h"
 #include "chrome/common/extensions/manifest_handler.h"
 #include "chrome/common/extensions/web_intents_handler.h"
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using extensions::Extension;
+using extensions::Manifest;
 using webkit_glue::WebIntentServiceData;
 
 class MockExtensionService: public TestExtensionService {
  public:
   virtual ~MockExtensionService() {}
   MOCK_CONST_METHOD0(extensions, const ExtensionSet*());
   MOCK_CONST_METHOD2(GetExtensionById,
                      const Extension*(const std::string&, bool));
   MOCK_CONST_METHOD1(GetInstalledExtension,
                      const Extension*(const std::string& id));
 };
 
 namespace {
 
 // TODO(groby): Unify loading functions with extension_manifest_unittest code.
 DictionaryValue* LoadManifestFile(const FilePath& path,
                                   std::string* error) {
   EXPECT_TRUE(file_util::PathExists(path));
   JSONFileValueSerializer serializer(path);
   return static_cast<DictionaryValue*>(serializer.Deserialize(NULL, error));
 }
 
 scoped_refptr<Extension> LoadExtensionWithLocation(
     const std::string& name,
-    Extension::Location location,
+    Manifest::Location location,
     std::string* error) {
   FilePath path;
   PathService::Get(chrome::DIR_TEST_DATA, &path);
   path = path.AppendASCII("extensions")
       .AppendASCII("manifest_tests")
       .AppendASCII(name.c_str());
   scoped_ptr<DictionaryValue> value(LoadManifestFile(path, error));
   if (!value.get())
     return NULL;
   return Extension::Create(path.DirName(),
                            location,
                            *value,
                            Extension::NO_FLAGS,
                            Extension::GenerateIdForPath(path),
                            error);
 }
 
 scoped_refptr<Extension> LoadExtension(const std::string& name,
                                        std::string* error) {
-  return LoadExtensionWithLocation(name, Extension::INTERNAL, error);
+  return LoadExtensionWithLocation(name, Manifest::INTERNAL, error);
 }
 
 scoped_refptr<Extension> LoadAndExpectSuccess(const std::string& name) {
   std::string error;
   scoped_refptr<Extension> extension = LoadExtension(name, &error);
   EXPECT_TRUE(extension) << name;
   EXPECT_EQ("", error) << name;
   return extension;
 }
 
@@ skipping 711 matching lines @@
 
   registry_.GetAllDefaultIntentServices(
       base::Bind(&DefaultServiceListConsumer::Accept,
                  base::Unretained(&consumer)));
 
   consumer.WaitForData();
 
   ASSERT_EQ(1U, consumer.services_.size());
   EXPECT_EQ(service_url_1.spec(), consumer.services_[0].service_url);
 }