Move ExtensionWindowController and related into extensions namespace

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>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_function_util.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
-#include "chrome/browser/extensions/extension_window_controller.h"
-#include "chrome/browser/extensions/extension_window_list.h"
 #include "chrome/browser/extensions/script_executor.h"
+#include "chrome/browser/extensions/window_controller.h"
+#include "chrome/browser/extensions/window_controller_list.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/sessions/restore_tab_helper.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
@@ skipping 48 matching lines @@
 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::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,
@@ skipping 32 matching lines @@
     if (!*browser) {
       function->SetError(error);
       return false;
     }
   }
   return true;
 }
 
 bool GetWindowFromWindowID(UIThreadExtensionFunction* function,
                            int window_id,
-                           ExtensionWindowController** controller) {
+                           WindowController** controller) {
   if (window_id == extension_misc::kCurrentWindowId) {
-    ExtensionWindowController* extension_window_controller =
+    WindowController* extension_window_controller =
         function->dispatcher()->delegate()->GetExtensionWindowController();
     // If there is a window controller associated with this extension, use that.
     if (extension_window_controller) {
       *controller = extension_window_controller;
     } else {
       // Otherwise get the focused or most recently added window.
-      *controller = ExtensionWindowList::GetInstance()->
+      *controller = WindowControllerList::GetInstance()->
           CurrentWindowForFunction(function);
     }
     if (!(*controller)) {
       function->SetError(keys::kNoCurrentWindowError);
       return false;
     }
   } else {
-    *controller = ExtensionWindowList::GetInstance()->FindWindowForFunctionById(
-        function, window_id);
+    *controller = WindowControllerList::GetInstance()->
+        FindWindowForFunctionById(function, window_id);
     if (!(*controller)) {
       function->SetError(ExtensionErrorUtils::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.
@@ skipping 68 matching lines @@
 // Windows ---------------------------------------------------------------------
 
 bool GetWindowFunction::RunImpl() {
   scoped_ptr<Get::Params> params(Get::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
-  ExtensionWindowController* controller;
+  WindowController* controller;
   if (!GetWindowFromWindowID(this, params->window_id, &controller))
     return false;
 
   if (populate_tabs)
     SetResult(controller->CreateWindowValueWithTabs());
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
 bool GetCurrentWindowFunction::RunImpl() {
   scoped_ptr<GetCurrent::Params> params(GetCurrent::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
-  ExtensionWindowController* controller;
+  WindowController* controller;
   if (!GetWindowFromWindowID(this,
                              extension_misc::kCurrentWindowId,
                              &controller)) {
     return false;
   }
   if (populate_tabs)
     SetResult(controller->CreateWindowValueWithTabs());
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
 bool GetLastFocusedWindowFunction::RunImpl() {
   scoped_ptr<GetLastFocused::Params> params(
       GetLastFocused::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
   // Note: currently this returns the last active browser. If we decide to
   // include other window types (e.g. panels), we will need to add logic to
-  // ExtensionWindowList that mirrors the active behavior of BrowserList.
+  // WindowControllerList that mirrors the active behavior of BrowserList.
   Browser* browser = browser::FindAnyBrowser(
       profile(), include_incognito());
   if (!browser || !browser->window()) {
     error_ = keys::kNoLastFocusedWindowError;
     return false;
   }
-  ExtensionWindowController* controller =
+  WindowController* controller =
       browser->extension_window_controller();
   if (populate_tabs)
     SetResult(controller->CreateWindowValueWithTabs());
   else
     SetResult(controller->CreateWindowValue());
   return true;
 }
 
 bool GetAllWindowsFunction::RunImpl() {
   scoped_ptr<GetAll::Params> params(GetAll::Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
   bool populate_tabs = false;
   if (params->get_info.get() && params->get_info->populate.get())
     populate_tabs = *params->get_info->populate;
 
   ListValue* window_list = new ListValue();
-  const ExtensionWindowList::WindowList& windows =
-      ExtensionWindowList::GetInstance()->windows();
-  for (ExtensionWindowList::WindowList::const_iterator iter =
+  const WindowControllerList::ControllerList& windows =
+      WindowControllerList::GetInstance()->windows();
+  for (WindowControllerList::ControllerList::const_iterator iter =
            windows.begin();
        iter != windows.end(); ++iter) {
     if (!this->CanOperateOnWindow(*iter))
       continue;
     if (populate_tabs)
       window_list->Append((*iter)->CreateWindowValueWithTabs());
     else
       window_list->Append((*iter)->CreateWindowValue());
   }
   SetResult(window_list);
@@ skipping 303 matching lines @@
 
   return true;
 }
 
 bool UpdateWindowFunction::RunImpl() {
   int window_id = extension_misc::kUnknownWindowId;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
   DictionaryValue* update_props;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
-  ExtensionWindowController* controller;
+  WindowController* controller;
   if (!GetWindowFromWindowID(this, window_id, &controller))
     return false;
 
   ui::WindowShowState show_state = ui::SHOW_STATE_DEFAULT;  // No change.
   std::string state_str;
   if (update_props->HasKey(keys::kShowStateKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetString(keys::kShowStateKey,
                                                         &state_str));
     if (state_str == keys::kShowStateValueNormal) {
       show_state = ui::SHOW_STATE_NORMAL;
@@ skipping 113 matching lines @@
 
   SetResult(controller->CreateWindowValue());
 
   return true;
 }
 
 bool RemoveWindowFunction::RunImpl() {
   int window_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
-  ExtensionWindowController* controller;
+  WindowController* controller;
   if (!GetWindowFromWindowID(this, window_id, &controller))
     return false;
 
-  ExtensionWindowController::Reason reason;
+  WindowController::Reason reason;
   if (!controller->CanClose(&reason)) {
-    if (reason == ExtensionWindowController::REASON_NOT_EDITABLE)
+    if (reason == WindowController::REASON_NOT_EDITABLE)
       error_ = keys::kTabStripNotEditableError;
     return false;
   }
   controller->window()->Close();
   return true;
 }
 
 // Tabs ------------------------------------------------------------------------
 
 bool GetSelectedTabFunction::RunImpl() {
@@ skipping 1005 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()
 }