Remove implementation of Panels on OSes other than ChromeOS.

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 <stddef.h>
 #include <algorithm>
 #include <limits>
 #include <memory>
@@ skipping 30 matching lines @@
 #include "chrome/browser/sessions/session_tab_helper.h"
 #include "chrome/browser/translate/chrome_translate_client.h"
 #include "chrome/browser/ui/apps/chrome_app_delegate.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_navigator_params.h"
 #include "chrome/browser/ui/browser_window.h"
-#include "chrome/browser/ui/panels/panel_manager.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
 #include "chrome/browser/ui/window_sizer/window_sizer.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/tabs.h"
 #include "chrome/common/extensions/api/windows.h"
 #include "chrome/common/extensions/extension_constants.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
@@ skipping 192 matching lines @@
              !is_panel;
     case windows::WINDOW_STATE_NORMAL:
     case windows::WINDOW_STATE_DOCKED:
     case windows::WINDOW_STATE_NONE:
       return true;
   }
   NOTREACHED();
   return true;
 }
 
+bool IsHangoutsExtensionId(const std::string& extension_id) {
+  for (const char* id : extension_misc::kHangoutsExtensionIds) {
+    if (extension_id == id)
+      return true;
+  }
+  return false;
+}
+
 }  // namespace
 
 void ZoomModeToZoomSettings(ZoomController::ZoomMode zoom_mode,
                             api::tabs::ZoomSettings* zoom_settings) {
   DCHECK(zoom_settings);
   switch (zoom_mode) {
     case ZoomController::ZOOM_MODE_DEFAULT:
       zoom_settings->mode = api::tabs::ZOOM_SETTINGS_MODE_AUTOMATIC;
       zoom_settings->scope = api::tabs::ZOOM_SETTINGS_SCOPE_PER_ORIGIN;
       break;
@@ skipping 225 matching lines @@
       return false;
     }
   }
 
   if (!IsValidStateForWindowsCreateFunction(create_data)) {
     error_ = keys::kInvalidWindowStateError;
     return false;
   }
 
   Browser::Type window_type = Browser::TYPE_TABBED;
-  bool create_panel = false;
 
