cros: Instant extended support for immersive fullscreen

chrome/browser/ui/views/frame/browser_view_layout.cc

 // Copyright 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/views/frame/browser_view_layout.h"
 
 #include "base/observer_list.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/find_bar/find_bar.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
 #include "chrome/browser/ui/views/toolbar_view.h"
 #include "chrome/browser/ui/web_contents_modal_dialog_host.h"
 #include "ui/base/hit_test.h"
 #include "ui/gfx/point.h"
 #include "ui/gfx/scrollbar_size.h"
 #include "ui/gfx/size.h"
 #include "ui/views/controls/single_split_view.h"
 #include "ui/views/controls/webview/webview.h"
 
+using views::View;
+
 namespace {
 
 // The visible height of the shadow above the tabs. Clicks in this area are
 // treated as clicks to the frame, rather than clicks to the tab.
 const int kTabShadowSize = 2;
-// The vertical overlap between the TabStrip and the Toolbar.
-const int kToolbarTabStripVerticalOverlap = 3;
 // The number of pixels the bookmark bar should overlap the spacer by if the
 // spacer is visible.
 const int kSpacerBookmarkBarOverlap = 1;
 // The number of pixels the metro switcher is offset from the right edge.
 const int kWindowSwitcherOffsetX = 7;
 // The number of pixels the constrained window should overlap the bottom
 // of the omnibox.
 const int kConstrainedWindowOverlap = 3;
 
 // Combines View::ConvertPointToTarget and View::HitTest for a given |point|.
@@ skipping 44 matching lines @@
     observer_list_.RemoveObserver(observer);
   }
 
   const BrowserViewLayout* browser_view_layout_;
 
   ObserverList<WebContentsModalDialogHostObserver> observer_list_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsModalDialogHostViews);
 };
 
+// static
+const int BrowserViewLayout::kToolbarTabStripVerticalOverlap = 3;
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserViewLayout, public:
 
 BrowserViewLayout::BrowserViewLayout()
     : contents_split_(NULL),
       contents_container_(NULL),
       download_shelf_(NULL),
       browser_view_(NULL),
       find_bar_y_(0),
@@ skipping 211 matching lines @@
         browser_view_->frame()->GetTabStripInsets(false).top));
   }
   top = LayoutToolbar(top);
   top = LayoutBookmarkAndInfoBars(top);
 
   // Top container requires updated toolbar and bookmark bar to compute size.
   browser_view_->top_container_->SetSize(
       browser_view_->top_container_->GetPreferredSize());
 
   int bottom = LayoutDownloadShelf(browser_view_->height());
-  int active_top_margin = GetTopMarginForActiveContent();
-  top -= active_top_margin;
-  contents_container_->SetActiveTopMargin(active_top_margin);
-  LayoutTabContents(top, bottom);
-
-  // Now set the contents to display at their previous origin if we just hid the
-  // bookmark and/or infobars.
-  if (active_top_margin == 0 && !old_contents_origin.IsOrigin()) {
-    gfx::Point new_contents_origin(contents->bounds().origin());
-    views::View::ConvertPointToTarget(contents->parent(), browser_view_,
-                                      &new_contents_origin);
-    active_top_margin = old_contents_origin.y() - new_contents_origin.y();
-    // Special case: While normally the suggestions appear to "cover" any
-    // bookmark/infobars, if the suggestions are very short, they might not
-    // fully cover that gap, and leaving the contents at their original height
-    // would leave an odd-looking blank space.  In this case, we allow the
-    // contents to go ahead and shift upward.
-    if (active_top_margin > 0 && active_top_margin < overlay_height)
-      contents_container_->SetActiveTopMargin(active_top_margin);
-  }
+  LayoutTabContents(top, bottom, old_contents_origin);
 
   // This must be done _after_ we lay out the WebContents since this
   // code calls back into us to find the bounding box the find bar
   // must be laid out within, and that code depends on the
   // TabContentsContainer's bounds being up to date.
   if (browser()->HasFindBarController()) {
     browser()->GetFindBarController()->find_bar()->MoveWindowIfNecessary(
         gfx::Rect(), true);
   }
 
