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());
+  // Treat a detached bookmark bar as if the web contents container is shifted
+  // upwards and overlaps it.
+  top -= GetContentsOffsetForBookmarkBar();
+  LayoutContentsSplitView(top, bottom);
+
+  // Instant extended can put suggestions in a web view, which can require an
+  // offset to align with the omnibox. This offset must be recomputed after
+  // split view layout to account for infobar heights.
   int active_top_margin = GetTopMarginForActiveContent();
-  top -= active_top_margin;
-  contents_container_->SetActiveTopMargin(active_top_margin);
-  LayoutTabContents(top, bottom);
+  bool needs_layout =
+      contents_container_->SetActiveTopMargin(active_top_margin);
+  needs_layout |=
+      contents_container_->SetOverlayTopMargin(GetTopMarginForOverlayContent());
+  if (needs_layout)
+    contents_container_->Layout();
 
   // 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
@@ skipping 120 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.
-
-  // 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,
+void BrowserViewLayout::LayoutContentsSplitView(int top, int bottom) {
+  // |contents_split_| contains web page contents and devtools.
+  // See browser_view.h for details.
+  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());
-
-  // 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);
-    }
-  }
-
-  // Now it's safe to actually resize all contents views in the hierarchy.
   contents_split_->SetBoundsRect(contents_split_bounds);
 }
 
-int BrowserViewLayout::GetTopMarginForActiveContent() {
+int BrowserViewLayout::GetContentsOffsetForBookmarkBar() {
+  // If the bookmark bar is hidden or attached to the omnibox the web contents
+  // will appear directly underneath it and does not need an offset.
   BookmarkBarView* bookmark_bar = browser_view_->bookmark_bar_view_.get();
   if (!bookmark_bar ||
       !browser_view_->IsBookmarkBarVisible() ||
       !bookmark_bar->IsDetached()) {
     return 0;
   }
 
+  // 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;
 }
 
+int BrowserViewLayout::GetTopMarginForActiveContent() {
+  // During an immersive reveal, if instant extended is showing suggestions
+  // in the main active web view, ensure that active web view appears aligned
+  // with the bottom of the omnibox.
+  InstantUIState instant_ui_state = GetInstantUIState();
+  if (instant_ui_state == kInstantUIFullPageResults &&
+      browser_view_->immersive_mode_controller()->IsRevealed())
+    return GetTopMarginForImmersiveInstant();
+
+  // Usually we only use a margin if there's a detached bookmarks bar.
+  return GetContentsOffsetForBookmarkBar();
+}
+
+int BrowserViewLayout::GetTopMarginForOverlayContent() {
+  // During an immersive reveal, if instant extended is showing suggestions
+  // in an overlay web view, ensure that overlay web view appears aligned
+  // with the bottom of the omnibox.
+  InstantUIState instant_ui_state = GetInstantUIState();
+  if (instant_ui_state == kInstantUIOverlay &&
+      browser_view_->immersive_mode_controller()->IsRevealed())
+    return GetTopMarginForImmersiveInstant();
+
+  // Usually the overlay content is aligned with the active web content.
+  return 0;
+}
+
+int BrowserViewLayout::GetTopMarginForImmersiveInstant() {
+  // Compute the position of the bottom edge of the top container views,
+  // expressed as an offset in the coordinates of |contents_container_|,
+  // because the offset will be applied in |contents_container_| layout.
+  // NOTE: This requires contents_split_ layout to be complete, as the
+  // coordinate system conversion depends on the contents_split_ origin.
+  gfx::Point bottom_edge(0, browser_view_->top_container_->height());
+  views::View::ConvertPointToTarget(browser_view_->top_container_,
+                                    contents_container_,
+                                    &bottom_edge);
+  return bottom_edge.y();
+}
+
+BrowserViewLayout::InstantUIState BrowserViewLayout::GetInstantUIState() {
+  if (!browser()->search_model()->mode().is_search())
+    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);
 }