Move extension_error_utils.* and url_pattern_set.* into

chrome/browser/extensions/api/tabs/tabs.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/tabs/tabs.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 34 matching lines @@
 #include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/snapshot_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/tab_contents.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/window_sizer/window_sizer.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/windows.h"
 #include "chrome/common/extensions/extension.h"
-#include "chrome/common/extensions/extension_error_utils.h"
 #include "chrome/common/extensions/extension_manifest_constants.h"
 #include "chrome/common/extensions/extension_messages.h"
 #include "chrome/common/extensions/user_script.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/navigation_controller.h"
 #include "content/public/browser/navigation_entry.h"
 #include "content/public/browser/notification_details.h"
 #include "content/public/browser/notification_source.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_view.h"
 #include "content/public/common/url_constants.h"
 #include "extensions/common/constants.h"
+#include "extensions/common/extension_error_utils.h"
 #include "skia/ext/image_operations.h"
 #include "skia/ext/platform_canvas.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "ui/base/ui_base_types.h"
 #include "ui/gfx/codec/jpeg_codec.h"
 #include "ui/gfx/codec/png_codec.h"
 
 #if defined(OS_WIN)
 #include "base/win/metro.h"
 #endif  // OS_WIN
 
 namespace Get = extensions::api::windows::Get;
 namespace GetAll = extensions::api::windows::GetAll;
 namespace GetCurrent = extensions::api::windows::GetCurrent;
 namespace GetLastFocused = extensions::api::windows::GetLastFocused;
 namespace errors = extension_manifest_errors;
 namespace keys = extensions::tabs_constants;
 
 using content::NavigationController;
 using content::NavigationEntry;
 using content::OpenURLParams;
 using content::Referrer;
 using content::RenderViewHost;
 using content::WebContents;
