Move extension_error_utils.* and url_pattern_set.* into

chrome/browser/extensions/api/management/management_api.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/api/management/management_api.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
@@ skipping 14 matching lines @@
 #include "chrome/browser/extensions/extension_uninstall_dialog.h"
 #include "chrome/browser/extensions/management_policy.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/webui/extensions/extension_icon_source.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_utility_messages.h"
 #include "chrome/common/extensions/api/management.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_constants.h"
-#include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_icon_set.h"
 #include "chrome/common/extensions/permissions/permission_set.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/utility_process_host.h"
 #include "content/public/browser/utility_process_host_client.h"
+#include "extensions/common/extension_error_utils.h"
 #include "extensions/common/url_pattern.h"
 
 #if !defined(OS_ANDROID)
 #include "chrome/browser/ui/webui/ntp/app_launcher_handler.h"
 #endif
 
 using base::IntToString;
 using content::BrowserThread;
 using content::UtilityProcessHost;
 using content::UtilityProcessHostClient;
 using extensions::api::management::ExtensionInfo;
 using extensions::api::management::IconInfo;
+using extensions::ErrorUtils;
 using extensions::Extension;
 using extensions::ExtensionSystem;
 using extensions::PermissionMessages;
 
 namespace events = extensions::event_names;
 namespace keys = extension_management_api_constants;
 namespace management = extensions::api::management;
 
 namespace {
 
@@ skipping 91 matching lines @@
   const std::set<std::string> perms =
       extension.GetActivePermissions()->GetAPIsAsStrings();
   if (!perms.empty()) {
     std::set<std::string>::const_iterator perms_iter;
     for (perms_iter = perms.begin(); perms_iter != perms.end(); ++perms_iter)
       info->permissions.push_back(*perms_iter);
   }
 
   if (!extension.is_hosted_app()) {
     // Skip host permissions for hosted apps.
-    const URLPatternSet host_perms =
+    const extensions::URLPatternSet host_perms =
         extension.GetActivePermissions()->explicit_hosts();
     if (!host_perms.is_empty()) {
-      for (URLPatternSet::const_iterator iter = host_perms.begin();
+      for (extensions::URLPatternSet::const_iterator iter = host_perms.begin();
            iter != host_perms.end(); ++iter) {
         info->host_permissions.push_back(iter->GetAsString());
       }
     }
   }
 
   switch (extension.location()) {
     case Extension::INTERNAL:
       info->install_type = management::ExtensionInfo::INSTALL_TYPE_NORMAL;
       break;
@@ skipping 53 matching lines @@
   return true;
 }
 
 bool GetExtensionByIdFunction::RunImpl() {
   scoped_ptr<management::Get::Params> params(
       management::Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const Extension* extension = service()->GetExtensionById(params->id, true);
   if (!extension) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
+    error_ = ErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
                                                      params->id);
     return false;
   }
 
   scoped_ptr<management::ExtensionInfo> info = CreateExtensionInfo(
       *extension, ExtensionSystem::Get(profile()));
   results_ = management::Get::Results::Create(*info);
 
   return true;
 }
 
 bool GetPermissionWarningsByIdFunction::RunImpl() {
   scoped_ptr<management::GetPermissionWarningsById::Params> params(
       management::GetPermissionWarningsById::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   const Extension* extension = service()->GetExtensionById(params->id, true);
   if (!extension) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
+    error_ = ErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
                                                      params->id);
     return false;
   }
 
   std::vector<std::string> warnings = CreateWarningsList(extension);
   results_ = management::GetPermissionWarningsById::Results::Create(warnings);
   return true;
 }
 
 namespace {
@@ skipping 130 matching lines @@
   // Matched with AddRef() in RunImpl().
   Release();
 }
 
 bool LaunchAppFunction::RunImpl() {
   scoped_ptr<management::LaunchApp::Params> params(
       management::LaunchApp::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
   const Extension* extension = service()->GetExtensionById(params->id, true);
   if (!extension) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
+    error_ = ErrorUtils::FormatErrorMessage(keys::kNoExtensionError,
                                                      params->id);
     return false;
   }
   if (!extension->is_app()) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kNotAnAppError,
+    error_ = ErrorUtils::FormatErrorMessage(keys::kNotAnAppError,
                                                      params->id);
     return false;
   }
 
   // Look at prefs to find the right launch container.
   // |default_pref_value| is set to LAUNCH_REGULAR so that if
   // the user has not set a preference, we open the app in a tab.
   extension_misc::LaunchContainer launch_container =
       service()->extension_prefs()->GetLaunchContainer(
           extension, extensions::ExtensionPrefs::LAUNCH_DEFAULT);
