Move extension_error_utils.* and url_pattern_set.* into

chrome/browser/extensions/api/context_menu/context_menu_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/context_menu/context_menu_api.h"
 
 #include <string>
 
-#include "base/values.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
+#include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/menu_manager.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/context_menus.h"
-#include "chrome/common/extensions/extension_error_utils.h"
-#include "chrome/common/extensions/url_pattern_set.h"
+#include "extensions/common/extension_error_utils.h"
+#include "extensions/common/url_pattern_set.h"
+
+using extensions::ErrorUtils;
 
 namespace {
 
 const char kGeneratedIdKey[] = "generatedId";
 
 const char kCannotFindItemError[] = "Cannot find menu item with id *";
 const char kOnclickDisallowedError[] = "Extensions using event pages cannot "
     "pass an onclick parameter to chrome.contextMenus.create. Instead, use "
     "the chrome.contextMenus.onClicked event.";
 const char kCheckedError[] =
@@ skipping 93 matching lines @@
       break;
   }
   return parent_id.Pass();
 }
 
 extensions::MenuItem* GetParent(extensions::MenuItem::Id parent_id,
                                 const extensions::MenuManager* menu_manager,
                                 std::string* error) {
   extensions::MenuItem* parent = menu_manager->GetItemById(parent_id);
   if (!parent) {
-    *error = ExtensionErrorUtils::FormatErrorMessage(
+    *error = ErrorUtils::FormatErrorMessage(
         kCannotFindItemError, GetIDString(parent_id));
     return NULL;
   }
   if (parent->type() != extensions::MenuItem::NORMAL) {
     *error = kParentsMustBeNormalError;
     return NULL;
   }
 
   return parent;
 }
@@ skipping 26 matching lines @@
                                                        &id.uid));
   }
 
   std::string title;
   if (params->create_properties.title.get())
     title = *params->create_properties.title;
 
   MenuManager* menu_manager = profile()->GetExtensionService()->menu_manager();
 
   if (menu_manager->GetItemById(id)) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(kDuplicateIDError,
+    error_ = ErrorUtils::FormatErrorMessage(kDuplicateIDError,
                                                      GetIDString(id));
     return false;
   }
 
   if (GetExtension()->has_lazy_background_page() &&
       params->create_properties.onclick.get()) {
     error_ = kOnclickDisallowedError;
     return false;
   }
 
@@ skipping 68 matching lines @@
       item_id.uid = *params->id_integer;
       break;
     case Update::Params::ID_NONE:
       NOTREACHED();
   }
 
   ExtensionService* service = profile()->GetExtensionService();
   MenuManager* manager = service->menu_manager();
   MenuItem* item = manager->GetItemById(item_id);
   if (!item || item->extension_id() != extension_id()) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(
+    error_ = ErrorUtils::FormatErrorMessage(
         kCannotFindItemError, GetIDString(item_id));
     return false;
   }
 
   // Type.
   MenuItem::Type type = GetType(params->update_properties);
 
   if (type != item->type()) {
     if (type == MenuItem::RADIO || item->type() == MenuItem::RADIO)
       radio_item_updated = true;
@@ skipping 89 matching lines @@
     case Remove::Params::MENU_ITEM_ID_INTEGER:
       id.uid = *params->menu_item_id_integer;
       break;
     case Remove::Params::MENU_ITEM_ID_NONE:
       NOTREACHED();
   }
 
   MenuItem* item = manager->GetItemById(id);
   // Ensure one extension can't remove another's menu items.
   if (!item || item->extension_id() != extension_id()) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(
+    error_ = ErrorUtils::FormatErrorMessage(
         kCannotFindItemError, GetIDString(id));
     return false;
   }
 
   if (!manager->RemoveContextMenuItem(id))
     return false;
   manager->WriteToStorage(GetExtension());
   return true;
 }
 
 bool RemoveAllContextMenusFunction::RunImpl() {
   ExtensionService* service = profile()->GetExtensionService();
   MenuManager* manager = service->menu_manager();
   manager->RemoveAllContextItems(GetExtension()->id());
   manager->WriteToStorage(GetExtension());
   return true;
 }
 
 }  // namespace extensions