Allow panels to be created as detached panels.

chrome/browser/ui/panels/panel_manager.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/ui/panels/panel_manager.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 111 matching lines @@
 
 PanelManager::~PanelManager() {
   display_settings_provider_->RemoveDisplayAreaObserver(this);
 
   // Docked strip should be disposed explicitly before DisplaySettingsProvider
   // is gone since docked strip needs to remove the observer from
   // DisplaySettingsProvider.
   docked_strip_.reset();
 }
 
+gfx::Point PanelManager::GetDefaultDetachedPanelOrigin() {
+  return detached_strip_->GetDefaultPanelOrigin();
+}
+
 void PanelManager::OnDisplayAreaChanged(const gfx::Rect& display_area) {
   if (display_area == display_area_)
     return;
   display_area_ = display_area;
 
   gfx::Rect docked_strip_bounds = display_area;
   docked_strip_bounds.set_x(display_area.x() + kPanelStripLeftMargin);
   docked_strip_bounds.set_width(display_area.width() -
                                 kPanelStripLeftMargin - kPanelStripRightMargin);
   docked_strip_->SetDisplayArea(docked_strip_bounds);
 
   detached_strip_->SetDisplayArea(display_area);
 }
 
 void PanelManager::OnFullScreenModeChanged(bool is_full_screen) {
   docked_strip_->OnFullScreenModeChanged(is_full_screen);
 }
 
 int PanelManager::GetMaxPanelWidth() const {
   return static_cast<int>(display_area_.width() * kPanelMaxWidthFactor);
 }
 
 int PanelManager::GetMaxPanelHeight() const {
   return display_area_.height() * kPanelMaxHeightFactor;
 }
 
 Panel* PanelManager::CreatePanel(Browser* browser) {
   return CreatePanel(browser, "", NULL, GURL(),
-                     browser->override_bounds().size());
+                     browser->override_bounds(), CREATE_AS_DOCKED);
 }
 
 Panel* PanelManager::CreatePanel(const std::string& app_name,
                                  Profile* profile,
                                  const GURL& url,
-                                 const gfx::Size& requested_size) {
-  return CreatePanel(NULL, app_name, profile, url, requested_size);
+                                 const gfx::Rect& requested_bounds,
+                                 CreateMode mode) {
+  return CreatePanel(NULL, app_name, profile, url, requested_bounds, mode);
 }
 
 Panel* PanelManager::CreatePanel(Browser* browser,
                                  const std::string& app_name,
                                  Profile* profile,
                                  const GURL& url,
-                                 const gfx::Size& requested_size) {
+                                 const gfx::Rect& requested_bounds,
+                                 CreateMode mode) {
   // Need to sync the display area if no panel is present. This is because:
   // 1) Display area is not initialized until first panel is created.
   // 2) On windows, display settings notification is tied to a window. When
   //    display settings are changed at the time that no panel exists, we do
   //    not receive any notification.
   if (num_panels() == 0) {
     display_settings_provider_->OnDisplaySettingsChanged();
     display_settings_provider_->AddFullScreenObserver(this);
   }
 
   // Compute initial bounds for the panel.
-  int width = requested_size.width();
-  int height = requested_size.height();
+  int width = requested_bounds.width();
+  int height = requested_bounds.height();
   if (width == 0)
     width = height * kPanelDefaultWidthToHeightRatio;
   else if (height == 0)
     height = width / kPanelDefaultWidthToHeightRatio;
 
   gfx::Size min_size(panel::kPanelMinWidth, panel::kPanelMinHeight);
   gfx::Size max_size(GetMaxPanelWidth(), GetMaxPanelHeight());
   if (width < min_size.width())
     width = min_size.width();
   else if (width > max_size.width())
     width = max_size.width();
 
   if (height < min_size.height())
     height = min_size.height();
   else if (height > max_size.height())
     height = max_size.height();
 
-  gfx::Size panel_size(width, height);
-  gfx::Rect bounds(docked_strip_->GetDefaultPositionForPanel(panel_size),
-                   panel_size);
+  gfx::Rect bounds(width, height);
+  if (CREATE_AS_DOCKED == mode) {
+    bounds.set_origin(docked_strip_->GetDefaultPositionForPanel(bounds.size()));
+  } else {
+    bounds.set_origin(requested_bounds.origin());
+    bounds = bounds.AdjustToFit(display_settings_provider_->GetDisplayArea());
+  }
 
   // Create the panel.
   Panel* panel;
   if (browser) {
     // Legacy panel. Delete after refactor.
     panel = new OldPanel(browser, min_size, max_size);
     panel->Initialize(bounds, browser);
   } else {
     panel = new Panel(app_name, min_size, max_size);
     panel->Initialize(profile, url, bounds);
   }
 
   // Auto resizable feature is enabled only if no initial size is requested.
-  if (auto_sizing_enabled() && requested_size.width() == 0 &&
-      requested_size.height() == 0) {
+  if (auto_sizing_enabled() && requested_bounds.width() == 0 &&
+      requested_bounds.height() == 0) {
     panel->SetAutoResizable(true);
   }
 
-  // Add the panel to the docked strip.
+  // Add the panel to the appropriate panel strip.
   // Delay layout refreshes in case multiple panels are created within
   // a short time of one another or the focus changes shortly after panel
   // is created to avoid excessive screen redraws.
-  docked_strip_->AddPanel(panel, PanelStrip::DELAY_LAYOUT_REFRESH);
-  docked_strip_->UpdatePanelOnStripChange(panel);
+  PanelStrip* panel_strip;
+  PanelStrip::PositioningMask positioning_mask;
+  if (CREATE_AS_DOCKED == mode) {
+    panel_strip = docked_strip_.get();
+    positioning_mask = PanelStrip::DELAY_LAYOUT_REFRESH;
+  } else {
+    panel_strip = detached_strip_.get();
+    positioning_mask = PanelStrip::KNOWN_POSITION;
+  }
+
+  panel_strip->AddPanel(panel, positioning_mask);
+  panel_strip->UpdatePanelOnStripChange(panel);
 
   return panel;
 }
 
 void PanelManager::OnPanelClosed(Panel* panel) {
   if (num_panels() == 1) {
     display_settings_provider_->RemoveFullScreenObserver(this);
   }
 
   drag_controller_->OnPanelClosed(panel);
@@ skipping 124 matching lines @@
 void PanelManager::SetMouseWatcher(PanelMouseWatcher* watcher) {
   panel_mouse_watcher_.reset(watcher);
 }
 
 void PanelManager::OnPanelAnimationEnded(Panel* panel) {
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_BOUNDS_ANIMATIONS_FINISHED,
       content::Source<Panel>(panel),
       content::NotificationService::NoDetails());
 }