Immersive mode reveals the tabstrip/omnibox on top of web content

chrome/browser/ui/views/frame/browser_view_layout.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/views/frame/browser_view_layout.h"
 
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/find_bar/find_bar.h"
 #include "chrome/browser/ui/find_bar/find_bar_controller.h"
 #include "chrome/browser/ui/search/search_model.h"
 #include "chrome/browser/ui/search/search_ui.h"
 #include "chrome/browser/ui/view_ids.h"
 #include "chrome/browser/ui/views/bookmarks/bookmark_bar_view.h"
 #include "chrome/browser/ui/views/download/download_shelf_view.h"
 #include "chrome/browser/ui/views/frame/browser_frame.h"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/views/frame/contents_container.h"
+#include "chrome/browser/ui/views/immersive_mode_controller.h"
 #include "chrome/browser/ui/views/infobars/infobar_container_view.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
 #include "chrome/browser/ui/views/toolbar_view.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"
 
@@ skipping 23 matching lines @@
   views::View::ConvertPointToTarget(src, dst, point);
   return dst->HitTestPoint(*point);
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserViewLayout, public:
 
 BrowserViewLayout::BrowserViewLayout()
-    : tabstrip_(NULL),
-      toolbar_(NULL),
-      contents_split_(NULL),
+    : contents_split_(NULL),
       contents_container_(NULL),
-      infobar_container_(NULL),
       download_shelf_(NULL),
       active_bookmark_bar_(NULL),
       browser_view_(NULL),
       find_bar_y_(0),
       constrained_window_top_y_(-1) {
 }
 
 BrowserViewLayout::~BrowserViewLayout() {
 }
 
 bool BrowserViewLayout::GetConstrainedWindowTopY(int* top_y) {
   DCHECK(top_y);
   *top_y = constrained_window_top_y_;
   return (constrained_window_top_y_ >= 0);
 }
 
 gfx::Size BrowserViewLayout::GetMinimumSize() {
   gfx::Size tabstrip_size(
       browser()->SupportsWindowFeature(Browser::FEATURE_TABSTRIP) ?
-      tabstrip_->GetMinimumSize() : gfx::Size());
+      browser_view_->tabstrip_->GetMinimumSize() : gfx::Size());
   BrowserNonClientFrameView::TabStripInsets tab_strip_insets(
       browser_view_->frame()->GetTabStripInsets(false));
   gfx::Size toolbar_size(
       (browser()->SupportsWindowFeature(Browser::FEATURE_TOOLBAR) ||
        browser()->SupportsWindowFeature(Browser::FEATURE_LOCATIONBAR)) ?
-      toolbar_->GetMinimumSize() : gfx::Size());
+           browser_view_->toolbar_->GetMinimumSize() : gfx::Size());
   if (tabstrip_size.height() && toolbar_size.height())
     toolbar_size.Enlarge(0, -kToolbarTabStripVerticalOverlap);
   gfx::Size bookmark_bar_size;
   if (active_bookmark_bar_ &&
       browser()->SupportsWindowFeature(Browser::FEATURE_BOOKMARKBAR)) {
     bookmark_bar_size = active_bookmark_bar_->GetMinimumSize();
     bookmark_bar_size.Enlarge(0,
         -(views::NonClientFrameView::kClientEdgeThickness +
             active_bookmark_bar_->GetToolbarOverlap(true)));
   }
