Make popups closer to pixel-perfect. The main problem is that the toolbar is...

chrome/browser/views/frame/opaque_non_client_view.cc

 // Copyright (c) 2006-2008 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/views/frame/opaque_non_client_view.h"
 
 #include "chrome/app/theme/theme_resources.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/views/frame/browser_view.h"
 #include "chrome/browser/views/tabs/tab_strip.h"
@@ skipping 281 matching lines @@
 const int kFrameBorderThickness = 4;
 // In maximized mode, where no frame border is otherwise visible, we draw a
 // different, 1 px high border along the bottom of the screen.
 const int kFrameBorderMaximizedExtraBottomThickness = 1;
 // Various edges of the frame border have a 1 px shadow along their edges; in a
 // few cases we shift elements based on this amount for visual appeal.
 const int kFrameShadowThickness = 1;
 // Besides the frame border, there's another 11 px of empty space atop the
 // window in restored mode, to use to drag the window around.
 const int kNonClientRestoredExtraThickness = 11;
-// In restored mode, we draw a 1 px edge around the content area inside the
-// frame border.
-const int kClientEdgeThickness = 1;
 // 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 to less than 19 px tall, plus the height of the
-// frame border.
-const int kTitlebarMinimumHeight = 19;
+// The titlebar never shrinks to less than 18 px tall, plus the height of the
+// frame border and any bottom edge.
+const int kTitlebarMinimumHeight = 18;
 // The icon is inset 2 px from the left frame border.
 const int kIconLeftSpacing = 2;
 // The icon takes up 16/25th of the available titlebar height.  (This is
 // expressed as two ints to avoid precision losses leading to off-by-one pixel
 // errors.)
 const int kIconHeightFractionNumerator = 16;
 const int kIconHeightFractionDenominator = 25;
 // The icon never shrinks below 16 px on a side.
 const int kIconMinimumSize = 16;
 // Because our frame border has a different "3D look" than Windows', with a less
@@ skipping 376 matching lines @@
       GetSystemMetrics(SM_CYSIZEFRAME) : kFrameBorderThickness;
 }
 
 int OpaqueNonClientView::TopResizeHeight() const {
   return FrameTopBorderHeight() - kTopResizeAdjust;
 }
 
 int OpaqueNonClientView::NonClientBorderWidth() const {
   // In maximized mode, we don't show a client edge.
   return FrameBorderWidth() +
-      (frame_->IsMaximized() ? 0 : kClientEdgeThickness);
+      (frame_->IsMaximized() ? 0 : BrowserView::kClientEdgeThickness);
 }
 
 int OpaqueNonClientView::NonClientTopBorderHeight() const {
   if (!frame_->window_delegate()->ShouldShowWindowTitle()) {
     return FrameTopBorderHeight() +
         (frame_->IsMaximized() ? 0 : kNonClientRestoredExtraThickness);
   }
 
   int title_top_spacing, title_thickness;
   return TitleCoordinates(&title_top_spacing, &title_thickness);
 }
 
 int OpaqueNonClientView::NonClientBottomBorderHeight() const {
   // In maximized mode, we don't show a client edge, but the frame border is
   // extended slightly.
   return frame_->IsMaximized() ? (GetSystemMetrics(SM_CYSIZEFRAME) +
       kFrameBorderMaximizedExtraBottomThickness) :
-      (kFrameBorderThickness + kClientEdgeThickness);
+      (kFrameBorderThickness + BrowserView::kClientEdgeThickness);
 }
 
