Factor out the layout code from OpaqueBrowserFrameView for testing.

chrome/browser/ui/views/frame/opaque_browser_frame_view.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/opaque_browser_frame_view.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/themes/theme_properties.h"
 #include "chrome/browser/ui/views/avatar_label.h"
 #include "chrome/browser/ui/views/avatar_menu_button.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/opaque_browser_frame_view_layout.h"
 #include "chrome/browser/ui/views/tab_icon_view.h"
 #include "chrome/browser/ui/views/tabs/tab_strip.h"
 #include "chrome/browser/ui/views/toolbar_view.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "grit/ui_resources.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/path.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/image_view.h"
 #include "ui/views/controls/label.h"
 #include "ui/views/layout/layout_constants.h"
 #include "ui/views/widget/root_view.h"
 #include "ui/views/window/frame_background.h"
 #include "ui/views/window/window_shape.h"
 
-#if defined(OS_WIN)
-#include "win8/util/win8_util.h"
-#endif  // OS_WIN
-
 using content::WebContents;
 
 namespace {
 
-// The frame border is only visible in restored mode and is hardcoded to 4 px on
-// each side regardless of the system window border size.
-const int kFrameBorderThickness = 4;
-// Besides the frame border, there's another 9 px of empty space atop the
-// window in restored mode, to use to drag the window around.
-const int kNonClientRestoredExtraThickness = 9;
 // While resize areas on Windows are normally the same size as the window
 // borders, our top area is shrunk by 1 px to make it easier to move the window
 // around with our thinner top grabbable strip.  (Incidentally, our side and
 // bottom resize areas don't match the frame border thickness either -- they
 // span the whole nonclient area, so there's no "dead zone" for the mouse.)
 const int kTopResizeAdjust = 1;
+
 // In the window corners, the resize areas don't actually expand bigger, but the
 // 16 px at the end of each edge triggers diagonal resizing.
 const int kResizeAreaCornerSize = 16;
-// The titlebar never shrinks too short to show the caption button plus some
-// padding below it.
-const int kCaptionButtonHeightWithPadding = 19;
+
 // The content left/right images have a shadow built into them.
 const int kContentEdgeShadowThickness = 2;
-// The titlebar has a 2 px 3D edge along the top and bottom.
-const int kTitlebarTopAndBottomEdgeThickness = 2;
-// The icon is inset 2 px from the left frame border.
-const int kIconLeftSpacing = 2;
+
 // The icon never shrinks below 16 px on a side.
 const int kIconMinimumSize = 16;
-// There is a 4 px gap between the icon and the title text.
-const int kIconTitleSpacing = 4;
-// There is a 5 px gap between the title text and the caption buttons.
-const int kTitleLogoSpacing = 5;
-// The avatar ends 2 px above the bottom of the tabstrip (which, given the
-// way the tabstrip draws its bottom edge, will appear like a 1 px gap to the
-// user).
-const int kAvatarBottomSpacing = 2;
-// Space between the frame border and the left edge of the avatar.
-const int kAvatarLeftSpacing = 2;
-// Space between the right edge of the avatar and the tabstrip.
-const int kAvatarRightSpacing = -2;
+
 // The top 3 px of the tabstrip is shadow; in maximized mode we push this off
 // the top of the screen so the tabs appear flush against the screen edge.
 const int kTabstripTopShadowThickness = 3;
-// In restored mode, the New Tab button isn't at the same height as the caption
-// buttons, but the space will look cluttered if it actually slides under them,
-// so we stop it when the gap between the two is down to 5 px.
-const int kNewTabCaptionRestoredSpacing = 5;
-// In maximized mode, where the New Tab button and the caption buttons are at
-// similar vertical coordinates, we need to reserve a larger, 16 px gap to avoid
-// looking too cluttered.
-const int kNewTabCaptionMaximizedSpacing = 16;
-// How far to indent the tabstrip from the left side of the screen when there
-// is no avatar icon.
-const int kTabStripIndent = -6;
 
 // Converts |bounds| from |src|'s coordinate system to |dst|, and checks if
 // |pt| is contained within.
 bool ConvertedContainsCheck(gfx::Rect bounds, const views::View* src,
                             const views::View* dst, const gfx::Point& pt) {
   DCHECK(src);
   DCHECK(dst);
   gfx::Point origin(bounds.origin());
   views::View::ConvertPointToTarget(src, dst, &origin);
   bounds.set_origin(origin);
   return bounds.Contains(pt);
 }
 
-bool ShouldAddDefaultCaptionButtons() {
-#if defined(OS_WIN)
-  return !win8::IsSingleWindowMetroMode();
-#endif  // OS_WIN
-  return true;
-}
-
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, public:
 
 OpaqueBrowserFrameView::OpaqueBrowserFrameView(BrowserFrame* frame,
                                                BrowserView* browser_view)
     : BrowserNonClientFrameView(frame, browser_view),
+      layout_(new OpaqueBrowserFrameViewLayout(this)),
       minimize_button_(NULL),
       maximize_button_(NULL),
       restore_button_(NULL),
       close_button_(NULL),
       window_icon_(NULL),
       window_title_(NULL),
       frame_background_(new views::FrameBackground()) {
-  if (ShouldAddDefaultCaptionButtons()) {
+  SetLayoutManager(layout_);
+
+  if (OpaqueBrowserFrameViewLayout::ShouldAddDefaultCaptionButtons()) {
     minimize_button_ = InitWindowCaptionButton(IDR_MINIMIZE,
                                                IDR_MINIMIZE_H,
                                                IDR_MINIMIZE_P,
                                                IDR_MINIMIZE_BUTTON_MASK,
-                                               IDS_ACCNAME_MINIMIZE);
+                                               IDS_ACCNAME_MINIMIZE,
+                                               VIEW_ID_MINIMIZE_BUTTON);
     maximize_button_ = InitWindowCaptionButton(IDR_MAXIMIZE,
                                                IDR_MAXIMIZE_H,
                                                IDR_MAXIMIZE_P,
                                                IDR_MAXIMIZE_BUTTON_MASK,
-                                               IDS_ACCNAME_MAXIMIZE);
+                                               IDS_ACCNAME_MAXIMIZE,
+                                               VIEW_ID_MAXIMIZE_BUTTON);
     restore_button_ = InitWindowCaptionButton(IDR_RESTORE,
                                               IDR_RESTORE_H,
                                               IDR_RESTORE_P,
                                               IDR_RESTORE_BUTTON_MASK,
-                                              IDS_ACCNAME_RESTORE);
+                                              IDS_ACCNAME_RESTORE,
+                                              VIEW_ID_RESTORE_BUTTON);
     close_button_ = InitWindowCaptionButton(IDR_CLOSE,
                                             IDR_CLOSE_H,
                                             IDR_CLOSE_P,
                                             IDR_CLOSE_BUTTON_MASK,
-                                            IDS_ACCNAME_CLOSE);
+                                            IDS_ACCNAME_CLOSE,
+                                            VIEW_ID_CLOSE_BUTTON);
   }
 
   // Initializing the TabIconView is expensive, so only do it if we need to.
   if (browser_view->ShouldShowWindowIcon()) {
     window_icon_ = new TabIconView(this);
     window_icon_->set_is_light(true);
+    window_icon_->set_id(VIEW_ID_WINDOW_ICON);
     AddChildView(window_icon_);
     window_icon_->Update();
   }
 
   window_title_ = new views::Label(browser_view->GetWindowTitle(),
                                    BrowserFrame::GetTitleFont());
   window_title_->SetVisible(browser_view->ShouldShowWindowTitle());
   window_title_->SetEnabledColor(SK_ColorWHITE);
   // TODO(msw): Use a transparent background color as a workaround to use the
   // gfx::Canvas::NO_SUBPIXEL_RENDERING flag and avoid some visual artifacts.
   window_title_->SetBackgroundColor(0x00000000);
   window_title_->SetHorizontalAlignment(gfx::ALIGN_LEFT);