-  // panel_create_mode only applies if create_panel = true
-  PanelManager::CreateMode panel_create_mode = PanelManager::CREATE_AS_DOCKED;
+#if defined(USE_ASH)
+  bool create_ash_panel = false;
+#endif  // defined(USE_ASH)
 
   gfx::Rect window_bounds;
   bool focused = true;
   bool saw_focus_key = false;
   std::string extension_id;
 
   if (create_data) {
     // Figure out window type before figuring out bounds so that default
     // bounds can be set according to the window type.
     switch (create_data->type) {
       case windows::CREATE_TYPE_POPUP:
         window_type = Browser::TYPE_POPUP;
         extension_id = extension()->id();
         break;
+
       case windows::CREATE_TYPE_PANEL:
       case windows::CREATE_TYPE_DETACHED_PANEL: {
         extension_id = extension()->id();
-        bool use_panels = PanelManager::ShouldUsePanels(extension_id);
-        if (use_panels) {
-          create_panel = true;
-#if !defined(USE_ASH)
-          // Non-ash supports both docked and detached panel types.
-          if (create_data->type == windows::CREATE_TYPE_DETACHED_PANEL) {
-            panel_create_mode = PanelManager::CREATE_AS_DETACHED;
-          }
-#endif  // USE_ASH
-        } else {
-          window_type = Browser::TYPE_POPUP;
+#if defined(USE_ASH)
+      // Only ChromeOS' version of chrome.windows.create would create a panel
+      // window. It is whitelisted to Hangouts extension for limited time until
+      // it transitioned to other types of windows.
+        if (IsHangoutsExtensionId(extension_id)) {
+          create_ash_panel = true;
+          break;
         }
+#endif  // defined(USE_ASH)
+        // Everything else gets POPUP instead of PANEL.
+        // TODO(dimich): Eventually, remove the 'panel' values form valid
+        // window.create parameters. However, this is a more breaking change, so
+        // for now simply treat it as a POPUP.
+        window_type = Browser::TYPE_POPUP;
         break;
       }
+
       case windows::CREATE_TYPE_NONE:
       case windows::CREATE_TYPE_NORMAL:
         break;
       default:
         error_ = keys::kInvalidWindowTypeError;
         return false;
     }
 
     // Initialize default window bounds according to window type.
     if (window_type == Browser::TYPE_TABBED ||
-        window_type == Browser::TYPE_POPUP ||
-        create_panel) {
+        window_type == Browser::TYPE_POPUP) {
       // 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 (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.
     if (create_data->left)
       window_bounds.set_x(*create_data->left);
 
     if (create_data->top)
       window_bounds.set_y(*create_data->top);
 
     if (create_data->width)
       window_bounds.set_width(*create_data->width);
 
     if (create_data->height)
       window_bounds.set_height(*create_data->height);
 
     if (create_data->focused) {
       focused = *create_data->focused;
       saw_focus_key = true;
     }
   }
 
-  if (create_panel) {
+#if defined(USE_ASH)
+  if (create_ash_panel) {
     if (urls.empty())
       urls.push_back(GURL(chrome::kChromeUINewTabURL));
 
-#if defined(USE_ASH)
     AppWindow::CreateParams create_params;
     create_params.window_type = AppWindow::WINDOW_TYPE_V1_PANEL;
     create_params.window_key = extension_id;
     create_params.window_spec.bounds = window_bounds;
     create_params.focused = saw_focus_key && focused;
     AppWindow* app_window =
         new AppWindow(window_profile, new ChromeAppDelegate(true), extension());
     AshPanelContents* ash_panel_contents = new AshPanelContents(app_window);
     app_window->Init(urls[0], ash_panel_contents, render_frame_host(),
                      create_params);
     WindowController* window_controller =
         WindowControllerList::GetInstance()->FindWindowById(
             app_window->session_id().id());
     if (!window_controller)
       return false;
     SetResult(window_controller->CreateWindowValueWithTabs(extension()));
     return true;
-#else
-    std::string title =
-        web_app::GenerateApplicationNameFromExtensionId(extension_id);
-    content::SiteInstance* source_site_instance =
-        render_frame_host()->GetSiteInstance();
-    // Note: Panels ignore all but the first url provided.
-    Panel* panel = PanelManager::GetInstance()->CreatePanel(
-        title, window_profile, urls[0], source_site_instance, window_bounds,
-        panel_create_mode);
-
-    // Unlike other window types, Panels do not take focus by default.
-    if (!saw_focus_key || !focused)
-      panel->ShowInactive();
-    else
-      panel->Show();
-
-    SetResult(panel->extension_window_controller()->CreateWindowValueWithTabs(
-        extension()));
-    return true;
-#endif
   }
+#endif  // defined(USE_ASH)
 
   // Create a new BrowserWindow.
-  if (create_panel)
-    window_type = Browser::TYPE_POPUP;
   Browser::CreateParams create_params(window_type, window_profile);
   if (extension_id.empty()) {
     create_params.initial_bounds = window_bounds;
   } else {
     create_params = Browser::CreateParams::CreateForApp(
         web_app::GenerateApplicationNameFromExtensionId(extension_id),
         false /* trusted_source */, window_bounds, window_profile);
   }
   create_params.initial_show_state = ui::SHOW_STATE_NORMAL;
   if (create_data && create_data->state) {
     create_params.initial_show_state =
         ConvertToWindowShowState(create_data->state);
   }
 
   Browser* new_window = new Browser(create_params);
 
   for (const GURL& url : urls) {
     chrome::NavigateParams navigate_params(new_window, url,
                                            ui::PAGE_TRANSITION_LINK);
     navigate_params.disposition = NEW_FOREGROUND_TAB;
     navigate_params.source_site_instance =
         render_frame_host()->GetSiteInstance();
     chrome::Navigate(&navigate_params);
-    if (create_panel) {
-      TabHelper::FromWebContents(navigate_params.target_contents)
-          ->SetExtensionAppIconById(extension_id);
-    }
   }
 
   WebContents* contents = NULL;
   // Move the tab into the created window only if it's an empty popup or it's
   // a tabbed window.
   if ((window_type == Browser::TYPE_POPUP && urls.empty()) ||
       window_type == Browser::TYPE_TABBED) {
     if (source_tab_strip)
       contents = source_tab_strip->DetachWebContentsAt(tab_index);
     if (contents) {
       TabStripModel* target_tab_strip = new_window->tab_strip_model();
       target_tab_strip->InsertWebContentsAt(urls.size(), contents,
                                             TabStripModel::ADD_NONE);
     }
   }
   // Create a new tab if the created window is still empty. Don't create a new
   // tab when it is intended to create an empty popup.
   if (!contents && urls.empty() && window_type != Browser::TYPE_POPUP) {
     chrome::NewTab(new_window);
   }
   chrome::SelectNumberedTab(new_window, 0);
 
-  // Unlike other window types, Panels do not take focus by default.
-  if (!saw_focus_key && create_panel)
-    focused = false;
-
   if (focused)
     new_window->window()->Show();
   else
     new_window->window()->ShowInactive();
 
   WindowController* controller = new_window->extension_window_controller();
 
   if (new_window->profile()->IsOffTheRecord() &&
       !GetProfile()->IsOffTheRecord() && !include_incognito()) {
     // Don't expose incognito windows if extension itself works in non-incognito
@@ skipping 1506 matching lines @@
       params->tab_id
           ? ErrorUtils::FormatErrorMessage(keys::kCannotDiscardTab,
                                            base::IntToString(*params->tab_id))
           : keys::kCannotFindTabToDiscard));
 }
 
 TabsDiscardFunction::TabsDiscardFunction() {}
 TabsDiscardFunction::~TabsDiscardFunction() {}
 
 }  // namespace extensions