Miscellaneous cleanup.

chrome/browser/ui/views/frame/glass_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/glass_browser_frame_view.h"
 
 #include "base/prefs/pref_service.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "chrome/app/chrome_command_ids.h"
@@ skipping 31 matching lines @@
 namespace {
 // Size of client edge drawn inside the outer frame borders.
 const int kNonClientBorderThicknessPreWin10 = 3;
 const int kNonClientBorderThicknessWin10 = 1;
 // 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;
 // In the window corners, the resize areas don't actually expand bigger, but the
 // 16 px at the end of the top and bottom edges triggers diagonal resizing.
 const int kResizeCornerWidth = 16;
-// 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;
+// Space between the right edge of the incognito icon and the tabstrip.
+const int kIncognitoRightSpacing = -2;
 // How far the new avatar button is from the left of the minimize button.
 const int kNewAvatarButtonOffset = 5;
 // The content left/right images have a shadow built into them.
 const int kContentEdgeShadowThickness = 2;
 // 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.
+// is no incognito icon.
 const int kTabStripIndent = -6;
 
 // Converts the |image| to a Windows icon and returns the corresponding HICON
 // handle. |image| is resized to desired |width| and |height| if needed.
 HICON CreateHICONFromSkBitmapSizedTo(const gfx::ImageSkia& image,
                                      int width,
                                      int height) {
   if (width == image.width() && height == image.height())
     return IconUtil::CreateHICONFromSkBitmap(*image.bitmap());
   return IconUtil::CreateHICONFromSkBitmap(skia::ImageOperations::Resize(
@@ skipping 17 matching lines @@
 }
 
 GlassBrowserFrameView::~GlassBrowserFrameView() {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // GlassBrowserFrameView, BrowserNonClientFrameView implementation:
 
 gfx::Rect GlassBrowserFrameView::GetBoundsForTabStrip(
     views::View* tabstrip) const {
-  int minimize_button_offset =
-      std::min(frame()->GetMinimizeButtonOffset(), width());
+  int end_x = std::min(frame()->GetMinimizeButtonOffset(), width());
 
   // The new avatar button is optionally displayed to the left of the
   // minimize button.
   if (new_avatar_button()) {
-    minimize_button_offset -=
-        new_avatar_button()->width() + kNewAvatarButtonOffset;
+    end_x -= new_avatar_button()->width() + kNewAvatarButtonOffset;
 
-    // In non-maximized mode, allow the new tab button to completely slide under
+    // In non-maximized mode, allow the new tab button to slide completely under
     // the avatar button.
     if (!frame()->IsMaximized() && !base::i18n::IsRTL()) {
-      minimize_button_offset +=
+      end_x +=
           TabStrip::kNewTabButtonAssetWidth + kNewTabCaptionRestoredSpacing;
     }
   }
 
-  int tabstrip_x = browser_view()->ShouldShowAvatar() ?
-      (avatar_bounds_.right() + kAvatarRightSpacing) :
+  int x = browser_view()->ShouldShowAvatar() ?
+      (incognito_bounds_.right() + kIncognitoRightSpacing) :
       NonClientBorderThickness() + kTabStripIndent;
   // In RTL languages, we have moved an avatar icon left by the size of window
   // controls to prevent it from being rendered over them. So, we use its x
   // position to move this tab strip left when maximized. Also, we can render
   // a tab strip until the left end of this window without considering the size
   // of window controls in RTL languages.
   if (base::i18n::IsRTL()) {
     if (!browser_view()->ShouldShowAvatar() && frame()->IsMaximized()) {
-      tabstrip_x += avatar_bounds_.x();
+      x += incognito_bounds_.x();
     } else if (browser_view()->IsRegularOrGuestSession()) {
-      tabstrip_x = width() - minimize_button_offset;
+      x = width() - end_x;
     }
 
-    minimize_button_offset = width();
+    end_x = width();
   }
-  int tabstrip_width = minimize_button_offset - tabstrip_x -
+  int tabstrip_width = end_x - x -
       (frame()->IsMaximized() ?
           kNewTabCaptionMaximizedSpacing : kNewTabCaptionRestoredSpacing);
-  return gfx::Rect(tabstrip_x, NonClientTopBorderHeight(),
-                   std::max(0, tabstrip_width),
+  return gfx::Rect(x, NonClientTopBorderHeight(), std::max(0, tabstrip_width),
                    tabstrip->GetPreferredSize().height());
 }
 
 int GlassBrowserFrameView::GetTopInset() const {
   return GetClientAreaInsets().top();
 }
 
 int GlassBrowserFrameView::GetThemeBackgroundXInset() const {
   return 0;
 }
@@ skipping 61 matching lines @@
 }
 
 int GlassBrowserFrameView::NonClientHitTest(const gfx::Point& point) {
   // If the browser isn't in normal mode, we haven't customized the frame, so
   // Windows can figure this out.  If the point isn't within our bounds, then
   // it's in the native portion of the frame, so again Windows can figure it
   // out.
   if (!browser_view()->IsBrowserTypeNormal() || !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))
-    return HTCLIENT;
-
-  if (new_avatar_button() &&
-     new_avatar_button()->GetMirroredBounds().Contains(point))
+  // See if the point is within the incognito icon or the new avatar menu.
+  if ((avatar_button() &&
+       avatar_button()->GetMirroredBounds().Contains(point)) ||
+      (new_avatar_button() &&
+       new_avatar_button()->GetMirroredBounds().Contains(point)))
    return HTCLIENT;
 
   int frame_component = frame()->client_view()->NonClientHitTest(point);
 
   // See if we're in the sysmenu region.  We still have to check the tabstrip
   // first so that clicks in a tab don't get treated as sysmenu clicks.
   int nonclient_border_thickness = NonClientBorderThickness();
   if (gfx::Rect(nonclient_border_thickness,
                 gfx::win::GetSystemMetricsInDIP(SM_CYSIZEFRAME),
                 gfx::win::GetSystemMetricsInDIP(SM_CXSMICON),
@@ skipping 26 matching lines @@
       browser_view()->toolbar()->ShouldPaintBackground())
     PaintToolbarBackground(canvas);
   if (!frame()->IsMaximized())
     PaintRestoredClientEdge(canvas);
 }
 
 void GlassBrowserFrameView::Layout() {
   if (browser_view()->IsRegularOrGuestSession())
     LayoutNewStyleAvatar();
   else
-    LayoutAvatar();
+    LayoutIncognitoIcon();
 
   LayoutClientView();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // GlassBrowserFrameView, protected:
 
 // views::ButtonListener:
 void GlassBrowserFrameView::ButtonPressed(views::Button* sender,
                                           const ui::Event& event) {
@@ skipping 16 matching lines @@
   UpdateNewAvatarButton(this, NewAvatarButton::NATIVE_BUTTON);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // GlassBrowserFrameView, private:
 
 // views::NonClientFrameView:
 bool GlassBrowserFrameView::DoesIntersectRect(const views::View* target,
                                               const gfx::Rect& rect) const {
   CHECK_EQ(target, this);
-  bool hit_avatar_button = avatar_button() &&
+  bool hit_incognito_icon = avatar_button() &&
       avatar_button()->GetMirroredBounds().Intersects(rect);
   bool hit_new_avatar_button = new_avatar_button() &&
       new_avatar_button()->GetMirroredBounds().Intersects(rect);
-  return hit_avatar_button || hit_new_avatar_button ||
+  return hit_incognito_icon || hit_new_avatar_button ||
          !frame()->client_view()->bounds().Intersects(rect);
 }
 
 int GlassBrowserFrameView::FrameBorderThickness() const {
   return (frame()->IsMaximized() || frame()->IsFullscreen()) ?
       0 : gfx::win::GetSystemMetricsInDIP(SM_CXSIZEFRAME);
 }
 
 int GlassBrowserFrameView::FrameTopBorderHeight() const {
   // We'd like to use FrameBorderThickness() here, but the maximized Aero glass
@@ skipping 44 matching lines @@
   int y = toolbar_bounds.y();
   int dest_y = browser_view()->IsTabStripVisible()
                    ? y + (kFrameShadowThickness * 2)
                    : y;
   canvas->TileImageInt(*theme_toolbar,
                        x + GetThemeBackgroundXInset(),
                        dest_y - GetTopInset(), x,
                        dest_y, w, theme_toolbar->height());
 
   if (browser_view()->IsTabStripVisible()) {
-    // On Windows 10, we don't draw our own window border but rather go right to
-    // the system border, so we don't need to draw the toolbar edges.
     if (base::win::GetVersion() < base::win::VERSION_WIN10) {
       int left_x = x - kContentEdgeShadowThickness;
       // 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 16 matching lines @@
 
       // Draw center edge.
       canvas->TileImageInt(*toolbar_center, left_x + toolbar_left->width(), y,
                            right_x - (left_x + toolbar_left->width()),
                            toolbar_center->height());
 
       // Right edge.
       canvas->DrawImageInt(*tp->GetImageSkiaNamed(IDR_CONTENT_TOP_RIGHT_CORNER),
                            right_x, y);
     } else {
+      // On Windows 10, we don't draw our own window border but rather go right
+      // to the system border, so we don't need to draw the toolbar edges.
       canvas->TileImageInt(*toolbar_center, x, y, w, toolbar_center->height());
     }
   }
 
   // Draw the content/toolbar separator.
   if (ui::MaterialDesignController::IsModeMaterial()) {
     toolbar_bounds.Inset(kClientEdgeThickness, 0);
     BrowserView::Paint1pxHorizontalLine(
         canvas,
         ThemeProperties::GetDefaultColor(
@@ skipping 86 matching lines @@
   // pixel in height, then we place it at the correct position in restored mode,
   // or one pixel above the top of the screen in maximized mode.
   int button_y = frame()->IsMaximized() ? (FrameTopBorderHeight() - 1) : 1;
   new_avatar_button()->SetBounds(
       button_x,
       button_y,
       label_size.width(),
       gfx::win::GetSystemMetricsInDIP(SM_CYMENUSIZE) + 1);
 }
 
-void GlassBrowserFrameView::LayoutAvatar() {
-  gfx::ImageSkia incognito_icon = browser_view()->GetOTRAvatarIcon();
-
-  int avatar_x = NonClientBorderThickness() + kAvatarLeftSpacing;
-  // Move this avatar icon by the size of window controls to prevent it from
-  // being rendered over them in RTL languages. This code also needs to adjust
-  // the width of a tab strip to avoid decreasing this size twice. (See the
-  // comment in GetBoundsForTabStrip().)
+void GlassBrowserFrameView::LayoutIncognitoIcon() {
+  const gfx::Insets insets(GetLayoutInsets(AVATAR_ICON));
+  const gfx::Size size(browser_view()->GetOTRAvatarIcon().size());
+  int x = NonClientBorderThickness();
+  // In RTL, the icon needs to start after the caption buttons.
   if (base::i18n::IsRTL())
-    avatar_x += width() - frame()->GetMinimizeButtonOffset();
-
-  int avatar_bottom = GetTopInset() +
-      browser_view()->GetTabStripHeight() - kAvatarBottomSpacing;
-  int avatar_y = frame()->IsMaximized() ?
-      FrameTopBorderHeight() : (avatar_bottom - incognito_icon.height());
-  avatar_bounds_.SetRect(avatar_x, avatar_y, incognito_icon.width(),
-      browser_view()->ShouldShowAvatar() ? (avatar_bottom - avatar_y) : 0);
+    x += width() - frame()->GetMinimizeButtonOffset();
+  const int bottom =
+      GetTopInset() + browser_view()->GetTabStripHeight() - insets.bottom();
+  const int y = frame()->IsMaximized() ?
+      FrameTopBorderHeight() : (bottom - size.height());
+  incognito_bounds_.SetRect(x + insets.left(), y, size.width(),
+      browser_view()->ShouldShowAvatar() ? (bottom - y) : 0);
   if (avatar_button())
-    avatar_button()->SetBoundsRect(avatar_bounds_);
+    avatar_button()->SetBoundsRect(incognito_bounds_);
 }
 
 void GlassBrowserFrameView::LayoutClientView() {
   client_view_bounds_ = CalculateClientAreaBounds(width(), height());
 }
 
 gfx::Insets GlassBrowserFrameView::GetClientAreaInsets() const {
   if (!browser_view()->IsTabStripVisible())
     return gfx::Insets();
 
@@ skipping 84 matching lines @@
   static bool initialized = false;
   if (!initialized) {
     for (int i = 0; i < kThrobberIconCount; ++i) {
       throbber_icons_[i] =
           ui::LoadThemeIconFromResourcesDataDLL(IDI_THROBBER_01 + i);
       DCHECK(throbber_icons_[i]);
     }
     initialized = true;
   }
 }