@@ skipping 15 matching lines @@
 
 bool SetEnabledFunction::RunImpl() {
   scoped_ptr<management::SetEnabled::Params> params(
       management::SetEnabled::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   extension_id_ = params->id;
 
   const Extension* extension = service()->GetInstalledExtension(extension_id_);
   if (!extension) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(
+    error_ = ErrorUtils::FormatErrorMessage(
         keys::kNoExtensionError, extension_id_);
     return false;
   }
 
   const extensions::ManagementPolicy* policy = extensions::ExtensionSystem::Get(
       profile())->management_policy();
   if (!policy->UserMayModifySettings(extension, NULL)) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(
+    error_ = ErrorUtils::FormatErrorMessage(
         keys::kUserCantModifyError, extension_id_);
     return false;
   }
 
   bool currently_enabled = service()->IsExtensionEnabled(extension_id_);
 
   if (!currently_enabled && params->enabled) {
     extensions::ExtensionPrefs* prefs = service()->extension_prefs();
     if (prefs->DidExtensionEscalatePermissions(extension_id_)) {
       if (!user_gesture()) {
@@ skipping 43 matching lines @@
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   extension_id_ = params->id;
 
   bool show_confirm_dialog = false;
   if (params->options.get() && params->options->show_confirm_dialog.get())
     show_confirm_dialog = *params->options->show_confirm_dialog;
 
   const Extension* extension = service()->GetExtensionById(extension_id_, true);
   if (!extension) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(
+    error_ = ErrorUtils::FormatErrorMessage(
         keys::kNoExtensionError, extension_id_);
     return false;
   }
 
   if (!extensions::ExtensionSystem::Get(
       profile())->management_policy()->UserMayModifySettings(extension, NULL)) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(
+    error_ = ErrorUtils::FormatErrorMessage(
         keys::kUserCantModifyError, extension_id_);
     return false;
   }
 
   if (auto_confirm_for_test == DO_NOT_SKIP) {
     if (show_confirm_dialog) {
       AddRef(); // Balanced in ExtensionUninstallAccepted/Canceled
       extension_uninstall_dialog_.reset(ExtensionUninstallDialog::Create(
           GetCurrentBrowser(), this));
       extension_uninstall_dialog_->ConfirmUninstall(extension);
@@ skipping 15 matching lines @@
 void UninstallFunction::Finish(bool should_uninstall) {
   if (should_uninstall) {
     bool success = service()->UninstallExtension(
         extension_id_,
         false, /* external uninstall */
         NULL);
 
     // TODO set error_ if !success
     SendResponse(success);
   } else {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(
+    error_ = ErrorUtils::FormatErrorMessage(
         keys::kUninstallCanceledError, extension_id_);
     SendResponse(false);
   }
 
 }
 
 void UninstallFunction::ExtensionUninstallAccepted() {
   Finish(true);
   Release();
 }
@@ skipping 64 matching lines @@
     CHECK(extension);
     scoped_ptr<management::ExtensionInfo> info = CreateExtensionInfo(
         *extension, ExtensionSystem::Get(profile));
     args->Append(info->ToValue().release());
   }
 
   extensions::ExtensionSystem::Get(profile)->event_router()->
       DispatchEventToRenderers(event_name, args.Pass(), NULL, GURL(),
                                extensions::EventFilteringInfo());
 }