Create BaseWindow and ExtensionWindowWrapper for extension API access to Panels

chrome/browser/extensions/extension_tabs_module.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_tabs_module.h"
 
 #include <algorithm>
 #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/extension_function_dispatcher.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/extension_tabs_module_constants.h"
+#include "chrome/browser/extensions/extension_window_controller.h"
+#include "chrome/browser/extensions/extension_window_list.h"
 #include "chrome/browser/net/url_fixer_upper.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/tabs/tab_strip_model.h"
 #include "chrome/browser/translate/translate_tab_helper.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_navigator.h"
 #include "chrome/browser/ui/browser_window.h"
@@ skipping 83 matching lines @@
     *browser = GetBrowserInProfileWithId(
         function->profile(), window_id, function->include_incognito(), &error);
     if (!*browser) {
       function->SetError(error);
       return false;
     }
   }
   return true;
 }
 
+ExtensionWindowController::ProfileMatchType ProfileMatchType(
+    bool include_incognito) {
+  return include_incognito ?
+      ExtensionWindowController::MATCH_INCOGNITO
+      : ExtensionWindowController::MATCH_NORMAL_ONLY;
+}
+
+bool GetWindowFromWindowID(UIThreadExtensionFunction* function,
+                           int window_id,
+                           ExtensionWindowController** controller) {
+  if (window_id == extension_misc::kCurrentWindowId) {
+    Browser* browser = function->dispatcher()->delegate()->GetBrowser();
+    // If there is a windowed browser associated with this extension, use that.
+    if (browser && browser->extension_window_controller()) {
+      *controller = browser->extension_window_controller();
+    } else {
+      // Otherwise get the focused or most recently added window.
+      *controller = ExtensionWindowList::GetInstance()->CurrentWindow(
+          function->profile(),
+          ProfileMatchType(function->include_incognito()));
+    }
+    if (!(*controller)) {
+      function->SetError(keys::kNoCurrentWindowError);
+      return false;
+    }
+  } else {
+    *controller = ExtensionWindowList::GetInstance()->FindWindowById(
+        function->profile(),
+        ProfileMatchType(function->include_incognito()),
+        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.
 bool GetTabById(int tab_id,
                 Profile* profile,
                 bool include_incognito,
                 Browser** browser,
                 TabStripModel** tab_strip,
                 TabContentsWrapper** contents,
                 int* tab_index,
                 std::string* error_message) {
@@ skipping 85 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;
 
-  Browser* browser = NULL;
-  if (!GetBrowserFromWindowID(this, params->window_id, &browser))
+  ExtensionWindowController* controller;
+  if (!GetWindowFromWindowID(this, params->window_id, &controller))
     return false;
 
-  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, populate_tabs));
+  if (populate_tabs)
+    result_.reset(controller->CreateWindowValueWithTabs());
+  else
+    result_.reset(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;
 
-  Browser* browser = GetCurrentBrowser();
-  if (!browser || !browser->window()) {
-    error_ = keys::kNoCurrentWindowError;
+  ExtensionWindowController* controller;
+  if (!GetWindowFromWindowID(this,
+                             extension_misc::kCurrentWindowId,
+                             &controller)) {
     return false;
   }
-  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, populate_tabs));
+  if (populate_tabs)
+    result_.reset(controller->CreateWindowValueWithTabs());
+  else
+    result_.reset(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.
   Browser* browser = BrowserList::FindAnyBrowser(
       profile(), include_incognito());
   if (!browser || !browser->window()) {
     error_ = keys::kNoLastFocusedWindowError;
     return false;
   }
-  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, populate_tabs));
+  ExtensionWindowController* controller =
+      browser->extension_window_controller();
+  if (populate_tabs)
+    result_.reset(controller->CreateWindowValueWithTabs());
+  else
+    result_.reset(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;
 
-  result_.reset(new ListValue());
-  Profile* incognito_profile =
-      include_incognito() && profile()->HasOffTheRecordProfile() ?
-          profile()->GetOffTheRecordProfile() : NULL;
-  for (BrowserList::const_iterator browser = BrowserList::begin();
-    browser != BrowserList::end(); ++browser) {
-      // Only examine browsers in the current profile that have windows.
-      if (((*browser)->profile() == profile() ||
-           (*browser)->profile() == incognito_profile) &&
-          (*browser)->window()) {
-        static_cast<ListValue*>(result_.get())->
-          Append(ExtensionTabUtil::CreateWindowValue(*browser, populate_tabs));
-      }
+  ListValue* window_list = new ListValue();
+  const ExtensionWindowList::WindowList& windows =
+      ExtensionWindowList::GetInstance()->windows();
+  for (ExtensionWindowList::WindowList::const_iterator iter =
+           windows.begin();
+       iter != windows.end(); ++iter) {
+    if (!(*iter)->MatchesProfile(
+            profile(), ProfileMatchType(include_incognito())))
+      continue;
+    if (populate_tabs)
+      window_list->Append((*iter)->CreateWindowValueWithTabs());
+    else
+      window_list->Append((*iter)->CreateWindowValue());
   }
-
+  result_.reset(window_list);
   return true;
 }
 
 bool CreateWindowFunction::ShouldOpenIncognitoWindow(
     const base::DictionaryValue* args,
     std::vector<GURL>* urls,
     bool* is_error) {
   *is_error = false;
   const IncognitoModePrefs::Availability incognito_availability =
       IncognitoModePrefs::GetAvailability(profile_->GetPrefs());
@@ skipping 213 matching lines @@
         else
           window_type = Browser::TYPE_POPUP;
       } else if (type_str != keys::kWindowTypeValueNormal) {
         error_ = keys::kInvalidWindowTypeError;
         return false;
       }
     }
   }
 
 #if defined(USE_AURA)
