Makes the min window size include the OTR image and caption buttons on

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"
@@ skipping 212 matching lines @@
     return gfx::Rect();
 
   gfx::Rect bounds = GetBoundsForTabStripAndAvatarArea(tabstrip);
   const int space_left_of_tabstrip = browser_view()->ShouldShowAvatar() ?
       (kAvatarLeftSpacing + avatar_bounds_.width() + kAvatarRightSpacing) :
       kTabStripIndent;
   bounds.Inset(space_left_of_tabstrip, 0, 0, 0);
   return bounds;
 }
 
-int OpaqueBrowserFrameView::GetHorizontalTabStripVerticalOffset(
-    bool restored) const {
-  return NonClientTopBorderHeight(restored) + ((!restored &&
+BrowserNonClientFrameView::TabStripInsets
+OpaqueBrowserFrameView::GetTabStripInsets(bool restored) const {
+  int top = NonClientTopBorderHeight(restored) + ((!restored &&
       (frame()->IsMaximized() ||
       frame()->IsFullscreen())) ?
       0 : kNonClientRestoredExtraThickness);
+  // TODO: include OTR and caption.
+  return TabStripInsets(top, 0, 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();
@@ skipping 328 matching lines @@
 }
 
 gfx::Rect OpaqueBrowserFrameView::GetBoundsForTabStripAndAvatarArea(
     views::View* tabstrip) const {
   const int available_width =
       minimize_button_ ? minimize_button_->x() : 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, GetHorizontalTabStripVerticalOffset(false),
+  return gfx::Rect(tabstrip_x, GetTabStripInsets(false).top,
                    std::max(0, tabstrip_width),
                    tabstrip->GetPreferredSize().height());
 }
 
 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());
 
@@ skipping 18 matching lines @@
 
 void OpaqueBrowserFrameView::PaintMaximizedFrameBorder(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());
 
   // Theme frame must be aligned with the tabstrip as if we were
   // in restored mode.  Note that the top of the tabstrip is
   // kTabstripTopShadowThickness px off the top of the screen.
-  int theme_background_y = -(GetHorizontalTabStripVerticalOffset(true) +
+  int theme_background_y = -(GetTabStripInsets(true).top +
       kTabstripTopShadowThickness);
   frame_background_->set_theme_background_y(theme_background_y);
 
   frame_background_->PaintMaximized(canvas, this);
 
   // TODO(jamescook): Migrate this into FrameBackground.
   if (!browser_view()->IsToolbarVisible()) {
     // There's no toolbar to edge the frame border, so we need to draw a bottom
     // edge.  The graphic we use for this has a built in client edge, so we clip
     // it off the bottom.
@@ skipping 65 matching lines @@
   gfx::ImageSkia* theme_toolbar = browser_view()->GetToolbarBackgroundImage(
       browser_view()->browser()->search_model()->mode().mode);
 
   // Paint the bottom rect.
   canvas->FillRect(gfx::Rect(x, bottom_y, w, bottom_edge_height),
                    background_color);
 
   // Tile the toolbar image starting at the frame edge on the left and where the
   // horizontal tabstrip is (or would be) on the top.
   canvas->TileImageInt(*theme_toolbar, x,
-                       bottom_y - GetHorizontalTabStripVerticalOffset(false), x,
+                       bottom_y - GetTabStripInsets(false).top, x,
                        bottom_y, w, theme_toolbar->height());
 
   // Draw rounded corners for the tab.
   gfx::ImageSkia* toolbar_left_mask =
       tp->GetImageSkiaNamed(IDR_CONTENT_TOP_LEFT_CORNER_MASK);
   gfx::ImageSkia* toolbar_right_mask =
       tp->GetImageSkiaNamed(IDR_CONTENT_TOP_RIGHT_CORNER_MASK);
 
   // We mask out the corners by using the DestinationIn transfer mode,
   // which keeps the RGB pixels from the destination and the alpha from
@@ skipping 283 matching lines @@
         title_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 = GetHorizontalTabStripVerticalOffset(false) +
+  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_);
 }
 
 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));
 }