Changes to make snapshots be in a portrait orientation.

chrome/browser/chromeos/wm_overview_controller.cc

 // Copyright (c) 2010 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/chromeos/wm_overview_controller.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "base/linked_ptr.h"
@@ skipping 29 matching lines @@
 // remove it and just use the configure timer.  The reason I'm not
 // doing that is that I have a hunch that we'll be needing to tune
 // things further, and this will be one of the knobs.
 static const int kDelayTimeMs = 10;
 
 // The time between setting snapshots during the configuration pass,
 // so that the CPU has a chance to do something else (to keep overview
 // mode responsive).
 static const int kConfigureTimeMs = 10;
 
+// This is the size of the web page when we lay it out for a snapshot.
+static const int kSnapshotWebPageWidth = 1024;
+static const int kSnapshotWebPageHeight = 1280;
+static const double kSnapshotWebPageRatio =
+    static_cast<double>(kSnapshotWebPageWidth) / kSnapshotWebPageHeight;
+
+// This is the maximum percentage of the original browser client area
+// that a snapshot can take up.
+static const double kSnapshotMaxSizeRatio = 0.77;
+
 class BrowserListener : public TabStripModelObserver {
  public:
   BrowserListener(Browser* browser, WmOverviewController* parent);
   ~BrowserListener();
 
   // Begin TabStripModelObserver methods
   virtual void TabInsertedAt(TabContents* contents,
                              int index,
                              bool foreground);
   virtual void TabClosingAt(TabContents* contents, int index) {}
@@ skipping 43 matching lines @@
   void SelectTab(int index, uint32 timestamp);
 
   // Shows any snapshots that are not visible.
   void ShowSnapshots();
 
   // Returns the tab contents from the tab model for this child at index.
   TabContents* GetTabContentsAt(int index) const  {
     return browser_->tabstrip_model()->GetTabContentsAt(index);
   }
  private:
+  // Calculate the size of a cell based on the browser window's size.
+  gfx::Size CalculateCellSize();
 
   // Configures a cell from the tab contents.
   void ConfigureCell(WmOverviewSnapshot* cell, TabContents* contents);
 
   // Configures a cell from the model.
   void ConfigureCell(WmOverviewSnapshot* cell, int index) {
     ConfigureCell(cell, GetTabContentsAt(index));
   }
 
   // Inserts a new snapshot, initialized from the model, at the given
@@ skipping 68 matching lines @@
                                int from_index,
                                int to_index) {
   // Need to reorder tab in the snapshots list, and reset the window
   // type atom on the affected snapshots (the one moved, and all the
   // ones after it), so that their indices are correct.
   WmOverviewSnapshot* snapshot = snapshots_[from_index];
   snapshots_.erase(snapshots_.begin() + from_index);
   snapshots_.insert(snapshots_.begin() + to_index, snapshot);
 
   RenumberSnapshots(std::min(to_index, from_index));
+  UpdateSelectedIndex(browser_->selected_index());
 }
 
 void BrowserListener::TabChangedAt(
     TabContents* contents,
     int index,
     TabStripModelObserver::TabChangeType change_type) {
   if (change_type != TabStripModelObserver::LOADING_ONLY &&
       change_type != TabStripModelObserver::TITLE_NOT_LOADING) {
     ReloadSnapshot(index);
   }
@@ skipping 49 matching lines @@
       ConfigureCell(cell, i);
       return true;
     }
   }
   return false;
 }
 
 void BrowserListener::RestoreOriginalSelectedTab() {
   if (original_selected_tab_ >= 0) {
     browser_->SelectTabContentsAt(original_selected_tab_, false);
+    UpdateSelectedIndex(browser_->selected_index());
   }
 }
 
 void BrowserListener::ShowSnapshots() {
   for (SnapshotVector::size_type i = 0; i < snapshots_.size(); ++i) {
     WmOverviewSnapshot* snapshot = snapshots_[i];
     if (!snapshot->IsVisible())
       snapshot->Show();
   }
 }
 
 void BrowserListener::SelectTab(int index, uint32 timestamp) {
   uint32 old_value = select_tab_timestamp_;
   select_tab_timestamp_ = timestamp;
   browser_->SelectTabContentsAt(index, true);
   select_tab_timestamp_ = old_value;
 }
 