-  // Aura Panels create a new PanelDOMView.
+  // Aura Panels create a new PanelViewAura.
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           ash::switches::kAuraPanelManager) &&
       window_type == Browser::TYPE_PANEL) {
     // Note: Panels ignore all but the first url provided.
     std::string title =
         web_app::GenerateApplicationNameFromExtensionId(extension_id);
     PanelViewAura* panel_view = new PanelViewAura(title);
     panel_view->Init(window_profile, urls[0], panel_bounds);
-    // TODO(stevenjb): Provide an interface enable handles for any view, not
-    // just browsers. See crbug.com/113412.
-    result_.reset(Value::CreateNullValue());
+    result_.reset(
+        panel_view->extension_window_controller()->CreateWindowValueWithTabs());
     return true;
   }
 #endif
 
   // Create a new BrowserWindow.
   Browser* new_window;
   if (extension_id.empty()) {
     new_window = Browser::CreateForType(window_type, window_profile);
     new_window->window()->SetBounds(window_bounds);
   } else {
@@ skipping 20 matching lines @@
 
   if (focused)
     new_window->window()->Show();
   else
     new_window->window()->ShowInactive();
 
   if (new_window->profile()->IsOffTheRecord() && !include_incognito()) {
     // Don't expose incognito windows if the extension isn't allowed.
     result_.reset(Value::CreateNullValue());
   } else {
-    result_.reset(ExtensionTabUtil::CreateWindowValue(new_window, true));
+    result_.reset(
+        new_window->extension_window_controller()->CreateWindowValueWithTabs());
   }
 
   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));
 
-  Browser* browser = NULL;
-  if (!GetBrowserFromWindowID(this, window_id, &browser))
+  ExtensionWindowController* 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;
     } else if (state_str == keys::kShowStateValueMinimized) {
       show_state = ui::SHOW_STATE_MINIMIZED;
     } else if (state_str == keys::kShowStateValueMaximized) {
       show_state = ui::SHOW_STATE_MAXIMIZED;
     } else if (state_str == keys::kShowStateValueFullscreen) {
       show_state = ui::SHOW_STATE_FULLSCREEN;
     } else {
       error_ = keys::kInvalidWindowStateError;
       return false;
     }
   }
 
