Changes tab overview to create a window the max size it can possibly...

chrome/browser/views/tabs/tab_overview_controller.cc

 // Copyright (c) 2009 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/views/tabs/tab_overview_controller.h"
 
 #include "chrome/browser/browser.h"
 #include "chrome/browser/gtk/browser_window_gtk.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/views/tabs/tab_overview_cell.h"
 #include "chrome/browser/views/tabs/tab_overview_container.h"
 #include "chrome/browser/views/tabs/tab_overview_grid.h"
 #include "chrome/browser/views/tabs/tab_overview_types.h"
 #include "chrome/browser/window_sizer.h"
-#include "views/fill_layout.h"
 #include "views/widget/root_view.h"
 #include "views/widget/widget_gtk.h"
 
 // Horizontal padding from the edge of the monitor to the overview.
 static int kMonitorPadding = 20;
 // Vertical padding between the overview and the windows along on the bottom.
 static int kWindowToOverviewPadding = 25;
 // Height of the windows along the bottom, as a percentage of the monitors
 // height.
 static float kWindowHeight = .30;
 // Height of the tab overview, as a percentage of monitors height.
 static float kOverviewHeight = .55;
 
 TabOverviewController::TabOverviewController(
     const gfx::Point& monitor_origin)
     : host_(NULL),
       container_(NULL),
       grid_(NULL),
       browser_(NULL),
       drag_browser_(NULL),
       moved_offscreen_(false),
       shown_(false),
       horizontal_center_(0),
       change_window_bounds_on_animate_(false),
       mutating_grid_(false) {
   grid_ = new TabOverviewGrid(this);
 
+  // Determine the max size for the overview.
+  scoped_ptr<WindowSizer::MonitorInfoProvider> provider(
+      WindowSizer::CreateDefaultMonitorInfoProvider());
+  monitor_bounds_ = provider->GetMonitorWorkAreaMatching(
+      gfx::Rect(monitor_origin.x(), monitor_origin.y(), 1, 1));
+
   // Create the host.
   views::WidgetGtk* host = new views::WidgetGtk(views::WidgetGtk::TYPE_POPUP);
   host->set_delete_on_destroy(false);
   host->MakeTransparent();
-  host->Init(NULL, gfx::Rect(), true);
+  host->Init(NULL, CalculateHostBounds(), true);
   TabOverviewTypes::instance()->SetWindowType(
       host->GetNativeView(),
       TabOverviewTypes::WINDOW_TYPE_CHROME_TAB_SUMMARY,
       NULL);
   host_ = host;
 
   container_ = new TabOverviewContainer();
   container_->AddChildView(grid_);
-  host->GetRootView()->SetLayoutManager(new views::FillLayout());
   host->GetRootView()->AddChildView(container_);
 
-  // Determine the max size for the overview.
-  scoped_ptr<WindowSizer::MonitorInfoProvider> provider(
-      WindowSizer::CreateDefaultMonitorInfoProvider());
-  monitor_bounds_ = provider->GetMonitorWorkAreaMatching(
-      gfx::Rect(monitor_origin.x(), monitor_origin.y(), 1, 1));
-  monitor_bounds_.Inset(kMonitorPadding, 0);
-  int max_width = monitor_bounds_.width();
-  int max_height = static_cast<int>(monitor_bounds_.height() *
-                                    kOverviewHeight);
-  container_->SetMaxSize(gfx::Size(max_width, max_height));
+  container_->SetMaxSize(CalculateHostBounds().size());
 
   // TODO: remove this when we get mid point.
   horizontal_center_ = monitor_bounds_.x() + monitor_bounds_.width() / 2;
 }
 
 TabOverviewController::~TabOverviewController() {
   if (browser_)
     model()->RemoveObserver(this);
   host_->Close();
   // The drag controller may call back to us from it's destructor. Make sure
   // it's destroyed before us.
   grid()->CancelDrag();
 }
 
 void TabOverviewController::SetBrowser(Browser* browser,
                                        int horizontal_center) {
   // TODO: update this when we horizontal_center is correct.
   // horizontal_center_ = horizontal_center;
   if (browser_)
     model()->RemoveObserver(this);
   browser_ = browser;
   if (browser_)
     model()->AddObserver(this);
-  moved_offscreen_ = false;
+  if (moved_offscreen_ && model() && model()->count()) {
+    // Need to reset the bounds if we were offscreen.
+    host_->SetBounds(CalculateHostBounds());
+    moved_offscreen_ = false;
+  }
   RecreateCells();
 }
 
 TabStripModel* TabOverviewController::model() const {
   return browser_ ? browser_->tabstrip_model() : NULL;
 }
 
 void TabOverviewController::Show() {
   if (host_->IsVisible())
     return;
@@ skipping 38 matching lines @@
 }
 
 void TabOverviewController::SelectTabContents(TabContents* contents) {
   NOTIMPLEMENTED();
 }
 
 void TabOverviewController::GridAnimationEnded() {
   if (moved_offscreen_ || !change_window_bounds_on_animate_ || mutating_grid_)
     return;
 
-  SetHostBounds(target_bounds_);
+  container_->SetBounds(target_bounds_);
   grid_->UpdateDragController();
   change_window_bounds_on_animate_ = false;
 }
 
 void TabOverviewController::GridAnimationProgressed() {
   if (moved_offscreen_ || !change_window_bounds_on_animate_)
     return;
 
   DCHECK(!mutating_grid_);
 
-  SetHostBounds(grid_->AnimationPosition(start_bounds_, target_bounds_));
+  // Schedule a paint before and after changing sizes to deal with the case
+  // of the view shrinking in size.
+  container_->SchedulePaint();
+  container_->SetBounds(
+      grid_->AnimationPosition(start_bounds_, target_bounds_));
+  container_->SchedulePaint();
+
+  // Update the position of the dragged cell.
   grid_->UpdateDragController();
 }
 
 void TabOverviewController::GridAnimationCanceled() {
   change_window_bounds_on_animate_ = false;
 }
 
 void TabOverviewController::TabInsertedAt(TabContents* contents,
                                           int index,
                                           bool foreground) {
@@ skipping 62 matching lines @@
     for (int i = 0; i < model()->count(); ++i) {
       TabOverviewCell* child = new TabOverviewCell();
       ConfigureCell(child, i);
       grid_->AddChildView(child);
     }
   }
 
   if (moved_offscreen_)
     return;
 
