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

chrome/browser/extensions/extension_browsertest.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_browsertest.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/file_path.h"
@@ skipping 29 matching lines @@
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/test/browser_test_utils.h"
 #include "sync/api/string_ordinal.h"
 
 using extensions::Extension;
 using extensions::ExtensionCreator;
 using extensions::FeatureSwitch;
+using extensions::Manifest;
 
 ExtensionBrowserTest::ExtensionBrowserTest()
     : loaded_(false),
       installed_(false),
       extension_installs_observed_(0),
       extension_load_errors_observed_(0),
       target_page_action_count_(-1),
       target_visible_page_action_count_(-1),
       current_channel_(chrome::VersionInfo::CHANNEL_DEV),
       override_prompt_for_external_extensions_(
@@ skipping 45 matching lines @@
        iter != service->extensions()->end(); ++iter) {
     if ((*iter)->path() == extension_path) {
       extension = *iter;
       break;
     }
   }
   if (!extension)
     return NULL;
 
   if (!(flags & kFlagIgnoreManifestWarnings)) {
-    const Extension::InstallWarningVector& install_warnings =
+    const std::vector<extensions::InstallWarning>& install_warnings =
         extension->install_warnings();
     if (!install_warnings.empty()) {
       std::string install_warnings_message = StringPrintf(
           "Unexpected warnings when loading test extension %s:\n",
           path.AsUTF8Unsafe().c_str());
 
-      for (Extension::InstallWarningVector::const_iterator it =
+      for (std::vector<extensions::InstallWarning>::const_iterator it =
           install_warnings.begin(); it != install_warnings.end(); ++it) {
         install_warnings_message += "  " + it->message + "\n";
       }
 
       EXPECT_TRUE(extension->install_warnings().empty()) <<
           install_warnings_message;
       return NULL;
     }
   }
 
@@ skipping 156 matching lines @@
                               const Extension* extension,
                               const ShowDialogCallback& show_dialog_callback) {
     delegate->InstallUIProceed();
   }
 };
 
 const Extension* ExtensionBrowserTest::InstallExtensionFromWebstore(
     const FilePath& path,
     int expected_change) {
   return InstallOrUpdateExtension("", path, INSTALL_UI_TYPE_NONE,
-                                  expected_change, Extension::INTERNAL,
+                                  expected_change, Manifest::INTERNAL,
                                   browser(), true);
 }
 
 const Extension* ExtensionBrowserTest::InstallOrUpdateExtension(
     const std::string& id,
     const FilePath& path,
     InstallUIType ui_type,
     int expected_change) {
   return InstallOrUpdateExtension(id, path, ui_type, expected_change,
-                                  Extension::INTERNAL, browser(), false);
+                                  Manifest::INTERNAL, browser(), false);
 }
 
 const Extension* ExtensionBrowserTest::InstallOrUpdateExtension(
     const std::string& id,
     const FilePath& path,
     InstallUIType ui_type,
     int expected_change,
     Browser* browser,
     bool from_webstore) {
   return InstallOrUpdateExtension(id, path, ui_type, expected_change,
-                                  Extension::INTERNAL, browser, from_webstore);
+                                  Manifest::INTERNAL, browser, from_webstore);
 }
 
 const Extension* ExtensionBrowserTest::InstallOrUpdateExtension(
     const std::string& id,
     const FilePath& path,
     InstallUIType ui_type,
     int expected_change,
-    Extension::Location install_source) {
+    Manifest::Location install_source) {
   return InstallOrUpdateExtension(id, path, ui_type, expected_change,
                                   install_source, browser(), false);
 }
 
 const Extension* ExtensionBrowserTest::InstallOrUpdateExtension(
     const std::string& id,
     const FilePath& path,
     InstallUIType ui_type,
     int expected_change,
-    Extension::Location install_source,
+    Manifest::Location install_source,
     Browser* browser,
     bool from_webstore) {
   ExtensionService* service = browser->profile()->GetExtensionService();
   service->set_show_extensions_prompts(false);
   size_t num_before = service->extensions()->size();
 
   {
     ExtensionInstallPrompt* install_ui = NULL;
     if (ui_type == INSTALL_UI_TYPE_CANCEL) {
       install_ui = new MockAbortExtensionInstallPrompt();
@@ skipping 340 matching lines @@
     case content::NOTIFICATION_LOAD_STOP:
       VLOG(1) << "Got LOAD_STOP notification.";
       MessageLoopForUI::current()->Quit();
       break;
 
     default:
       NOTREACHED();
       break;
   }
 }