-  if (browser->window()->IsFullscreen() &&
-      show_state != ui::SHOW_STATE_FULLSCREEN &&
+  if (show_state != ui::SHOW_STATE_FULLSCREEN &&
       show_state != ui::SHOW_STATE_DEFAULT)
-    browser->ToggleFullscreenModeWithExtension(*GetExtension());
+    controller->SetFullscreenMode(false, GetExtension()->url());
 
   switch (show_state) {
     case ui::SHOW_STATE_MINIMIZED:
-      browser->window()->Minimize();
+      controller->window()->Minimize();
       break;
     case ui::SHOW_STATE_MAXIMIZED:
-      browser->window()->Maximize();
+      controller->window()->Maximize();
       break;
     case ui::SHOW_STATE_FULLSCREEN:
-      if (browser->window()->IsMinimized() || browser->window()->IsMaximized())
-        browser->window()->Restore();
-      if (!browser->window()->IsFullscreen())
-        browser->ToggleFullscreenModeWithExtension(*GetExtension());
+      if (controller->window()->IsMinimized() ||
+          controller->window()->IsMaximized())
+        controller->window()->Restore();
+      controller->SetFullscreenMode(true, GetExtension()->url());
       break;
     case ui::SHOW_STATE_NORMAL:
-      browser->window()->Restore();
+      controller->window()->Restore();
       break;
     default:
       break;
   }
 
-  gfx::Rect bounds = browser->window()->GetRestoredBounds();
+  gfx::Rect bounds;
+  if (controller->window()->IsMinimized())
+    bounds = controller->window()->GetRestoredBounds();
+  else
+    bounds = controller->window()->GetBounds();
   bool set_bounds = false;
 
   // Any part of the bounds can optionally be set by the caller.
   int bounds_val;
   if (update_props->HasKey(keys::kLeftKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetInteger(
         keys::kLeftKey,
         &bounds_val));
     bounds.set_x(bounds_val);
     set_bounds = true;
@@ skipping 23 matching lines @@
     set_bounds = true;
   }
 
   if (set_bounds) {
     if (show_state == ui::SHOW_STATE_MINIMIZED ||
         show_state == ui::SHOW_STATE_MAXIMIZED ||
         show_state == ui::SHOW_STATE_FULLSCREEN) {
       error_ = keys::kInvalidWindowStateError;
       return false;
     }
-    browser->window()->SetBounds(bounds);
+    controller->window()->SetBounds(bounds);
   }
 
   bool active_val = false;
   if (update_props->HasKey(keys::kFocusedKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kFocusedKey, &active_val));
     if (active_val) {
       if (show_state == ui::SHOW_STATE_MINIMIZED) {
         error_ = keys::kInvalidWindowStateError;
         return false;
       }
-      browser->window()->Activate();
+      controller->window()->Activate();
     } else {
       if (show_state == ui::SHOW_STATE_MAXIMIZED ||
           show_state == ui::SHOW_STATE_FULLSCREEN) {
         error_ = keys::kInvalidWindowStateError;
         return false;
       }
-      browser->window()->Deactivate();
+      controller->window()->Deactivate();
     }
   }
 
   bool draw_attention = false;
   if (update_props->HasKey(keys::kDrawAttentionKey)) {
     EXTENSION_FUNCTION_VALIDATE(update_props->GetBoolean(
         keys::kDrawAttentionKey, &draw_attention));
-    browser->window()->FlashFrame(draw_attention);
+    controller->window()->FlashFrame(draw_attention);
   }
 
-  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, false));
+  result_.reset(controller->CreateWindowValue());
 
   return true;
 }
 
 bool RemoveWindowFunction::RunImpl() {
   int window_id = -1;
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &window_id));
 
-  Browser* browser = GetBrowserInProfileWithId(profile(), window_id,
-                                               include_incognito(), &error_);
-  if (!browser)
+  ExtensionWindowController* controller;
+  if (!GetWindowFromWindowID(this, window_id, &controller))
     return false;
 
-  // Don't let the extension remove the window if the user is dragging tabs
-  // in that window.
-  if (!browser->IsTabStripEditable()) {
-    error_ = keys::kTabStripNotEditableError;
+  ExtensionWindowController::Reason reason;
+  if (!controller->CanClose(&reason)) {
+    if (reason == ExtensionWindowController::REASON_TAB_STRIP_NOT_EDITABLE)
+      error_ = keys::kTabStripNotEditableError;
     return false;
   }
-
-  browser->CloseWindow();
-
+  controller->window()->Close();
   return true;
 }
 
 // Tabs ------------------------------------------------------------------------
 
 bool GetSelectedTabFunction::RunImpl() {
   // windowId defaults to "current" window.
   int window_id = extension_misc::kCurrentWindowId;
 
   if (HasOptionalArgument(0))
@@ skipping 334 matching lines @@
   }
 
   // Make sure they actually specified tabs to select.
   if (selection.empty()) {
     error_ = keys::kNoHighlightedTabError;
     return false;
   }
 
   selection.set_active(active_index);
   browser->tabstrip_model()->SetSelectionFromModel(selection);
-  result_.reset(ExtensionTabUtil::CreateWindowValue(browser, true));
+  result_.reset(
+      browser->extension_window_controller()->CreateWindowValueWithTabs());
   return true;
 }
 
 UpdateTabFunction::UpdateTabFunction() : web_contents_(NULL) {
 }
 
 bool UpdateTabFunction::RunImpl() {
   DictionaryValue* update_props = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetDictionary(1, &update_props));
 
@@ skipping 637 matching lines @@
   // called for every API call the extension made.
   GotLanguage(language);
 }
 
 void DetectTabLanguageFunction::GotLanguage(const std::string& language) {
   result_.reset(Value::CreateStringValue(language.c_str()));
   SendResponse(true);
 
   Release();  // Balanced in Run()
 }