Support detaching/attaching panels via inter-strip drags.

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/auto_reset.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 51 matching lines @@
 }
 
 PanelManager::PanelManager()
     : panel_mouse_watcher_(PanelMouseWatcher::Create()),
       auto_sizing_enabled_(true),
       is_full_screen_(false),
       is_processing_overflow_(false) {
   detached_strip_.reset(new DetachedPanelStrip(this));
   docked_strip_.reset(new DockedPanelStrip(this));
   overflow_strip_.reset(new OverflowPanelStrip(this));
-  drag_controller_.reset(new PanelDragController());
+  drag_controller_.reset(new PanelDragController(this));
   display_settings_provider_.reset(DisplaySettingsProvider::Create(this));
 
   OnDisplayChanged();
 }
 
 PanelManager::~PanelManager() {
 }
 
 void PanelManager::OnDisplayChanged() {
   gfx::Rect work_area = display_settings_provider_->GetWorkArea();
@@ skipping 23 matching lines @@
 
 Panel* PanelManager::CreatePanel(Browser* browser) {
   // Need to sync the display area if no panel is present. This is because we
   // could only get display area notifications through a panel window.
   if (num_panels() == 0)
     OnDisplayChanged();
 
   int width = browser->override_bounds().width();
   int height = browser->override_bounds().height();
   Panel* panel = new Panel(browser, gfx::Size(width, height));
-  docked_strip_->AddPanel(panel);
+  docked_strip_->AddPanel(panel, PanelStrip::DEFAULT_POSITION);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_ADDED,
       content::Source<Panel>(panel),
       content::NotificationService::NoDetails());
 
   if (num_panels() == 1) {
     full_screen_mode_timer_.Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(kFullScreenModeCheckIntervalMs),
         this, &PanelManager::CheckFullScreenMode);
@@ skipping 49 matching lines @@
                                        const gfx::Size& preferred_window_size) {
   DCHECK(auto_sizing_enabled_);
   docked_strip_->ResizePanelWindow(panel, preferred_window_size);
 }
 
 void PanelManager::ResizePanel(Panel* panel, const gfx::Size& new_size) {
   docked_strip_->ResizePanelWindow(panel, new_size);
   panel->SetAutoResizable(false);
 }
 
-void PanelManager::MovePanelToStrip(Panel* panel,
-                                    PanelStrip::Type new_layout) {
+void PanelManager::MovePanelToStrip(
+    Panel* panel,
+    PanelStrip::Type new_layout,
+    PanelStrip::PositioningMask positioning_mask) {
   DCHECK(panel);
   PanelStrip* current_strip = panel->panel_strip();
   DCHECK(current_strip);
   DCHECK_NE(current_strip->type(), new_layout);
   current_strip->RemovePanel(panel);
 
   PanelStrip* target_strip = NULL;
   switch (new_layout) {
     case PanelStrip::DETACHED:
       target_strip = detached_strip_.get();
       break;
     case PanelStrip::DOCKED:
       target_strip = docked_strip_.get();
       break;
     case PanelStrip::IN_OVERFLOW:
       target_strip = overflow_strip_.get();
       break;
     default:
       NOTREACHED();
   }
 
-  target_strip->AddPanel(panel);
+  target_strip->AddPanel(panel, positioning_mask);
 
   content::NotificationService::current()->Notify(
       chrome::NOTIFICATION_PANEL_CHANGED_LAYOUT_MODE,
       content::Source<Panel>(panel),
       content::NotificationService::NoDetails());
 }
 
 void PanelManager::MovePanelsToOverflow(Panel* last_panel_to_move) {
   AutoReset<bool> processing_overflow(&is_processing_overflow_, true);
   // Move panels to overflow in reverse to maintain their order.
   Panel* bumped_panel;
   while ((bumped_panel = docked_strip_->last_panel())) {
-    MovePanelToStrip(bumped_panel, PanelStrip::IN_OVERFLOW);
+    MovePanelToStrip(bumped_panel,
+                     PanelStrip::IN_OVERFLOW,
+                     PanelStrip::DEFAULT_POSITION);
     if (bumped_panel == last_panel_to_move)
       break;
   }
   DCHECK(!docked_strip_->panels().empty());
 }
 
 void PanelManager::MovePanelsOutOfOverflowIfCanFit() {
   if (is_processing_overflow_)
     return;
 
   Panel* overflow_panel;
   while ((overflow_panel = overflow_strip_->first_panel()) &&
-         docked_strip_->CanFitPanel(overflow_panel))
-    MovePanelToStrip(overflow_panel, PanelStrip::DOCKED);
+         docked_strip_->CanFitPanel(overflow_panel)) {
+    MovePanelToStrip(overflow_panel,
+                     PanelStrip::DOCKED,
+                     PanelStrip::DEFAULT_POSITION);
+  }
 }
 
 bool PanelManager::ShouldBringUpTitlebars(int mouse_x, int mouse_y) const {
   return docked_strip_->ShouldBringUpTitlebars(mouse_x, mouse_y);
 }
 
 void PanelManager::BringUpOrDownTitlebars(bool bring_up) {
   docked_strip_->BringUpOrDownTitlebars(bring_up);
 }
 
@@ skipping 72 matching lines @@
   return panels;
 }
 
 int PanelManager::overflow_strip_width() const {
   return kOverflowStripThickness;
 }
 
 void PanelManager::SetMouseWatcher(PanelMouseWatcher* watcher) {
   panel_mouse_watcher_.reset(watcher);
 }