-  SetHostBounds(CalculateHostBounds());
   if (grid()->GetChildViewCount() > 0) {
     if (shown_)
       host_->Show();
   } else {
     host_->Hide();
   }
+  container_->SetBounds(CalculateContainerBounds());
 }
 
 void TabOverviewController::UpdateStartAndTargetBounds() {
   if (moved_offscreen_ || !shown_)
     return;
 
   if (grid()->GetChildViewCount() == 0) {
     host_->Hide();
   } else {
-    host_->GetBounds(&start_bounds_, true);
-    target_bounds_ = CalculateHostBounds();
+    start_bounds_ = container_->bounds();
+    target_bounds_ = CalculateContainerBounds();
     change_window_bounds_on_animate_ = (start_bounds_ != target_bounds_);
   }
 }
 
-void TabOverviewController::SetHostBounds(const gfx::Rect& bounds) {
-  host_->SetBounds(bounds);
-  container_->UpdateWidgetShape(horizontal_center_, bounds.width(),
-                                bounds.height());
+gfx::Rect TabOverviewController::CalculateContainerBounds() {
+  gfx::Rect host_bounds = CalculateHostBounds();
+  const gfx::Size& host_size = CalculateHostBounds().size();
+  gfx::Size pref = container_->GetPreferredSize();
+  int relative_horizontal_center = horizontal_center_ - host_bounds.x();
+  int x = relative_horizontal_center - pref.width() / 2;
+  int y = host_size.height() - pref.height();
+  return gfx::Rect(x, y, pref.width(), pref.height()).
+      AdjustToFit(gfx::Rect(0, 0, host_size.width(), host_size.height()));
 }
 
 gfx::Rect TabOverviewController::CalculateHostBounds() {
-  gfx::Size pref = container_->GetPreferredSize();
-  int x = horizontal_center_ - pref.width() / 2;
-  int y = monitor_bounds_.bottom() -
-      static_cast<int>(monitor_bounds_.height() * kWindowHeight) -
-      kWindowToOverviewPadding - pref.height();
-  return gfx::Rect(x, y, pref.width(), pref.height()).
-      AdjustToFit(monitor_bounds_);
+  int max_width = monitor_bounds_.width() - kMonitorPadding * 2;
+  int window_height = monitor_bounds_.height() * kWindowHeight;
+  int max_height = static_cast<int>(monitor_bounds_.height() *
+                                    kOverviewHeight);
+  return gfx::Rect(monitor_bounds_.x() + kMonitorPadding,
+                   monitor_bounds_.bottom() - window_height -
+                   kWindowToOverviewPadding - max_height, max_width,
+                   max_height);
 }