@@ skipping 104 matching lines @@
   find_bar_y_ = top + browser_view_->y() - 1;
   return LayoutInfoBar(top);
 }
 
 int BrowserViewLayout::LayoutBookmarkBar(int top) {
   BookmarkBarView* bookmark_bar = browser_view_->bookmark_bar_view_.get();
   DCHECK(bookmark_bar);
   int y = top;
   if (!browser_view_->IsBookmarkBarVisible()) {
     bookmark_bar->SetVisible(false);
+    // TODO(jamescook): Don't change the bookmark bar height when it is
+    // invisible, so we can use its height for layout even in that state.
     bookmark_bar->SetBounds(0, y, browser_view_->width(), 0);
     return y;
   }
 
   bookmark_bar->set_infobar_visible(InfobarVisible());
   int bookmark_bar_height = bookmark_bar->GetPreferredSize().height();
   y -= views::NonClientFrameView::kClientEdgeThickness +
       bookmark_bar->GetToolbarOverlap(false);
   bookmark_bar->SetVisible(true);
   bookmark_bar->SetBounds(vertical_layout_rect_.x(), y,
@@ skipping 15 matching lines @@
   infobar_container->SetVisible(InfobarVisible());
   int height;
   int overlapped_top = top - infobar_container->GetVerticalOverlap(&height);
   infobar_container->SetBounds(vertical_layout_rect_.x(),
                                overlapped_top,
                                vertical_layout_rect_.width(),
                                height);
   return overlapped_top + height;
 }
 
-void BrowserViewLayout::LayoutTabContents(int top, int bottom) {
-  // The ultimate idea is to calculate bounds and reserved areas for all
-  // contents views first and then resize them all, so every view
-  // (and its contents) is resized and laid out only once.
+void BrowserViewLayout::LayoutTabContents(
+    int top,
+    int bottom,
+    const gfx::Point& contents_origin) {
+  // Vertical offsets for the active page and instant overlay.
+  int active_top_margin = GetTopMarginForActiveContent();
+  int overlay_top_margin = 0;
 
-  // The views hierarcy (see browser_view.h for more details):
-  // contents_split_ -> [contents_container_ | devtools]
-
-  gfx::Rect contents_bounds;
-  gfx::Rect devtools_bounds;
-
-  gfx::Rect contents_split_bounds(vertical_layout_rect_.x(), top,
+  // |contents_split_| contains web page contents and devtools.
+  // See browser_view.h for details.
+  top -= active_top_margin;
+  gfx::Rect contents_split_bounds(vertical_layout_rect_.x(),
+                                  top,
                                   vertical_layout_rect_.width(),
                                   std::max(0, bottom - top));
-  gfx::Point contents_split_offset(
-      contents_split_bounds.x() - contents_split_->bounds().x(),
-      contents_split_bounds.y() - contents_split_->bounds().y());
+  contents_split_->SetBoundsRect(contents_split_bounds);

[James Cook, 2013/04/05 02:05:05]

The diff is confusing - LayoutTabContents() contained a large amount of dead
code. The only thing it actually did was set the bounds of the contents split.

[kuan, 2013/04/08 15:56:30]

if SetBoundsRect changes bounds of contents_container_, it will re-layout its
children at the top margins u've set in the previous Layout().
this works if your previous margins were 0; @543, u'll then get the new origins
of the active and overlay webviews as if they were laid out afresh.
if however, u've set some margins in the previous Layout(), the webviews will be
laid out at the previous margins.  then @555, ur active_top_margin will be
incorrect, because it doesn't consider the margin used to layout the active
webview.
i think that's why the previous impl of calling SetActiveTopMargin twice worked
because the webviews were always re-laid out at the new margin, and we need to
know where the webviews will be without the spacer.

fyi, here are the scenarios that work:
a) if there's only bmb: at amazon.com, enable bmb, type a query that reproduces
a url as the first suggestion, u'll notice contents of amazon.com don't shift
b) if there's only infobar: at google.de, disable bmb, u shld have translate
infobar, type same query, u'll notice same results as (a).

here's the scenario that fails:
if there's bmb AND infobar: at google.de, enable bmb, u shld have translate
infobar, type same query, u'll notice contents of google.de shift up.

let me know if u need screenshots/video for better illustration.  

[kuan, 2013/04/08 16:05:33]

in the scenario that fails, Layout is called separately when bmb and infobar are
hidden; u set a margin when the 1st bar gets hidden, then u reuse that margin to
position active webview when the 2nd bar gets hidden.  this gives u an origin
that is already shifted down, but u don't consider that when u set a new margin.

 
-  // Layout resize corner and calculate reserved contents rects here as all
-  // contents view bounds are already determined, but not yet set at this point,
-  // so contents will be laid out once at most.
-  gfx::Rect browser_reserved_rect;
-  if (!browser_view_->frame_->IsMaximized() &&
-      !browser_view_->frame_->IsFullscreen()) {
-    gfx::Size resize_corner_size = browser_view_->GetResizeCornerSize();
-    if (!resize_corner_size.IsEmpty()) {
-      gfx::Rect bounds = browser_view_->GetContentsBounds();
-      gfx::Point resize_corner_origin(
-          bounds.right() - resize_corner_size.width(),
-          bounds.bottom() - resize_corner_size.height());
-      browser_reserved_rect =
-          gfx::Rect(resize_corner_origin, resize_corner_size);
+  // During an immersive reveal, if instant extended is showing suggestions
+  // (either in an overlay web view or the active web view) ensure the
+  // the web view appears aligned with the bottom of the omnibox.
+  InstantUIState instant_ui_state = GetInstantUIState();
+  if (instant_ui_state != kInstantUINone &&
+      browser_view_->immersive_mode_controller()->IsRevealed()) {
+    gfx::Point bottom_edge(0, browser_view_->top_container_->height());
+    views::View::ConvertPointToTarget(browser_view_->top_container_,
+                                      contents_container_,
+                                      &bottom_edge);
+    switch (instant_ui_state) {
+      case kInstantUINone:
+        break;
+      case kInstantUIOverlay:
+        overlay_top_margin = bottom_edge.y();
+        break;
+      case kInstantUIFullPageResults:
+        active_top_margin = bottom_edge.y();
+        break;
     }
   }
 
-  // Now it's safe to actually resize all contents views in the hierarchy.
-  contents_split_->SetBoundsRect(contents_split_bounds);
+  // Now set the contents to display at their previous origin if we just hid the
+  // bookmark and/or infobars for instant extended. We can't just compute the
+  // proper position at this point because we don't know the height of all the
+  // infobars and their arrows.
+  if (active_top_margin == 0 && !contents_origin.IsOrigin()) {
+    views::WebView* contents_view = browser_view_->contents_container_;
+    gfx::Point new_contents_origin(contents_view->bounds().origin());
+    views::View::ConvertPointToTarget(contents_view->parent(),
+                                      browser_view_,
+                                      &new_contents_origin);
+    int contents_offset = contents_origin.y() - new_contents_origin.y();
+    // Special case: While normally the suggestions appear to "cover" any
+    // bookmark/infobars, if the suggestions are very short, they might not
+    // fully cover that gap, and leaving the contents at their original height
+    // would leave an odd-looking blank space.  In this case, we allow the
+    // contents to go ahead and shift upward.
+    if (contents_offset > 0 &&
+        contents_offset < contents_container_->overlay_height())
+      active_top_margin = contents_offset;
+  }
+
+  // Apply our adjustments to the active page and instant overlay position
+  // to account for detached bookmark bars, instant extended and immersive mode.
+  contents_container_->SetWebViewsTopMargins(active_top_margin,
+                                             overlay_top_margin);
 }
 
 int BrowserViewLayout::GetTopMarginForActiveContent() {
   BookmarkBarView* bookmark_bar = browser_view_->bookmark_bar_view_.get();
   if (!bookmark_bar ||
       !browser_view_->IsBookmarkBarVisible() ||
       !bookmark_bar->IsDetached()) {
     return 0;
   }
 
+  // Handle dev tools.
   if (contents_split_->child_at(1) && contents_split_->child_at(1)->visible())
     return 0;
 
-  // Adjust for separator.
+  // Offset for the detached bookmark bar.
   return bookmark_bar->height() -
       views::NonClientFrameView::kClientEdgeThickness;
 }
 
+BrowserViewLayout::InstantUIState BrowserViewLayout::GetInstantUIState() {

[James Cook, 2013/04/05 02:05:05]

This is a near-copy of the Mac function currentInstantUIState().

+  if (!browser()->search_model()->mode().is_search_suggestions())
+    return kInstantUINone;
+
+  // If the search suggestions are already being displayed in the overlay
+  // contents then return kInstantUIOverlay.
+  if (contents_container_->overlay_height() > 0)
+    return kInstantUIOverlay;
+
+  // Top bars stay visible until the results page notifies Chrome it is ready.
+  if (browser()->search_model()->top_bars_visible())
+    return kInstantUINone;
+
+  return kInstantUIFullPageResults;
+}
+
 int BrowserViewLayout::LayoutDownloadShelf(int bottom) {
   // Re-layout the shelf either if it is visible or if its close animation
   // is currently running.
   if (browser_view_->IsDownloadShelfVisible() ||
       (download_shelf_ && download_shelf_->IsClosing())) {
     bool visible = browser()->SupportsWindowFeature(
         Browser::FEATURE_DOWNLOADSHELF);
     DCHECK(download_shelf_);
     int height = visible ? download_shelf_->GetPreferredSize().height() : 0;
     download_shelf_->SetVisible(visible);
     download_shelf_->SetBounds(vertical_layout_rect_.x(), bottom - height,
                                vertical_layout_rect_.width(), height);
     download_shelf_->Layout();
     bottom -= height;
   }
   return bottom;
 }
 
 bool BrowserViewLayout::InfobarVisible() const {
   views::View* infobar_container = browser_view_->infobar_container_;
   // NOTE: Can't check if the size IsEmpty() since it's always 0-width.
   return browser()->SupportsWindowFeature(Browser::FEATURE_INFOBAR) &&
       (infobar_container->GetPreferredSize().height() != 0);
 }