+using extensions::ErrorUtils;
 using extensions::ScriptExecutor;
 using extensions::WindowController;
 using extensions::WindowControllerList;
 
 const int CaptureVisibleTabFunction::kDefaultQuality = 90;
 
 namespace {
 
 // |error_message| can optionally be passed in a will be set with an appropriate
 // message if the window cannot be found by id.
 Browser* GetBrowserInProfileWithId(Profile* profile,
                                    const int window_id,
                                    bool include_incognito,
                                    std::string* error_message) {
   Profile* incognito_profile =
       include_incognito && profile->HasOffTheRecordProfile() ?
           profile->GetOffTheRecordProfile() : NULL;
   for (BrowserList::const_iterator browser = BrowserList::begin();
        browser != BrowserList::end(); ++browser) {
     if (((*browser)->profile() == profile ||
          (*browser)->profile() == incognito_profile) &&
         ExtensionTabUtil::GetWindowId(*browser) == window_id &&
         ((*browser)->window()))
       return *browser;
   }
 
   if (error_message)
-    *error_message = ExtensionErrorUtils::FormatErrorMessage(
+    *error_message = ErrorUtils::FormatErrorMessage(
         keys::kWindowNotFoundError, base::IntToString(window_id));
 
   return NULL;
 }
 
 bool GetBrowserFromWindowID(
     UIThreadExtensionFunction* function, int window_id, Browser** browser) {
   if (window_id == extension_misc::kCurrentWindowId) {
     *browser = function->GetCurrentBrowser();
     if (!(*browser) || !(*browser)->window()) {
@@ skipping 27 matching lines @@
           CurrentWindowForFunction(function);
     }
     if (!(*controller)) {
       function->SetError(keys::kNoCurrentWindowError);
       return false;
     }
   } else {
     *controller = WindowControllerList::GetInstance()->
         FindWindowForFunctionById(function, window_id);
     if (!(*controller)) {
-      function->SetError(ExtensionErrorUtils::FormatErrorMessage(
+      function->SetError(ErrorUtils::FormatErrorMessage(
           keys::kWindowNotFoundError, base::IntToString(window_id)));
       return false;
     }
   }
   return true;
 }
 
 // |error_message| can optionally be passed in and will be set with an
 // appropriate message if the tab cannot be found by id.
 bool GetTabById(int tab_id,
                 Profile* profile,
                 bool include_incognito,
                 Browser** browser,
                 TabStripModel** tab_strip,
                 content::WebContents** contents,
                 int* tab_index,
                 std::string* error_message) {
   if (ExtensionTabUtil::GetTabById(tab_id, profile, include_incognito,
                                    browser, tab_strip, contents, tab_index))
     return true;
 
   if (error_message)
-    *error_message = ExtensionErrorUtils::FormatErrorMessage(
+    *error_message = ErrorUtils::FormatErrorMessage(
         keys::kTabNotFoundError, base::IntToString(tab_id));
 
   return false;
 }
 
 // A three state enum to distinguish between when a boolean query argument is
 // set or not.
 enum QueryArg {
   NOT_SET = -1,
   MATCH_FALSE,
@@ skipping 168 matching lines @@
     for (size_t i = 0; i < urls->size();) {
       if (chrome::IsURLAllowedInIncognito((*urls)[i], profile())) {
         i++;
       } else {
         if (first_url_erased.empty())
           first_url_erased = (*urls)[i].spec();
         urls->erase(urls->begin() + i);
       }
     }
     if (urls->empty() && !first_url_erased.empty()) {
-      error_ = ExtensionErrorUtils::FormatErrorMessage(
+      error_ = ErrorUtils::FormatErrorMessage(
           keys::kURLsNotAllowedInIncognitoError, first_url_erased);
       *is_error = true;
       return false;
     }
   }
   return incognito;
 }
 
 bool CreateWindowFunction::RunImpl() {
   DictionaryValue* args = NULL;
@@ skipping 23 matching lines @@
           url_strings.push_back(url_string);
         }
       }
 
       // Second, resolve, validate and convert them to GURLs.
       for (std::vector<std::string>::iterator i = url_strings.begin();
            i != url_strings.end(); ++i) {
         GURL url = ExtensionTabUtil::ResolvePossiblyRelativeURL(
             *i, GetExtension());
         if (!url.is_valid()) {
-          error_ = ExtensionErrorUtils::FormatErrorMessage(
+          error_ = ErrorUtils::FormatErrorMessage(
               keys::kInvalidUrlError, *i);
           return false;
         }
         // Don't let the extension crash the browser or renderers.
         if (ExtensionTabUtil::IsCrashURL(url)) {
           error_ = keys::kNoCrashBrowserError;
           return false;
         }
         urls.push_back(url);
       }
     }
   }
 
   // Look for optional tab id.
   if (args) {
     int tab_id = -1;
     if (args->HasKey(keys::kTabIdKey)) {
       EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kTabIdKey, &tab_id));
 
       // Find the tab and detach it from the original window.
       TabStripModel* source_tab_strip = NULL;
       int tab_index = -1;
       if (!GetTabById(tab_id, profile(), include_incognito(),
                       NULL, &source_tab_strip,
                       NULL, &tab_index, &error_))
         return false;
       contents = source_tab_strip->DetachTabContentsAt(tab_index);
       if (!contents) {
-        error_ = ExtensionErrorUtils::FormatErrorMessage(
+        error_ = ErrorUtils::FormatErrorMessage(
             keys::kTabNotFoundError, base::IntToString(tab_id));
         return false;
       }
     }
   }
 
   Profile* window_profile = profile();
   Browser::Type window_type = Browser::TYPE_TABBED;
 
   // panel_create_mode only applies if window is TYPE_PANEL.
@@ skipping 553 matching lines @@
   // -favIconUrl
 
   std::string url_string;
   GURL url;
   if (args->HasKey(keys::kUrlKey)) {
     EXTENSION_FUNCTION_VALIDATE(args->GetString(keys::kUrlKey,
                                                 &url_string));
     url = ExtensionTabUtil::ResolvePossiblyRelativeURL(url_string,
                                                        GetExtension());
     if (!url.is_valid()) {
-      error_ = ExtensionErrorUtils::FormatErrorMessage(keys::kInvalidUrlError,
+      error_ = ErrorUtils::FormatErrorMessage(keys::kInvalidUrlError,
                                                        url_string);
       return false;
     }
   }
 
   // Don't let extensions crash the browser or renderers.
   if (ExtensionTabUtil::IsCrashURL(url)) {
     error_ = keys::kNoCrashBrowserError;
     return false;
   }
@@ skipping 147 matching lines @@
   std::vector<int> tab_indices;
   EXTENSION_FUNCTION_VALIDATE(extensions::ReadOneOrMoreIntegers(
       tab_value, &tab_indices));
 
   // Create a new selection model as we read the list of tab indices.
   for (size_t i = 0; i < tab_indices.size(); ++i) {
     int index = tab_indices[i];
 
     // Make sure the index is in range.
     if (!tabstrip->ContainsIndex(index)) {
-      error_ = ExtensionErrorUtils::FormatErrorMessage(
+      error_ = ErrorUtils::FormatErrorMessage(
           keys::kTabIndexNotFoundError, base::IntToString(index));
       return false;
     }
 
     // By default, we make the first tab in the list active.
     if (active_index == -1)
       active_index = index;
 
     selection.AddIndexToSelection(index);
   }
@@ skipping 125 matching lines @@
   if (!update_props->HasKey(keys::kUrlKey))
     return true;
 
   std::string url_string;
   EXTENSION_FUNCTION_VALIDATE(update_props->GetString(
       keys::kUrlKey, &url_string));
   GURL url = ExtensionTabUtil::ResolvePossiblyRelativeURL(
       url_string, GetExtension());
 
   if (!url.is_valid()) {
-    error_ = ExtensionErrorUtils::FormatErrorMessage(
+    error_ = ErrorUtils::FormatErrorMessage(
         keys::kInvalidUrlError, url_string);
     return false;
   }
 
   // Don't let the extension crash the browser or renderers.
   if (ExtensionTabUtil::IsCrashURL(url)) {
     error_ = keys::kNoCrashBrowserError;
     return false;
   }
 
@@ skipping 110 matching lines @@
         return false;
       }
 
       // If windowId is different from the current window, move between windows.
       if (ExtensionTabUtil::GetWindowId(target_browser) !=
           ExtensionTabUtil::GetWindowId(source_browser)) {
         TabStripModel* target_tab_strip = target_browser->tab_strip_model();
         TabContents* tab_contents =
             source_tab_strip->DetachTabContentsAt(tab_index);
         if (!tab_contents) {
-          error_ = ExtensionErrorUtils::FormatErrorMessage(
+          error_ = ErrorUtils::FormatErrorMessage(
               keys::kTabNotFoundError, base::IntToString(tab_ids[i]));
           return false;
         }
 
         // Clamp move location to the last position.
         // This is ">" because it can append to a new index position.
         // -1 means set the move location to the last position.
         if (new_index > target_tab_strip->count() || new_index < 0)
           new_index = target_tab_strip->count();
 
@@ skipping 382 matching lines @@
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
   SetResult(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }