Unit test for BrowserViewLayout that does not depend on BrowserView

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"
 #include "chrome/browser/ui/find_bar/find_bar_controller.h"
 #include "chrome/browser/ui/search/search_model.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/frame/immersive_mode_controller.h"
 #include "chrome/browser/ui/views/frame/overlay_container.h"
 #include "chrome/browser/ui/views/frame/top_container_view.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 "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 number of pixels the bookmark bar should overlap the spacer by if the
@@ skipping 61 matching lines @@
 };
 
 // static
 const int BrowserViewLayout::kToolbarTabStripVerticalOverlap = 3;
 
 ////////////////////////////////////////////////////////////////////////////////
 // BrowserViewLayout, public:
 
 BrowserViewLayout::BrowserViewLayout()
     : browser_(NULL),
+      delegate_(NULL),
       browser_view_(NULL),
+      top_container_(NULL),
+      tab_strip_(NULL),
+      toolbar_(NULL),
       bookmark_bar_(NULL),
       infobar_container_(NULL),
       contents_split_(NULL),
       contents_container_(NULL),
       overlay_container_(NULL),
+      window_switcher_button_(NULL),
       download_shelf_(NULL),
+      immersive_mode_controller_(NULL),
       dialog_host_(new WebContentsModalDialogHostViews(this)),
       web_contents_modal_dialog_top_y_(-1) {
 }
 
 BrowserViewLayout::~BrowserViewLayout() {
 }
 
-void BrowserViewLayout::Init(Browser* browser,
-                             BrowserView* browser_view,
-                             InfoBarContainerView* infobar_container,
-                             views::SingleSplitView* contents_split,
-                             ContentsContainer* contents_container,
-                             OverlayContainer* overlay_container) {
+void BrowserViewLayout::Init(
+    Browser* browser,
+    BrowserViewLayoutDelegate* delegate,
+    BrowserView* browser_view,
+    views::View* top_container,
+    TabStrip* tab_strip,
+    views::View* toolbar,
+    InfoBarContainerView* infobar_container,
+    views::View* contents_split,
+    ContentsContainer* contents_container,
+    OverlayContainer* overlay_container,
+    ImmersiveModeController* immersive_mode_controller) {
   browser_ = browser;
+  delegate_ = delegate;
   browser_view_ = browser_view;
+  top_container_ = top_container;
+  tab_strip_ = tab_strip;
+  toolbar_ = toolbar;
   infobar_container_ = infobar_container;
   contents_split_ = contents_split;
   contents_container_ = contents_container;
   overlay_container_ = overlay_container;
+  immersive_mode_controller_ = immersive_mode_controller;
 }
 
 WebContentsModalDialogHost*
     BrowserViewLayout::GetWebContentsModalDialogHost() {
   return dialog_host_.get();
 }
 
 gfx::Size BrowserViewLayout::GetMinimumSize() {
   gfx::Size tabstrip_size(
       browser()->SupportsWindowFeature(Browser::FEATURE_TABSTRIP) ?
-      browser_view_->tabstrip_->GetMinimumSize() : gfx::Size());
+      tab_strip_->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)) ?
-           browser_view_->toolbar_->GetMinimumSize() : gfx::Size());
+           toolbar_->GetMinimumSize() : gfx::Size());
   if (tabstrip_size.height() && toolbar_size.height())
     toolbar_size.Enlarge(0, -kToolbarTabStripVerticalOverlap);
   gfx::Size bookmark_bar_size;
   if (bookmark_bar_ &&
       bookmark_bar_->visible() &&
       browser()->SupportsWindowFeature(Browser::FEATURE_BOOKMARKBAR)) {
     bookmark_bar_size = bookmark_bar_->GetMinimumSize();
     bookmark_bar_size.Enlarge(0,
         -(views::NonClientFrameView::kClientEdgeThickness +
             bookmark_bar_->GetToolbarOverlap(true)));
@@ skipping 18 matching lines @@
   // basically implies the "user-perceived content area" of the browser
   // window excluding the vertical scrollbar. The "user-perceived content area"
   // excludes the detached bookmark bar (in the New Tab case) and any infobars
   // since they are not _visually_ connected to the Toolbar.
 
   // First determine the bounding box of the content area in Widget
   // coordinates.
   gfx::Rect bounding_box = contents_container_->ConvertRectToWidget(
       contents_container_->GetLocalBounds());
 
-  TopContainerView* top_container = browser_view_->top_container();
-  gfx::Rect top_container_bounds = top_container->ConvertRectToWidget(
-      top_container->GetLocalBounds());
+  gfx::Rect top_container_bounds = top_container_->ConvertRectToWidget(
+      top_container_->GetLocalBounds());
 
   // The find bar is positioned 1 pixel above the bottom of the top container so
   // that it occludes the border between the content area and the top container
   // and looks connected to the top container.
   int find_bar_y = top_container_bounds.bottom() - 1;
 
   // Grow the height of |bounding_box| by the height of any elements between
   // the top container and |contents_container_| such as the detached bookmark
   // bar and any infobars.
   int height_delta = bounding_box.y() - find_bar_y;
   bounding_box.set_y(find_bar_y);
   bounding_box.set_height(std::max(0, bounding_box.height() + height_delta));
 
   // Finally decrease the width of the bounding box by the width of
   // the vertical scroll bar.
   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())
+  if (!tab_strip_->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_, tab_strip_, &tabstrip_point);
+  return tab_strip_->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, browser_view_->tabstrip_, &test_point)) {
-      if (browser_view_->tabstrip_->IsPositionInWindowCaption(test_point))
+    if (ConvertedHitTest(parent, tab_strip_, &test_point)) {
+      if (tab_strip_->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() <
-         (browser_view_->tabstrip_->y() + kTabShadowSize))) {
+            (tab_strip_->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, browser_view_->toolbar_->y());
-  bv_bounds.set_height(bv_bounds.height() - browser_view_->toolbar_->y());
+  bv_bounds.Offset(0, toolbar_->y());
+  bv_bounds.set_height(bv_bounds.height() - 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(browser_view_->toolbar_->y());
+  bv_bounds.set_height(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::Layout(views::View* host) {
-  vertical_layout_rect_ = browser_view_->GetLocalBounds();
-  int top = LayoutTabStripRegion();
-  if (browser_view_->IsTabStripVisible()) {
-    int x = browser_view_->tabstrip_->GetMirroredX() +
+void BrowserViewLayout::Layout(views::View* browser_view) {
+  vertical_layout_rect_ = browser_view->GetLocalBounds();
+  int top = LayoutTabStripRegion(browser_view);
+  if (delegate_->IsTabStripVisible()) {
+    int x = tab_strip_->GetMirroredX() +
         browser_view_->GetMirroredX() +
         browser_view_->frame()->GetThemeBackgroundXInset();
-    browser_view_->tabstrip_->SetBackgroundOffset(gfx::Point(x,
-        browser_view_->frame()->GetTabStripInsets(false).top));
+    tab_strip_->SetBackgroundOffset(
+        gfx::Point(x, browser_view_->frame()->GetTabStripInsets(false).top));
   }
   top = LayoutToolbar(top);
 
+  web_contents_modal_dialog_top_y_ =
+      top + browser_view->y() - kConstrainedWindowOverlap;
+
   // Overlay container requires updated toolbar bounds to determine its
   // position, and needs to be laid out before:
   // - GetTopMarginForActiveContent(), which calls GetInstantUIState() to check
   //   if overlay container is visible
   // - LayoutInfoBar(): children of infobar container will layout and call
   //   BrowserView::DrawInfoBarArrows(), which checks if overlay container is
   //   visible.
   LayoutOverlayContainer();
 
   top = LayoutBookmarkAndInfoBars(top);
 
   // Top container requires updated toolbar and bookmark bar to compute size.
-  browser_view_->top_container_->SetSize(
-      browser_view_->top_container_->GetPreferredSize());
+  top_container_->SetSize(top_container_->GetPreferredSize());
 
-  int bottom = LayoutDownloadShelf(browser_view_->height());
+  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();
   if (contents_container_->SetActiveTopMargin(active_top_margin))
@@ skipping 14 matching lines @@
 
 // Return the preferred size which is the size required to give each
 // children their respective preferred size.
 gfx::Size BrowserViewLayout::GetPreferredSize(views::View* host) {
   return gfx::Size();
 }
 
 //////////////////////////////////////////////////////////////////////////////
 // BrowserViewLayout, private:
 
-int BrowserViewLayout::LayoutTabStripRegion() {
-  TabStrip* tabstrip = browser_view_->tabstrip_;
-  if (!browser_view_->IsTabStripVisible()) {
-    tabstrip->SetVisible(false);
-    tabstrip->SetBounds(0, 0, 0, 0);
+int BrowserViewLayout::LayoutTabStripRegion(views::View* browser_view) {
+  if (!delegate_->IsTabStripVisible()) {
+    tab_strip_->SetVisible(false);
+    tab_strip_->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));
+  gfx::Rect tabstrip_bounds(delegate_->GetBoundsForTabStrip(tab_strip_));
   gfx::Point tabstrip_origin(tabstrip_bounds.origin());
-  views::View::ConvertPointToTarget(browser_view_->parent(), browser_view_,
-                                    &tabstrip_origin);
+  views::View::ConvertPointToTarget(
+      browser_view->parent(), browser_view, &tabstrip_origin);
   tabstrip_bounds.set_origin(tabstrip_origin);
 
-  tabstrip->SetVisible(true);
-  tabstrip->SetBoundsRect(tabstrip_bounds);
+  tab_strip_->SetVisible(true);
+  tab_strip_->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_;
+  views::View* switcher_button = window_switcher_button_;
   if (switcher_button) {
     if (browser()->profile()->HasOffTheRecordProfile() &&
         chrome::FindBrowserWithProfile(
             browser()->profile()->GetOriginalProfile(),
             browser()->host_desktop_type()) != NULL) {
       switcher_button->SetVisible(true);
-      int width = browser_view_->width();
+      int width = browser_view->width();
       gfx::Size ps = switcher_button->GetPreferredSize();
       if (width > ps.width()) {
         switcher_button->SetBounds(width - ps.width() - kWindowSwitcherOffsetX,
                                    0,
                                    ps.width(),
                                    ps.height());
       }
     } else {
       // We hide the button if the incognito profile is not alive.
       // Note that Layout() is not called to all browser windows automatically
       // when a profile goes away but we rely in the metro_driver.dll to call
       // ::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);
+  bool toolbar_visible = delegate_->IsToolbarVisible();
   int y = top;
-  y -= (toolbar_visible && browser_view_->IsTabStripVisible()) ?
+  y -= (toolbar_visible && delegate_->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) {
-  web_contents_modal_dialog_top_y_ =
-      top + browser_view_->y() - kConstrainedWindowOverlap;
   if (bookmark_bar_) {
     // If we're showing the Bookmark bar in detached style, then we
     // need to show any Info bar _above_ the Bookmark bar, since the
     // Bookmark bar is styled to look like it's part of the page.
     if (bookmark_bar_->IsDetached())
       return LayoutBookmarkBar(LayoutInfoBar(top));
     // Otherwise, Bookmark bar first, Info bar second.
-    top = std::max(browser_view_->toolbar_->bounds().bottom(),
-                   LayoutBookmarkBar(top));
+    top = std::max(toolbar_->bounds().bottom(), LayoutBookmarkBar(top));
   }
   return LayoutInfoBar(top);
 }
 
 int BrowserViewLayout::LayoutBookmarkBar(int top) {
   int y = top;
-  if (!browser_view_->IsBookmarkBarVisible()) {
+  if (!delegate_->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,
                                  vertical_layout_rect_.width(),
                                  bookmark_bar_height);
   return y + bookmark_bar_height;
 }
 
 int BrowserViewLayout::LayoutInfoBar(int top) {
   // In immersive fullscreen, the infobar always starts near the top of the
   // screen, just under the "light bar" rectangular stripes.
-  if (browser_view_->immersive_mode_controller_->IsEnabled()) {
-    top = browser_view_->immersive_mode_controller_->ShouldHideTabIndicators() ?
-        browser_view_->y() :
-        browser_view_->y() + TabStrip::GetImmersiveHeight();
+  if (immersive_mode_controller_->IsEnabled()) {
+    top = immersive_mode_controller_->ShouldHideTabIndicators()
+              ? browser_view_->y()
+              : browser_view_->y() + TabStrip::GetImmersiveHeight();
   }
-  InfoBarContainerView* infobar_container = browser_view_->infobar_container_;
-  // Raise the |infobar_container| by its vertical overlap.
-  infobar_container->SetVisible(InfobarVisible());
+  // Raise the |infobar_container_| by its vertical overlap.
+  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);
+  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::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));
   contents_split_->SetBoundsRect(contents_split_bounds);
 }
 
 void BrowserViewLayout::LayoutOverlayContainer() {
   bool full_height = overlay_container_->IsOverlayFullHeight();
   int preferred_height = 0;
   if (!full_height)
     preferred_height = overlay_container_->GetPreferredSize().height();
   overlay_container_->SetVisible(full_height || preferred_height > 0);
   if (!overlay_container_->visible())
     return;
-  ToolbarView* toolbar = browser_view_->toolbar_;
-  gfx::Point bottom_edge(0, toolbar->bounds().bottom());
+  gfx::Point bottom_edge(0, toolbar_->bounds().bottom());
   views::View::ConvertPointToTarget(
-      toolbar->parent(), browser_view_, &bottom_edge);
+      toolbar_->parent(), browser_view_, &bottom_edge);
   // Overlaps with the toolbar like the attached bookmark bar would, so as to
   // completely obscure the attached bookmark bar if it were visible.
   bottom_edge.Offset(0,
                      -(views::NonClientFrameView::kClientEdgeThickness +
                        BookmarkBarView::kToolbarAttachedBookmarkBarOverlap));
   gfx::Rect rect(vertical_layout_rect_);
   rect.Inset(0, bottom_edge.y(), 0, 0);
   if (!full_height && preferred_height < rect.height())
     rect.set_height(preferred_height);
   overlay_container_->SetBoundsRect(rect);
@@ skipping 16 matching lines @@
   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())
+      immersive_mode_controller_->IsRevealed())
     return GetTopMarginForImmersiveInstant();
 
   // Usually we only use a margin if there's a detached bookmarks bar.
   return GetContentsOffsetForBookmarkBar();
 }
 
 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_,
+  gfx::Point bottom_edge(0, top_container_->height());
+  views::View::ConvertPointToTarget(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 (overlay_container_->visible())
     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())) {
+  if (delegate_->DownloadShelfNeedsLayout()) {
     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 {
   // Cast to a views::View to access GetPreferredSize().
   views::View* infobar_container = 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);
 }