Deprecate Browser::TYPE_PANEL

chrome/browser/extensions/api/tabs/tabs_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/tabs/tabs_api.h"
 
 #include <algorithm>
 #include <limits>
 #include <vector>
 
@@ skipping 464 matching lines @@
       if (!contents) {
         error_ = ErrorUtils::FormatErrorMessage(
             keys::kTabNotFoundError, base::IntToString(tab_id));
         return false;
       }
     }
   }
 
   Profile* window_profile = profile();
   Browser::Type window_type = Browser::TYPE_TABBED;
+  bool create_panel = false;
 
-  // panel_create_mode only applies if window is TYPE_PANEL.
+  // panel_create_mode only applies if create_panel = true
   PanelManager::CreateMode panel_create_mode = PanelManager::CREATE_AS_DOCKED;
 
   gfx::Rect window_bounds;
   bool focused = true;
   bool saw_focus_key = false;
   std::string extension_id;
 
   // Decide whether we are opening a normal window or an incognito window.
   bool is_error = true;
   bool open_incognito_window = ShouldOpenIncognitoWindow(args, &urls,
@@ skipping 17 matching lines @@
         window_type = Browser::TYPE_POPUP;
         extension_id = GetExtension()->id();
       } else if (type_str == keys::kWindowTypeValuePanel ||
                  type_str == keys::kWindowTypeValueDetachedPanel) {
         extension_id = GetExtension()->id();
         bool use_panels = false;
 #if !defined(OS_ANDROID)
         use_panels = PanelManager::ShouldUsePanels(extension_id);
 #endif
         if (use_panels) {
-          window_type = Browser::TYPE_PANEL;
+          create_panel = true;
 #if !defined(OS_CHROMEOS)
           // Non-ChromeOS has both docked and detached panel types.
           if (type_str == keys::kWindowTypeValueDetachedPanel)
             panel_create_mode = PanelManager::CREATE_AS_DETACHED;
 #endif
         } else {
           window_type = Browser::TYPE_POPUP;
         }
       } else if (type_str != keys::kWindowTypeValueNormal) {
         error_ = keys::kInvalidWindowTypeError;
         return false;
       }
     }
 
     // Initialize default window bounds according to window type.
-    if (Browser::TYPE_TABBED == window_type ||
-        Browser::TYPE_POPUP == window_type ||
-        Browser::TYPE_PANEL == window_type) {
+    if (window_type == Browser::TYPE_TABBED ||
+        window_type == Browser::TYPE_POPUP ||
+        create_panel) {
       // Try to position the new browser relative to its originating
       // browser window. The call offsets the bounds by kWindowTilePixels
       // (defined in WindowSizer to be 10).
       //
       // NOTE(rafaelw): It's ok if GetCurrentBrowser() returns NULL here.
       // GetBrowserWindowBounds will default to saved "default" values for
       // the app.
       ui::WindowShowState show_state = ui::SHOW_STATE_DEFAULT;
       WindowSizer::GetBrowserWindowBoundsAndShowState(std::string(),
                                                       gfx::Rect(),
                                                       GetCurrentBrowser(),
                                                       &window_bounds,
                                                       &show_state);
     }
 
-    if (Browser::TYPE_PANEL == window_type &&
-        PanelManager::CREATE_AS_DETACHED == panel_create_mode) {
+    if (create_panel && PanelManager::CREATE_AS_DETACHED == panel_create_mode) {
       window_bounds.set_origin(
           PanelManager::GetInstance()->GetDefaultDetachedPanelOrigin());
     }
 
     // Any part of the bounds can optionally be set by the caller.
     int bounds_val = -1;
     if (args->HasKey(keys::kLeftKey)) {
       EXTENSION_FUNCTION_VALIDATE(args->GetInteger(keys::kLeftKey,
                                                    &bounds_val));
       window_bounds.set_x(bounds_val);
@@ skipping 17 matching lines @@
       window_bounds.set_height(bounds_val);
     }
 
     if (args->HasKey(keys::kFocusedKey)) {
       EXTENSION_FUNCTION_VALIDATE(args->GetBoolean(keys::kFocusedKey,
                                                    &focused));
       saw_focus_key = true;
     }
   }
 
-  if (window_type == Browser::TYPE_PANEL) {
+  if (create_panel) {
     if (urls.empty())
       urls.push_back(GURL(chrome::kChromeUINewTabURL));
 
 #if defined(OS_CHROMEOS)
     if (PanelManager::ShouldUsePanels(extension_id)) {
       ShellWindow::CreateParams create_params;
       create_params.window_type = ShellWindow::WINDOW_TYPE_V1_PANEL;
       create_params.bounds = window_bounds;
       create_params.minimum_size = window_bounds.size();
       create_params.maximum_size = window_bounds.size();
@@ skipping 24 matching lines @@
 
     SetResult(
         panel->extension_window_controller()->CreateWindowValueWithTabs(
             GetExtension()));
     return true;
 #endif
   }
 
   // Create a new BrowserWindow.
   chrome::HostDesktopType host_desktop_type = chrome::GetActiveDesktop();
+  if (create_panel)
+    window_type = Browser::TYPE_POPUP;
   Browser::CreateParams create_params(window_type, window_profile,
                                       host_desktop_type);
   if (extension_id.empty()) {
     create_params.initial_bounds = window_bounds;
   } else {
     create_params = Browser::CreateParams::CreateForApp(
         window_type,
         web_app::GenerateApplicationNameFromExtensionId(extension_id),
         window_bounds,
         window_profile,
         host_desktop_type);
   }
   create_params.initial_show_state = ui::SHOW_STATE_NORMAL;
   create_params.host_desktop_type = chrome::GetActiveDesktop();
 
   Browser* new_window = CreateBrowserWindow(create_params, window_profile,
                                             extension_id);
 
   for (std::vector<GURL>::iterator i = urls.begin(); i != urls.end(); ++i) {
     WebContents* tab = chrome::AddSelectedTabWithURL(
         new_window, *i, content::PAGE_TRANSITION_LINK);
-    if (window_type == Browser::TYPE_PANEL) {
+    if (create_panel) {
       extensions::TabHelper::FromWebContents(tab)->
           SetExtensionAppIconById(extension_id);
     }
   }
   if (contents) {
     TabStripModel* target_tab_strip = new_window->tab_strip_model();
     target_tab_strip->InsertWebContentsAt(urls.size(), contents,
                                           TabStripModel::ADD_NONE);
   } else if (urls.empty()) {
     chrome::NewTab(new_window);
   }
   chrome::SelectNumberedTab(new_window, 0);
 
   // Unlike other window types, Panels do not take focus by default.
-  if (!saw_focus_key && window_type == Browser::TYPE_PANEL)
+  if (!saw_focus_key && create_panel)
     focused = false;
 
   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.
     SetResult(Value::CreateNullValue());
@@ skipping 1475 matching lines @@
           extension->id(),
           script_type,
           code_string,
           frame_scope,
           run_at,
           ScriptExecutor::ISOLATED_WORLD,
           false /* is_web_view */,
           base::Bind(&ExecuteCodeInTabFunction::OnExecuteCodeFinished, this));
   return true;
 }