+  window_title_->set_id(VIEW_ID_WINDOW_TITLE);
   AddChildView(window_title_);
 
   UpdateAvatarInfo();
   if (!browser_view->IsOffTheRecord()) {
     registrar_.Add(this, chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED,
                    content::NotificationService::AllSources());
   }
 }
 
 OpaqueBrowserFrameView::~OpaqueBrowserFrameView() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// OpaqueBrowserFrameView, protected:
-
-int OpaqueBrowserFrameView::GetReservedHeight() const {
-  return 0;
-}
-
-gfx::Rect OpaqueBrowserFrameView::GetBoundsForReservedArea() const {
-  gfx::Rect client_view_bounds = CalculateClientAreaBounds(width(), height());
-  return gfx::Rect(
-      client_view_bounds.x(),
-      client_view_bounds.y() + client_view_bounds.height(),
-      client_view_bounds.width(),
-      GetReservedHeight());
-}
-
-int OpaqueBrowserFrameView::NonClientTopBorderHeight(
-    bool restored) const {
-  views::WidgetDelegate* delegate = frame()->widget_delegate();
-  // |delegate| may be NULL if called from callback of InputMethodChanged while
-  // a window is being destroyed.
-  // See more discussion at http://crosbug.com/8958
-  if (delegate && delegate->ShouldShowWindowTitle()) {
-    return std::max(FrameBorderThickness(restored) + IconSize(),
-        CaptionButtonY(restored) + kCaptionButtonHeightWithPadding) +
-        TitlebarBottomThickness(restored);
-  }
-
-  return FrameBorderThickness(restored) -
-      ((browser_view()->IsTabStripVisible() &&
-          !restored && !frame()->ShouldLeaveOffsetNearTopBorder())
-              ? kTabstripTopShadowThickness : 0);
-}
-
-///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, BrowserNonClientFrameView implementation:
 
 gfx::Rect OpaqueBrowserFrameView::GetBoundsForTabStrip(
     views::View* tabstrip) const {
   if (!tabstrip)
     return gfx::Rect();
 
-  gfx::Rect bounds = GetBoundsForTabStripAndAvatarArea(tabstrip);
-  int space_left_of_tabstrip = kTabStripIndent;
-  if (browser_view()->ShouldShowAvatar()) {
-    if (avatar_label() && avatar_label()->bounds().width()) {
-      // Space between the right edge of the avatar label and the tabstrip.
-      const int kAvatarLabelRightSpacing = -10;
-      space_left_of_tabstrip =
-          avatar_label()->bounds().right() + kAvatarLabelRightSpacing;
-    } else {
-      space_left_of_tabstrip =
-          kAvatarLeftSpacing + avatar_bounds_.width() + kAvatarRightSpacing;
-    }
-  }
-  bounds.Inset(space_left_of_tabstrip, 0, 0, 0);
-  return bounds;
+  return layout_->GetBoundsForTabStrip(tabstrip->GetPreferredSize(), width());
 }
 
 BrowserNonClientFrameView::TabStripInsets
 OpaqueBrowserFrameView::GetTabStripInsets(bool restored) const {
-  int top = NonClientTopBorderHeight(restored) + ((!restored &&
-      (!frame()->ShouldLeaveOffsetNearTopBorder() ||
-      frame()->IsFullscreen())) ?
-      0 : kNonClientRestoredExtraThickness);
   // TODO: include OTR and caption.
-  return TabStripInsets(top, 0, 0);
+  return TabStripInsets(layout_->GetTabStripInsetsTop(restored), 0, 0);
 }
 
 int OpaqueBrowserFrameView::GetThemeBackgroundXInset() const {
   return 0;
 }
 
 void OpaqueBrowserFrameView::UpdateThrobber(bool running) {
   if (window_icon_)
     window_icon_->Update();
 }
 
 gfx::Size OpaqueBrowserFrameView::GetMinimumSize() {
-  gfx::Size min_size(browser_view()->GetMinimumSize());
-  int border_thickness = NonClientBorderThickness();
-  min_size.Enlarge(2 * border_thickness,
-                   NonClientTopBorderHeight(false) + border_thickness);
-
-  views::WidgetDelegate* delegate = frame()->widget_delegate();
-  int min_titlebar_width = (2 * FrameBorderThickness(false)) +
-      kIconLeftSpacing +
-      (delegate && delegate->ShouldShowWindowIcon() ?
-       (IconSize() + kTitleLogoSpacing) : 0);
-#if !defined(OS_CHROMEOS)
-  if (ShouldAddDefaultCaptionButtons()) {
-    min_titlebar_width +=
-        minimize_button_->GetMinimumSize().width() +
-        restore_button_->GetMinimumSize().width() +
-        close_button_->GetMinimumSize().width();
-  }
-#endif
-  min_size.set_width(std::max(min_size.width(), min_titlebar_width));
-
-  // Ensure that the minimum width is enough to hold a minimum width tab strip
-  // and avatar icon at their usual insets.
-  if (browser_view()->IsTabStripVisible()) {
-    TabStrip* tabstrip = browser_view()->tabstrip();
-    const int min_tabstrip_width = tabstrip->GetMinimumSize().width();
-    const int min_tabstrip_area_width =
-        width() - GetBoundsForTabStripAndAvatarArea(tabstrip).width() +
-        min_tabstrip_width + browser_view()->GetOTRAvatarIcon().width() +
-        kAvatarLeftSpacing + kAvatarRightSpacing;
-    min_size.set_width(std::max(min_size.width(), min_tabstrip_area_width));
-  }
-
-  return min_size;
+  return layout_->GetMinimumSize(width());
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, views::NonClientFrameView implementation:
 
 gfx::Rect OpaqueBrowserFrameView::GetBoundsForClientView() const {
-  return client_view_bounds_;
+  return layout_->client_view_bounds();
 }
 
 gfx::Rect OpaqueBrowserFrameView::GetWindowBoundsForClientBounds(
     const gfx::Rect& client_bounds) const {
-  int top_height = NonClientTopBorderHeight(false);
-  int border_thickness = NonClientBorderThickness();
-  return gfx::Rect(std::max(0, client_bounds.x() - border_thickness),
-                   std::max(0, client_bounds.y() - top_height),
-                   client_bounds.width() + (2 * border_thickness),
-                   client_bounds.height() + top_height + border_thickness);
+  return layout_->GetWindowBoundsForClientBounds(client_bounds);
 }
 
 int OpaqueBrowserFrameView::NonClientHitTest(const gfx::Point& point) {
   if (!bounds().Contains(point))
     return HTNOWHERE;
 
   // See if the point is within the avatar menu button or within the avatar
   // label.
   if ((avatar_button() &&
        avatar_button()->GetMirroredBounds().Contains(point)) ||
@@ skipping 46 matching lines @@
                                            gfx::Path* window_mask) {
   DCHECK(window_mask);
 
   if (frame()->IsMaximized() || frame()->IsFullscreen())
     return;
 
   views::GetDefaultWindowMask(size, window_mask);
 }
 
 void OpaqueBrowserFrameView::ResetWindowControls() {
-  if (!ShouldAddDefaultCaptionButtons())
+  if (!OpaqueBrowserFrameViewLayout::ShouldAddDefaultCaptionButtons())
     return;
   restore_button_->SetState(views::CustomButton::STATE_NORMAL);
   minimize_button_->SetState(views::CustomButton::STATE_NORMAL);
   maximize_button_->SetState(views::CustomButton::STATE_NORMAL);
   // The close button isn't affected by this constraint.
 }
 
 void OpaqueBrowserFrameView::UpdateWindowIcon() {
   window_icon_->SchedulePaint();
 }
@@ skipping 22 matching lines @@
    * alpha-blend either (since the Windows text APIs don't really do this).
    * So we'd need to sample the background color at the right location and
    * synthesize a good shadow color. */
 
   if (browser_view()->IsToolbarVisible())
     PaintToolbarBackground(canvas);
   if (!frame()->IsMaximized())
     PaintRestoredClientEdge(canvas);
 }
 
-void OpaqueBrowserFrameView::Layout() {
-  LayoutWindowControls();
-  LayoutTitleBar();
-  LayoutAvatar();
-  client_view_bounds_ = CalculateClientAreaBounds(width(), height());
-}
-
 bool OpaqueBrowserFrameView::HitTestRect(const gfx::Rect& rect) const {
   if (!views::View::HitTestRect(rect)) {
     // |rect| is outside OpaqueBrowserFrameView's bounds.
     return false;
   }
 
   // If the rect is outside the bounds of the client area, claim it.
   // TODO(tdanderson): Implement View::ConvertRectToTarget().
   gfx::Point rect_in_client_view_coords_origin(rect.origin());
   View::ConvertPointToTarget(this, frame()->client_view(),
@@ skipping 102 matching lines @@
     case chrome::NOTIFICATION_PROFILE_CACHED_INFO_CHANGED:
       UpdateAvatarInfo();
       break;
     default:
       NOTREACHED() << "Got a notification we didn't register for!";
       break;
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
+// OpaqueBrowserFrameView, OpaqueBrowserFrameViewLayoutDelegate implementation:
+
+bool OpaqueBrowserFrameView::ShouldShowWindowIcon() const {
+  views::WidgetDelegate* delegate = frame()->widget_delegate();
+  return delegate && delegate->ShouldShowWindowIcon();
+}
+
+bool OpaqueBrowserFrameView::ShouldShowWindowTitle() const {
+  // |delegate| may be NULL if called from callback of InputMethodChanged while
+  // a window is being destroyed.
+  // See more discussion at http://crosbug.com/8958
+  views::WidgetDelegate* delegate = frame()->widget_delegate();
+  return delegate && delegate->ShouldShowWindowTitle();
+}
+
+string16 OpaqueBrowserFrameView::GetWindowTitle() const {
+  return frame()->widget_delegate()->GetWindowTitle();
+}
+
+int OpaqueBrowserFrameView::GetIconSize() const {
+#if defined(OS_WIN)
+  // This metric scales up if either the titlebar height or the titlebar font
+  // size are increased.
+  return GetSystemMetrics(SM_CYSMICON);
+#else
+  return std::max(BrowserFrame::GetTitleFont().GetHeight(), kIconMinimumSize);
+#endif
+}
+
+bool OpaqueBrowserFrameView::ShouldLeaveOffsetNearTopBorder() const {
+  return frame()->ShouldLeaveOffsetNearTopBorder();
+}
+
+gfx::Size OpaqueBrowserFrameView::GetBrowserViewMinimumSize() const {
+  return browser_view()->GetMinimumSize();
+}
+
+bool OpaqueBrowserFrameView::ShouldShowAvatar() const {
+  return browser_view()->ShouldShowAvatar();
+}
+
+gfx::ImageSkia OpaqueBrowserFrameView::GetOTRAvatarIcon() const {
+  return browser_view()->GetOTRAvatarIcon();
+}
+
+bool OpaqueBrowserFrameView::IsMaximized() const {
+  return frame()->IsMaximized();
+}
+
+bool OpaqueBrowserFrameView::IsMinimized() const {
+  return frame()->IsMinimized();
+}
+
+bool OpaqueBrowserFrameView::IsFullscreen() const {
+  return frame()->IsFullscreen();
+}
+
+bool OpaqueBrowserFrameView::IsTabStripVisible() const {
+  return browser_view()->IsTabStripVisible();
+}
+
+int OpaqueBrowserFrameView::GetTabStripHeight() const {
+  return browser_view()->GetTabStripHeight();
+}
+
+int OpaqueBrowserFrameView::GetAdditionalReservedSpaceInTabStrip() const {
+  // We don't have the sysmenu buttons in Windows 8 metro mode. However there
+  // are buttons like the window switcher which are drawn in the non client
+  // are in the BrowserView. We need to ensure that the tab strip does not
+  // draw on the window switcher button.
+  views::View* button = browser_view()->window_switcher_button();
+  return button ? button->width() : 0;
+}
+
+gfx::Size OpaqueBrowserFrameView::GetTabstripPreferredSize() const {
+  gfx::Size s = browser_view()->tabstrip()->GetPreferredSize();
+  return s;
+}
+
+///////////////////////////////////////////////////////////////////////////////
 // OpaqueBrowserFrameView, private:
 
 views::ImageButton* OpaqueBrowserFrameView::InitWindowCaptionButton(
     int normal_image_id,
     int hot_image_id,
     int pushed_image_id,
     int mask_image_id,
-    int accessibility_string_id) {
+    int accessibility_string_id,
+    ViewID view_id) {
   views::ImageButton* button = new views::ImageButton(this);
   ui::ThemeProvider* tp = frame()->GetThemeProvider();
   button->SetImage(views::CustomButton::STATE_NORMAL,
                    tp->GetImageSkiaNamed(normal_image_id));
   button->SetImage(views::CustomButton::STATE_HOVERED,
                    tp->GetImageSkiaNamed(hot_image_id));
   button->SetImage(views::CustomButton::STATE_PRESSED,
                    tp->GetImageSkiaNamed(pushed_image_id));
   if (browser_view()->IsBrowserTypeNormal()) {
     button->SetBackground(
         tp->GetColor(ThemeProperties::COLOR_BUTTON_BACKGROUND),
         tp->GetImageSkiaNamed(IDR_THEME_WINDOW_CONTROL_BACKGROUND),
         tp->GetImageSkiaNamed(mask_image_id));
   }
   button->SetAccessibleName(
       l10n_util::GetStringUTF16(accessibility_string_id));
+  button->set_id(view_id);
   AddChildView(button);
   return button;
 }
 
 int OpaqueBrowserFrameView::FrameBorderThickness(bool restored) const {
-  return (!restored && (frame()->IsMaximized() || frame()->IsFullscreen())) ?
-      0 : kFrameBorderThickness;
+  return layout_->FrameBorderThickness(restored);
 }
 
 int OpaqueBrowserFrameView::TopResizeHeight() const {
   return FrameBorderThickness(false) - kTopResizeAdjust;
 }
 
 int OpaqueBrowserFrameView::NonClientBorderThickness() const {
-  // When we fill the screen, we don't show a client edge.
-  return FrameBorderThickness(false) +
-      ((frame()->IsMaximized() || frame()->IsFullscreen()) ?
-       0 : kClientEdgeThickness);
-}
-
-int OpaqueBrowserFrameView::CaptionButtonY(bool restored) const {
-  // Maximized buttons start at window top so that even if their images aren't
-  // drawn flush with the screen edge, they still obey Fitts' Law.
-  return (!restored && frame()->IsMaximized()) ?
-      FrameBorderThickness(false) : kFrameShadowThickness;
-}
-
-int OpaqueBrowserFrameView::TitlebarBottomThickness(bool restored) const {
-  return kTitlebarTopAndBottomEdgeThickness +
-      ((!restored && frame()->IsMaximized()) ? 0 : kClientEdgeThickness);
-}
-
-int OpaqueBrowserFrameView::IconSize() const {
-#if defined(OS_WIN)
-  // This metric scales up if either the titlebar height or the titlebar font
-  // size are increased.
-  return GetSystemMetrics(SM_CYSMICON);
-#else
-  return std::max(BrowserFrame::GetTitleFont().GetHeight(), kIconMinimumSize);
-#endif
+  return layout_->NonClientBorderThickness();
 }
 
 gfx::Rect OpaqueBrowserFrameView::IconBounds() const {
-  int size = IconSize();
-  int frame_thickness = FrameBorderThickness(false);
-  int y;
-  views::WidgetDelegate* delegate = frame()->widget_delegate();
-  if (delegate && (delegate->ShouldShowWindowIcon() ||
-                   delegate->ShouldShowWindowTitle())) {
-    // Our frame border has a different "3D look" than Windows'.  Theirs has a
-    // more complex gradient on the top that they push their icon/title below;
-    // then the maximized window cuts this off and the icon/title are centered
-    // in the remaining space.  Because the apparent shape of our border is
-    // simpler, using the same positioning makes things look slightly uncentered
-    // with restored windows, so when the window is restored, instead of
-    // calculating the remaining space from below the frame border, we calculate
-    // from below the 3D edge.
-    int unavailable_px_at_top = frame()->IsMaximized() ?
-        frame_thickness : kTitlebarTopAndBottomEdgeThickness;
-    // When the icon is shorter than the minimum space we reserve for the
-    // caption button, we vertically center it.  We want to bias rounding to put
-    // extra space above the icon, since the 3D edge (+ client edge, for
-    // restored windows) below looks (to the eye) more like additional space
-    // than does the 3D edge (or nothing at all, for maximized windows) above;
-    // hence the +1.
-    y = unavailable_px_at_top + (NonClientTopBorderHeight(false) -
-        unavailable_px_at_top - size - TitlebarBottomThickness(false) + 1) / 2;
-  } else {
-    // For "browser mode" windows, we use the native positioning, which is just
-    // below the top frame border.
-    y = frame_thickness;
-  }
-  return gfx::Rect(frame_thickness + kIconLeftSpacing, y, size, size);
-}
-
-gfx::Rect OpaqueBrowserFrameView::GetBoundsForTabStripAndAvatarArea(
-    views::View* tabstrip) const {
-  int available_width = width();
-  if (minimize_button_) {
-    available_width = minimize_button_->x();
-  } else if (browser_view()->window_switcher_button()) {
-    // We don't have the sysmenu buttons in Windows 8 metro mode. However there
-    // are buttons like the window switcher which are drawn in the non client
-    // are in the BrowserView. We need to ensure that the tab strip does not
-    // draw on the window switcher button.
-    available_width -= browser_view()->window_switcher_button()->width();
-  }
-  const int caption_spacing = frame()->IsMaximized() ?
-      kNewTabCaptionMaximizedSpacing : kNewTabCaptionRestoredSpacing;
-  const int tabstrip_x = NonClientBorderThickness();
-  const int tabstrip_width = available_width - tabstrip_x - caption_spacing;
-  return gfx::Rect(tabstrip_x, GetTabStripInsets(false).top,
-                   std::max(0, tabstrip_width),
-                   tabstrip->GetPreferredSize().height());
+  return layout_->IconBounds();
 }
 
 void OpaqueBrowserFrameView::PaintRestoredFrameBorder(gfx::Canvas* canvas) {
   frame_background_->set_frame_color(GetFrameColor());
   frame_background_->set_theme_image(GetFrameImage());
   frame_background_->set_theme_overlay_image(GetFrameOverlayImage());
   frame_background_->set_top_area_height(GetTopAreaHeight());
 
   ui::ThemeProvider* tp = GetThemeProvider();
   frame_background_->SetSideImages(
@@ skipping 148 matching lines @@
                 kClientEdgeThickness),
       ThemeProperties::GetDefaultColor(
           ThemeProperties::COLOR_TOOLBAR_SEPARATOR));
 }
 
 void OpaqueBrowserFrameView::PaintRestoredClientEdge(gfx::Canvas* canvas) {
   ui::ThemeProvider* tp = GetThemeProvider();
   int client_area_top = frame()->client_view()->y();
   int image_top = client_area_top;
 
-  gfx::Rect client_area_bounds = CalculateClientAreaBounds(width(), height());
+  gfx::Rect client_area_bounds =
+      layout_->CalculateClientAreaBounds(width(), height());
   SkColor toolbar_color = tp->GetColor(ThemeProperties::COLOR_TOOLBAR);
 
   if (browser_view()->IsToolbarVisible()) {
     // The client edge images always start below the toolbar corner images.  The
     // client edge filled rects start there or at the bottom of the toolbar,
     // whichever is shorter.
     gfx::Rect toolbar_bounds(browser_view()->GetToolbarBounds());
     image_top += toolbar_bounds.y() +
         tp->GetImageSkiaNamed(IDR_CONTENT_TOP_LEFT_CORNER)->height();
     client_area_top = std::min(image_top,
@@ skipping 123 matching lines @@
 
 int OpaqueBrowserFrameView::GetTopAreaHeight() const {
   gfx::ImageSkia* frame_image = GetFrameImage();
   int top_area_height = frame_image->height();
   if (browser_view()->IsTabStripVisible()) {
     top_area_height = std::max(top_area_height,
       GetBoundsForTabStrip(browser_view()->tabstrip()).bottom());
   }
   return top_area_height;
 }
-
-void OpaqueBrowserFrameView::LayoutWindowControls() {
-  if (!ShouldAddDefaultCaptionButtons())
-    return;
-  bool is_maximized = frame()->IsMaximized();
-  close_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
-                                   views::ImageButton::ALIGN_BOTTOM);
-  int caption_y = CaptionButtonY(false);
-  // There should always be the same number of non-shadow pixels visible to the
-  // side of the caption buttons.  In maximized mode we extend the rightmost
-  // button to the screen corner to obey Fitts' Law.
-  int right_extra_width = is_maximized ?
-      (kFrameBorderThickness - kFrameShadowThickness) : 0;
-  gfx::Size close_button_size = close_button_->GetPreferredSize();
-  close_button_->SetBounds(width() - FrameBorderThickness(false) -
-      right_extra_width - close_button_size.width(), caption_y,
-      close_button_size.width() + right_extra_width,
-      close_button_size.height());
-
-  // When the window is restored, we show a maximized button; otherwise, we show
-  // a restore button.
-  bool is_restored = !is_maximized && !frame()->IsMinimized();
-  views::ImageButton* invisible_button = is_restored ?
-      restore_button_ : maximize_button_;
-  invisible_button->SetVisible(false);
-
-  views::ImageButton* visible_button = is_restored ?
-      maximize_button_ : restore_button_;
-  visible_button->SetVisible(true);
-  visible_button->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
-                                    views::ImageButton::ALIGN_BOTTOM);
-  gfx::Size visible_button_size = visible_button->GetPreferredSize();
-  visible_button->SetBounds(close_button_->x() - visible_button_size.width(),
-                            caption_y, visible_button_size.width(),
-                            visible_button_size.height());
-
-  minimize_button_->SetVisible(true);
-  minimize_button_->SetImageAlignment(views::ImageButton::ALIGN_LEFT,
-                                      views::ImageButton::ALIGN_BOTTOM);
-  gfx::Size minimize_button_size = minimize_button_->GetPreferredSize();
-  minimize_button_->SetBounds(
-      visible_button->x() - minimize_button_size.width(), caption_y,
-      minimize_button_size.width(),
-      minimize_button_size.height());
-}
-
-void OpaqueBrowserFrameView::LayoutTitleBar() {
-  const views::WidgetDelegate* delegate = frame()->widget_delegate();
-  if (delegate) {
-    gfx::Rect icon_bounds(IconBounds());
-    if (delegate->ShouldShowWindowIcon())
-      window_icon_->SetBoundsRect(icon_bounds);
-
-    window_title_->SetVisible(delegate->ShouldShowWindowTitle());
-    if (delegate->ShouldShowWindowTitle()) {
-      window_title_->SetText(delegate->GetWindowTitle());
-      const int title_x = delegate->ShouldShowWindowIcon() ?
-          icon_bounds.right() + kIconTitleSpacing : icon_bounds.x();
-      window_title_->SetBounds(title_x, icon_bounds.y(),
-          std::max(0, minimize_button_->x() - kTitleLogoSpacing - title_x),
-          icon_bounds.height());
-    }
-  }
-}
-
-void OpaqueBrowserFrameView::LayoutAvatar() {
-  // Even though the avatar is used for both incognito and profiles we always
-  // use the incognito icon to layout the avatar button. The profile icon
-  // can be customized so we can't depend on its size to perform layout.
-  gfx::ImageSkia incognito_icon = browser_view()->GetOTRAvatarIcon();
-
-  int avatar_bottom = GetTabStripInsets(false).top +
-      browser_view()->GetTabStripHeight() - kAvatarBottomSpacing;
-  int avatar_restored_y = avatar_bottom - incognito_icon.height();
-  int avatar_y = frame()->IsMaximized() ?
-      (NonClientTopBorderHeight(false) + kTabstripTopShadowThickness) :
-      avatar_restored_y;
-  avatar_bounds_.SetRect(NonClientBorderThickness() + kAvatarLeftSpacing,
-      avatar_y, incognito_icon.width(),
-      browser_view()->ShouldShowAvatar() ? (avatar_bottom - avatar_y) : 0);
-  if (avatar_button())
-    avatar_button()->SetBoundsRect(avatar_bounds_);
-
-  if (avatar_label()) {
-    // Space between the bottom of the avatar and the bottom of the avatar
-    // label.
-    const int kAvatarLabelBottomSpacing = 3;
-    // Space between the frame border and the left edge of the avatar label.
-    const int kAvatarLabelLeftSpacing = -1;
-    gfx::Size label_size = avatar_label()->GetPreferredSize();
-    gfx::Rect label_bounds(
-        FrameBorderThickness(false) + kAvatarLabelLeftSpacing,
-        avatar_bottom - kAvatarLabelBottomSpacing - label_size.height(),
-        label_size.width(),
-        browser_view()->ShouldShowAvatar() ? label_size.height() : 0);
-    avatar_label()->SetBoundsRect(label_bounds);
-  }
-}
-
-gfx::Rect OpaqueBrowserFrameView::CalculateClientAreaBounds(int width,
-                                                            int height) const {
-  int top_height = NonClientTopBorderHeight(false);
-  int border_thickness = NonClientBorderThickness();
-  return gfx::Rect(border_thickness, top_height,
-                   std::max(0, width - (2 * border_thickness)),
-                   std::max(0, height - GetReservedHeight() -
-                       top_height - border_thickness));
-}