@@ skipping 36 matching lines @@
   int scrollbar_width = gfx::scrollbar_size();
   bounding_box.set_width(std::max(0, bounding_box.width() - scrollbar_width));
   if (base::i18n::IsRTL())
     bounding_box.set_x(bounding_box.x() + scrollbar_width);
 
   return bounding_box;
 }
 
 bool BrowserViewLayout::IsPositionInWindowCaption(
     const gfx::Point& point) {
+  TabStrip* tabstrip = browser_view_->tabstrip_;
+  // Tab strip may transiently have no parent between the RemoveChildView() and
+  // AddChildView() caused by reparenting during an immersive mode reveal.
+  // During this window report that the point didn't hit a tab.
+  if (!tabstrip->parent())
+    return true;
   gfx::Point tabstrip_point(point);
-  views::View::ConvertPointToTarget(browser_view_, tabstrip_, &tabstrip_point);
-  return tabstrip_->IsPositionInWindowCaption(tabstrip_point);
+  views::View::ConvertPointToTarget(browser_view_, tabstrip, &tabstrip_point);
+  return tabstrip->IsPositionInWindowCaption(tabstrip_point);
 }
 
 int BrowserViewLayout::NonClientHitTest(
     const gfx::Point& point) {
   // Since the TabStrip only renders in some parts of the top of the window,
   // the un-obscured area is considered to be part of the non-client caption
   // area of the window. So we need to treat hit-tests in these regions as
   // hit-tests of the titlebar.
 
   views::View* parent = browser_view_->parent();
 
   gfx::Point point_in_browser_view_coords(point);
   views::View::ConvertPointToTarget(
       parent, browser_view_, &point_in_browser_view_coords);
   gfx::Point test_point(point);
 
   // Determine if the TabStrip exists and is capable of being clicked on. We
   // might be a popup window without a TabStrip.
   if (browser_view_->IsTabStripVisible()) {
     // See if the mouse pointer is within the bounds of the TabStrip.
-    if (ConvertedHitTest(parent, tabstrip_, &test_point)) {
-      if (tabstrip_->IsPositionInWindowCaption(test_point))
+    if (ConvertedHitTest(parent, browser_view_->tabstrip_, &test_point)) {
+      if (browser_view_->tabstrip_->IsPositionInWindowCaption(test_point))
         return HTCAPTION;
       return HTCLIENT;
     }
 
     // The top few pixels of the TabStrip are a drop-shadow - as we're pretty
     // starved of dragable area, let's give it to window dragging (this also
     // makes sense visually).
     if (!browser_view_->IsMaximized() &&
         (point_in_browser_view_coords.y() <
-         (tabstrip_->y() + kTabShadowSize))) {
+         (browser_view_->tabstrip_->y() + kTabShadowSize))) {
       // We return HTNOWHERE as this is a signal to our containing
       // NonClientView that it should figure out what the correct hit-test
       // code is given the mouse position...
       return HTNOWHERE;
     }
   }
 
   // If the point's y coordinate is below the top of the toolbar and otherwise
   // within the bounds of this view, the point is considered to be within the
   // client area.
   gfx::Rect bv_bounds = browser_view_->bounds();
-  bv_bounds.Offset(0, toolbar_->y());
-  bv_bounds.set_height(bv_bounds.height() - toolbar_->y());
+  bv_bounds.Offset(0, browser_view_->toolbar_->y());
+  bv_bounds.set_height(bv_bounds.height() - browser_view_->toolbar_->y());
   if (bv_bounds.Contains(point))
     return HTCLIENT;
 
   // If the point's y coordinate is above the top of the toolbar, but not in
   // the tabstrip (per previous checking in this function), then we consider it
   // in the window caption (e.g. the area to the right of the tabstrip
   // underneath the window controls). However, note that we DO NOT return
   // HTCAPTION here, because when the window is maximized the window controls
   // will fall into this space (since the BrowserView is sized to entire size
   // of the window at that point), and the HTCAPTION value will cause the
   // window controls not to work. So we return HTNOWHERE so that the caller
   // will hit-test the window controls before finally falling back to
   // HTCAPTION.
   bv_bounds = browser_view_->bounds();
-  bv_bounds.set_height(toolbar_->y());
+  bv_bounds.set_height(browser_view_->toolbar_->y());
   if (bv_bounds.Contains(point))
     return HTNOWHERE;
 
   // If the point is somewhere else, delegate to the default implementation.
   return browser_view_->views::ClientView::NonClientHitTest(point);
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // BrowserViewLayout, views::LayoutManager implementation:
 
 void BrowserViewLayout::Installed(views::View* host) {
-  toolbar_ = NULL;
   contents_split_ = NULL;
   contents_container_ = NULL;
-  infobar_container_ = NULL;
   download_shelf_ = NULL;
   active_bookmark_bar_ = NULL;
-  tabstrip_ = NULL;
   browser_view_ = static_cast<BrowserView*>(host);
 }
 
 void BrowserViewLayout::Uninstalled(views::View* host) {}
 
 void BrowserViewLayout::ViewAdded(views::View* host, views::View* view) {
   switch (view->id()) {
     case VIEW_ID_CONTENTS_SPLIT: {
       contents_split_ = static_cast<views::SingleSplitView*>(view);
       // We're installed as the LayoutManager before BrowserView creates the
       // contents, so we have to set contents_container_ here rather than in
       // Installed.
       contents_container_ = browser_view_->contents_;
       break;
     }
-    case VIEW_ID_INFO_BAR_CONTAINER:
-      infobar_container_ = view;
-      break;
     case VIEW_ID_DOWNLOAD_SHELF:
       download_shelf_ = static_cast<DownloadShelfView*>(view);
       break;
     case VIEW_ID_BOOKMARK_BAR:
       active_bookmark_bar_ = static_cast<BookmarkBarView*>(view);
       break;
-    case VIEW_ID_TOOLBAR:
-      toolbar_ = static_cast<ToolbarView*>(view);
-      break;
-    case VIEW_ID_TAB_STRIP:
-      tabstrip_ = static_cast<TabStrip*>(view);
-      break;
   }
 }
 
 void BrowserViewLayout::ViewRemoved(views::View* host, views::View* view) {
   switch (view->id()) {
     case VIEW_ID_BOOKMARK_BAR:
       active_bookmark_bar_ = NULL;
       break;
   }
 }
 
 void BrowserViewLayout::Layout(views::View* host) {
   vertical_layout_rect_ = browser_view_->GetLocalBounds();
   int top = LayoutTabStripRegion();
   if (browser_view_->IsTabStripVisible()) {
-    int x = tabstrip_->GetMirroredX() + browser_view_->GetMirroredX() +
+    int x = browser_view_->tabstrip_->GetMirroredX() +
+        browser_view_->GetMirroredX() +
         browser_view_->frame()->GetThemeBackgroundXInset();
-    tabstrip_->SetBackgroundOffset(gfx::Point(x,
+    browser_view_->tabstrip_->SetBackgroundOffset(gfx::Point(x,
         browser_view_->frame()->GetTabStripInsets(false).top));
   }
   top = LayoutToolbar(top);
   top = LayoutBookmarkAndInfoBars(top);
+  // During immersive mode reveal the content stays near the top of the view.
+  if (browser_view_->immersive_mode_controller()->IsRevealed())
+    top = browser_view_->tabstrip_->x() + TabStrip::GetImmersiveHeight();
+
   int bottom = LayoutDownloadShelf(browser_view_->height());
   int active_top_margin = GetTopMarginForActiveContent();
   top -= active_top_margin;
   contents_container_->SetActiveTopMargin(active_top_margin);
   LayoutTabContents(top, bottom);
   // 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()) {
@@ skipping 23 matching lines @@
 
 Browser* BrowserViewLayout::browser() {
   return browser_view_->browser();
 }
 
 const Browser* BrowserViewLayout::browser() const {
   return browser_view_->browser();
 }
 
 int BrowserViewLayout::LayoutTabStripRegion() {
+  TabStrip* tabstrip = browser_view_->tabstrip_;
   if (!browser_view_->IsTabStripVisible()) {
-    tabstrip_->SetVisible(false);
-    tabstrip_->SetBounds(0, 0, 0, 0);
+    tabstrip->SetVisible(false);
+    tabstrip->SetBounds(0, 0, 0, 0);
     return 0;
   }
   // This retrieves the bounds for the tab strip based on whether or not we show
   // anything to the left of it, like the incognito avatar.
   gfx::Rect tabstrip_bounds(
-      browser_view_->frame()->GetBoundsForTabStrip(tabstrip_));
+      browser_view_->frame()->GetBoundsForTabStrip(tabstrip));
   gfx::Point tabstrip_origin(tabstrip_bounds.origin());
   views::View::ConvertPointToTarget(browser_view_->parent(), browser_view_,
                                   &tabstrip_origin);
   tabstrip_bounds.set_origin(tabstrip_origin);
 
-  tabstrip_->SetVisible(true);
-  tabstrip_->SetBoundsRect(tabstrip_bounds);
+  tabstrip->SetVisible(true);
+  tabstrip->SetBoundsRect(tabstrip_bounds);
   int bottom = tabstrip_bounds.bottom();
 
   // The metro window switcher sits at the far right edge of the tabstrip
   // a |kWindowSwitcherOffsetX| pixels from the right edge.
   // Only visible if there is more than one type of window to switch between.
   // TODO(mad): update this code when more window types than just incognito
   // and regular are available.
   views::Button* switcher_button = browser_view_->window_switcher_button_;
   if (switcher_button) {
     if (browser()->profile()->HasOffTheRecordProfile() &&
@@ skipping 16 matching lines @@
       // ::SetWindowPos( , .. SWP_SHOWWINDOW) which causes this function to
       // be called again. This works both in showing or hidding the button.
       switcher_button->SetVisible(false);
     }
   }
 
   return bottom;
 }
 
 int BrowserViewLayout::LayoutToolbar(int top) {
+  ToolbarView* toolbar = browser_view_->toolbar_;
   int browser_view_width = vertical_layout_rect_.width();
   bool toolbar_visible = browser_view_->IsToolbarVisible();
-  toolbar_->location_bar()->SetLocationEntryFocusable(toolbar_visible);
+  toolbar->location_bar()->SetLocationEntryFocusable(toolbar_visible);
   int y = top;
   y -= (toolbar_visible && browser_view_->IsTabStripVisible()) ?
         kToolbarTabStripVerticalOverlap : 0;
-  int height = toolbar_visible ? toolbar_->GetPreferredSize().height() : 0;
-  toolbar_->SetVisible(toolbar_visible);
-  toolbar_->SetBounds(vertical_layout_rect_.x(), y, browser_view_width, height);
+  int height = toolbar_visible ? toolbar->GetPreferredSize().height() : 0;
+  toolbar->SetVisible(toolbar_visible);
+  toolbar->SetBounds(vertical_layout_rect_.x(), y, browser_view_width, height);
 
   return y + height;
 }
 
 int BrowserViewLayout::LayoutBookmarkAndInfoBars(int top) {
   constrained_window_top_y_ =
       top + browser_view_->y() - kConstrainedWindowOverlap;
   find_bar_y_ = top + browser_view_->y() - 1;
   if (active_bookmark_bar_) {
     // If the bookmark bar is showing in detached style:
     // - for non-NTP mode, show any Info bar _above_ the bookmark bar, since the
     //   bookmark bar is styled to look like it's part of the page.
     // - otherwise, show the bookmark bar at the bottom of content view, so just
     //   lay out infobar here; bottom bookmark bar is laid out in
     //   |LayoutBookmarkBarAtBottom|.
     if (active_bookmark_bar_->IsDetached()) {
       int infobar_top = LayoutInfoBar(top);
       return browser()->search_model()->mode().is_ntp() ?
           infobar_top : LayoutBookmarkBarAtTop(infobar_top);
     }
     // Otherwise, Bookmark bar first, Info bar second.
-    top = std::max(toolbar_->bounds().bottom(), LayoutBookmarkBarAtTop(top));
+    top = std::max(browser_view_->toolbar_->bounds().bottom(),
+                   LayoutBookmarkBarAtTop(top));
   }
   find_bar_y_ = top + browser_view_->y() - 1;
   return LayoutInfoBar(top);
 }
 
 int BrowserViewLayout::LayoutBookmarkBarAtTop(int top) {
   DCHECK(active_bookmark_bar_);
   int y = top;
   if (!browser_view_->IsBookmarkBarVisible()) {
     active_bookmark_bar_->SetVisible(false);
@@ skipping 55 matching lines @@
   // contents_container_ allows it to tell its child view that it's bigger,
   // and clip it so that a theme background aligned to the bottom
   // or vertically centered is properly aligned whith the bookmark bar view
   // drawing of the bottom of the bitmap.
   contents_container_->SetExtraContentHeight(height);
   contents_split_->SetLeadingBottomOffset(height);
 #endif  // !USE_AURA
 }
 
 int BrowserViewLayout::LayoutInfoBar(int top) {
-  // Raise the |infobar_container_| by its vertical overlap.
-  infobar_container_->SetVisible(InfobarVisible());
+  InfoBarContainerView* infobar_container = browser_view_->infobar_container_;
+  // Raise the |infobar_container| by its vertical overlap.
+  infobar_container->SetVisible(InfobarVisible());
   int height;
-  int overlapped_top = top -
-      static_cast<InfoBarContainerView*>(infobar_container_)->
-          GetVerticalOverlap(&height);
-  infobar_container_->SetBounds(vertical_layout_rect_.x(),
-                                overlapped_top,
-                                vertical_layout_rect_.width(),
-                                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]
@@ skipping 36 matching lines @@
     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);
+      (infobar_container->GetPreferredSize().height() != 0);
 }