-int OpaqueNonClientView::ClientEdgeThicknessWithinNonClientHeight() const {
-  return (frame_->IsMaximized() || browser_view_->IsToolbarVisible()) ?
-      0 : kClientEdgeThickness;
+int OpaqueNonClientView::BottomEdgeThicknessWithinNonClientHeight() const {
+  if (browser_view_->IsToolbarVisible())
+    return 0;
+  return kFrameShadowThickness +
+      (frame_->IsMaximized() ? 0 : BrowserView::kClientEdgeThickness);
 }
 
 int OpaqueNonClientView::TitleCoordinates(int* title_top_spacing,
                                           int* title_thickness) const {
   int top_height = FrameTopBorderHeight();
   int min_titlebar_height = kTitlebarMinimumHeight + top_height;
   *title_top_spacing = top_height + kTitleTopSpacing;
   // The bottom spacing should be the same apparent height as the top spacing.
   // Because the actual top spacing height varies based on the system border
   // thickness, we calculate this based on the restored top spacing and then
-  // adjust for maximized mode.
-  int title_bottom_spacing = kFrameBorderThickness + kTitleTopSpacing;
+  // adjust for maximized mode.  We also don't include the frame shadow here,
+  // since while it's part of the bottom spacing it will be added in at the end
+  // as necessary (when a toolbar is present, the "shadow" is actually drawn by
+  // the toolbar).
+  int title_bottom_spacing =
+      kFrameBorderThickness + kTitleTopSpacing - kFrameShadowThickness;
   if (frame_->IsMaximized()) {
     // When we maximize, the top border appears to be chopped off; shift the
     // title down to stay centered within the remaining space.
     int title_adjust = (kFrameBorderThickness / 2);
     *title_top_spacing += title_adjust;
     title_bottom_spacing -= title_adjust;
   }
   *title_thickness = std::max(title_font_.height(),
       min_titlebar_height - *title_top_spacing - title_bottom_spacing);
   return *title_top_spacing + *title_thickness + title_bottom_spacing +
-      ClientEdgeThicknessWithinNonClientHeight();
+      BottomEdgeThicknessWithinNonClientHeight();
 }
 
 void OpaqueNonClientView::PaintRestoredFrameBorder(ChromeCanvas* canvas) {
   SkBitmap* top_left_corner =
       resources()->GetPartBitmap(FRAME_TOP_LEFT_CORNER);
   SkBitmap* top_right_corner =
       resources()->GetPartBitmap(FRAME_TOP_RIGHT_CORNER);
   SkBitmap* top_edge = resources()->GetPartBitmap(FRAME_TOP_EDGE);
   SkBitmap* right_edge = resources()->GetPartBitmap(FRAME_RIGHT_EDGE);
   SkBitmap* left_edge = resources()->GetPartBitmap(FRAME_LEFT_EDGE);
@@ skipping 40 matching lines @@
 
 void OpaqueNonClientView::PaintMaximizedFrameBorder(ChromeCanvas* canvas) {
   SkBitmap* top_edge = resources()->GetPartBitmap(FRAME_MAXIMIZED_TOP_EDGE);
   canvas->TileImageInt(*top_edge, 0, FrameTopBorderHeight(), width(),
                        top_edge->height());
 
   if (!browser_view_->IsToolbarVisible()) {
     // There's no toolbar to edge the frame border, so we need to draw a bottom
     // edge.  The App Window graphic we use for this has a built in client edge,
     // so we clip it off the bottom.
-    int edge_height = app_top_center_.height() - kClientEdgeThickness;
+    int edge_height =
+        app_top_center_.height() - BrowserView::kClientEdgeThickness;
     canvas->TileImageInt(app_top_center_, 0,
         frame_->client_view()->y() - edge_height, width(), edge_height);
   }
 
   SkBitmap* bottom_edge =
       resources()->GetPartBitmap(FRAME_MAXIMIZED_BOTTOM_EDGE);
   // We draw the bottom edge of this image.
   canvas->TileImageInt(*bottom_edge, 0,
       bottom_edge->height() - kFrameBorderMaximizedExtraBottomThickness, 0,
       height() - NonClientBottomBorderHeight(), width(),
@@ skipping 19 matching lines @@
     /* TODO(pkasting):  If this window is active, we should also draw a drop
      * shadow on the title.  This is tricky, because we don't want to hardcode a
      * shadow color (since we want to work with various themes), but we can't
      * 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. */
   }
 }
 
 void OpaqueNonClientView::PaintToolbarBackground(ChromeCanvas* canvas) {
-  if (!browser_view_->IsToolbarVisible() && !browser_view_->IsTabStripVisible())
+  if (!browser_view_->IsToolbarVisible() ||
+      !browser_view_->IsToolbarDisplayModeNormal())
     return;
 
   gfx::Rect toolbar_bounds(browser_view_->GetToolbarBounds());
   gfx::Point toolbar_origin(toolbar_bounds.origin());
   View::ConvertPointToView(frame_->client_view(), this, &toolbar_origin);
   toolbar_bounds.set_origin(toolbar_origin);
 
   SkBitmap* toolbar_left =
       resources()->GetPartBitmap(FRAME_CLIENT_EDGE_TOP_LEFT);
   canvas->DrawBitmapInt(*toolbar_left,
@@ skipping 16 matching lines @@
 
   SkBitmap otr_avatar_icon = browser_view_->GetOTRAvatarIcon();
   canvas->DrawBitmapInt(otr_avatar_icon, 0,
       (otr_avatar_icon.height() - otr_avatar_bounds_.height()) / 2,
       otr_avatar_bounds_.width(), otr_avatar_bounds_.height(), 
       MirroredLeftPointForRect(otr_avatar_bounds_), otr_avatar_bounds_.y(),
       otr_avatar_bounds_.width(), otr_avatar_bounds_.height(), false);
 }
 
 void OpaqueNonClientView::PaintRestoredClientEdge(ChromeCanvas* canvas) {
-  int client_area_top = frame_->client_view()->y();
+  int client_area_top =
+      frame_->client_view()->y() + browser_view_->GetToolbarBounds().bottom();
 
-  // The toolbar draws a client edge along its own bottom edge when it's
-  // visible.  However, it only draws this for the width of the actual client
-  // area, leaving a gap at the left and right edges:
-  //
-  // |             Toolbar             | <-- part of toolbar
-  //  ----- (toolbar client edge) -----  <-- gap
-  // |           Client area           | <-- right client edge
-  //
-  // To address this, we extend the left and right client edges up to fill the
-  // gap, by pretending the toolbar is shorter than it really is.
-  //
-  // Note: We can get away with this hackery because we only draw a top edge
-  // when there is no toolbar.  If we tried to draw a client edge over the
-  // toolbar's bottom edge, we'd need a different solution.
-  if (browser_view_->IsToolbarVisible()) {
-    client_area_top +=
-        browser_view_->GetToolbarBounds().bottom() - kClientEdgeThickness;
-  }
-
-  // When we don't have a toolbar to draw a top edge for us, draw a top edge.
   gfx::Rect client_area_bounds = CalculateClientAreaBounds(width(), height());
-  if (!browser_view_->IsToolbarVisible()) {
+  if (browser_view_->IsToolbarVisible() &&
+      browser_view_->IsToolbarDisplayModeNormal()) {
+    // The toolbar draws a client edge along its own bottom edge when it's
+    // visible and in normal mode.  However, it only draws this for the width of
+    // the actual client area, leaving a gap at the left and right edges:
+    //
+    // |             Toolbar             | <-- part of toolbar
+    //  ----- (toolbar client edge) -----  <-- gap
+    // |           Client area           | <-- right client edge
+    //
+    // To address this, we extend the left and right client edges up to fill the
+    // gap, by pretending the toolbar is shorter than it really is.
+    client_area_top -= BrowserView::kClientEdgeThickness;
+  } else {
+    // The toolbar isn't going to draw a client edge for us, so draw one
+    // ourselves.
+    int top_edge_y = client_area_top - app_top_center_.height();
     // This is necessary because the top center bitmap is shorter than the top
     // left and right bitmaps.  We need their top edges to line up, and we
     // need the left and right edges to start below the corners' bottoms.
-    int top_edge_y = client_area_top - app_top_center_.height();
     client_area_top = top_edge_y + app_top_left_.height();
     canvas->DrawBitmapInt(app_top_left_,
                           client_area_bounds.x() - app_top_left_.width(),
                           top_edge_y);
     canvas->TileImageInt(app_top_center_, client_area_bounds.x(), top_edge_y,
                          client_area_bounds.width(), app_top_center_.height());
     canvas->DrawBitmapInt(app_top_right_, client_area_bounds.right(),
                           top_edge_y);
   }
 
@@ skipping 82 matching lines @@
   logo_bounds_.SetRect(logo_x, TopResizeHeight(), distributor_logo_.width(),
                        distributor_logo_.height());
 }
 
 void OpaqueNonClientView::LayoutTitleBar() {
   // Always lay out the icon, even when it's not present, so we can lay out the
   // window title based on its position.
   int icon_x = FrameBorderWidth() + kIconLeftSpacing;
 
   // The usable height of the titlebar area is the total height minus the top
-  // resize border, the one shadow pixel at the bottom, and any client edge area
-  // we draw below that shadow pixel.
+  // resize border and any edge area we draw at its bottom.
   int title_top_spacing, title_thickness;
   int top_height = TitleCoordinates(&title_top_spacing, &title_thickness);
   int top_border_height = FrameTopBorderHeight();
   int available_height = top_height - top_border_height -
-      kFrameShadowThickness - ClientEdgeThicknessWithinNonClientHeight();
+      BottomEdgeThicknessWithinNonClientHeight();
 
   // The icon takes up a constant fraction of the available height, down to a
   // minimum size, and is always an even number of pixels on a side (presumably
   // to make scaled icons look better).  It's centered within the usable height.
   int icon_size = std::max((available_height * kIconHeightFractionNumerator /
       kIconHeightFractionDenominator) / 2 * 2, kIconMinimumSize);
   int icon_y = ((available_height - icon_size) / 2) + top_border_height;
 
   // Hack: 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;
@@ skipping 62 matching lines @@
 }
 
 // static
 void OpaqueNonClientView::InitAppWindowResources() {
   static bool initialized = false;
   if (!initialized) {
     title_font_ = win_util::GetWindowTitleFont();
     initialized = true;
   }
 }