+gfx::Size BrowserListener::CalculateCellSize() {
+  // Make the page size and the cell size a fixed size for overview
+  // mode.  The cell size is calculated based on the desired maximum
+  // size on the screen, so it's related to the width and height of
+  // the browser client area.  In this way, when this snapshot gets
+  // to the window manager, it will already have the correct size,
+  // and will be scaled by 1.0, meaning that it won't be resampled
+  // and will not be blurry.
+  gfx::Rect bounds = static_cast<BrowserView*>(browser_->window())->
+                     GetClientAreaBounds();
+  const gfx::Size max_size = gfx::Size(
+      bounds.width() * kSnapshotMaxSizeRatio,
+      bounds.height() * kSnapshotMaxSizeRatio)
+  const double max_size_ratio = static_cast<double>(max_size.width()) /
+                                max_size.height();
+  gfx::Size cell_size;
+  if (kSnapshotWebPageRatio > max_size_ratio) {
+    const double scale_factor =
+        static_cast<double>(max_size.width())/ kSnapshotWebPageWidth;
+    cell_size = gfx::Size(max_size.width(),
+                          kSnapshotWebPageHeight * scale_factor + 0.5);
+  } else {
+    const double scale_factor =
+        static_cast<double>(max_size.height())/ kSnapshotWebPageHeight;
+    cell_size = gfx::Size(kSnapshotWebPageWidth * scale_factor + 0.5,
+                          max_size.height());
+  }
+  return cell_size;
+}
+
 void BrowserListener::ConfigureCell(WmOverviewSnapshot* cell,
                                     TabContents* contents) {
   if (contents) {
     ThumbnailGenerator* generator =
         g_browser_process->GetThumbnailGenerator();
     // TODO: Make sure that if the cell gets deleted before the
     // callback is called that it sticks around until it gets
     // called.  (some kind of "in flight" list that uses linked_ptr
     // to make sure they don't actually get deleted?)  Also, make
     // sure that any request for a thumbnail eventually returns
     // (even if it has bogus data), so we don't leak orphaned cells,
     // which could happen if a tab is closed while it is being
     // rendered.
     ThumbnailGenerator::ThumbnailReadyCallback* callback =
         NewCallback(cell, &WmOverviewSnapshot::SetImage);
-    gfx::Size cell_size = cell->size();
 
-    // Ask for the page size to be twice the requested size of the
-    // snapshot.
     generator->AskForSnapshot(contents->render_view_host(),
                               false,
                               callback,
-                              gfx::Size(cell_size.width() * 2,
-                                        cell_size.height() * 2),
-                              cell_size);
+                              gfx::Size(kSnapshotWebPageWidth,
+                                        kSnapshotWebPageHeight),
+                              CalculateCellSize());
   } else {
     // This happens because the contents haven't been loaded yet.
 
     // Make sure we set the snapshot image to something, otherwise
     // configured_snapshot remains false and
     // ConfigureNextUnconfiguredSnapshot would get stuck.
     cell->SetImage(SkBitmap());
   }
 }
 
 void BrowserListener::InsertSnapshot(int index) {
   WmOverviewSnapshot* snapshot = new WmOverviewSnapshot;
-  gfx::Rect bounds =
-      static_cast<BrowserView*>(browser_->window())->GetClientAreaBounds();
-  gfx::Size size(bounds.width() / 2, bounds.height() / 2);
-  snapshot->Init(size, browser_, index);
+  snapshot->Init(CalculateCellSize(), browser_, index);
   snapshots_.insert(snapshots_.begin() + index, snapshot);
   snapshot->reload_snapshot();
   controller_->StartDelayTimer();
 }
 
 // Removes the snapshot at index.
 void BrowserListener::ClearSnapshot(int index) {
   snapshots_[index]->CloseNow();
   snapshots_.erase(snapshots_.begin() + index);
 }
@@ skipping 57 matching lines @@
     // sufficient to know when the first tab of a new browser has its
     // dimensions set.  The implementation of AddAllBrowsers avoids
     // doing anything to already-existing browsers, so it's not a huge
     // problem, but still, it would be nice if there were a more
     // appropriate (browser-level) notification.
     case NotificationType::TAB_CONTENTS_CONNECTED:
       AddAllBrowsers();
       break;
 
     case NotificationType::THUMBNAIL_GENERATOR_SNAPSHOT_CHANGED: {
-      // Don't do any dynamic updating if we're not in overview mode.
-      if (layout_mode_ == OVERVIEW_MODE) {
-        RenderWidgetHost* renderer = Details<RenderViewHost>(details).ptr();
-        SnapshotImageChanged(renderer);
-      }
+      // It's OK to do this in active mode too -- nothing will happen
+      // except invalidation of the snapshot, because the delay timer
+      // won't start until we're in overview mode.
+      RenderWidgetHost* renderer = Details<RenderViewHost>(details).ptr();
+      SnapshotImageChanged(renderer);
       break;
     }
     default:
       // Do nothing.
       break;
   }
 }
 
 void WmOverviewController::SnapshotImageChanged(RenderWidgetHost* renderer) {
   // Find out which TabContents this renderer is attached to, and then
@@ skipping 169 matching lines @@
     if (item.get() == NULL) {
       item = BrowserListenerVector::value_type(
           new BrowserListener(*iterator, this));
     }
     listeners_.push_back(item);
     ++iterator;
   }
 }
 
 }  // namespace chromeos