Draw the same portion of the frame background behind the tabstrip in maximized

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 87 matching lines @@
 gfx::Rect GlassBrowserFrameView::GetBoundsForTabStrip(
     views::View* tabstrip) const {
   // In maximized RTL windows, don't let the tabstrip overlap the caption area,
   // or the alpha-blending it does will make things like the new avatar button
   // look glitchy.
   const int offset =
     (ui::MaterialDesignController::IsModeMaterial() || !base::i18n::IsRTL() ||
      !frame()->IsMaximized()) ?
         GetLayoutInsets(AVATAR_ICON).right() : 0;
   const int x = incognito_bounds_.right() + offset;
-  int end_x = width() - NonClientBorderThickness();
+  int end_x = width() - NonClientBorderThickness(false);
   if (!base::i18n::IsRTL()) {
     end_x = std::min(frame()->GetMinimizeButtonOffset(), end_x) -
         (frame()->IsMaximized() ?
             kNewTabCaptionMaximizedSpacing : kNewTabCaptionRestoredSpacing);
 
     // The new avatar button is optionally displayed to the left of the
     // minimize button.
     if (new_avatar_button()) {
       const int old_end_x = end_x;
       end_x -= new_avatar_button()->width() + kNewAvatarButtonOffset;
 
       // In non-maximized mode, allow the new tab button to slide completely
       // under the avatar button.
       if (!frame()->IsMaximized()) {
         end_x = std::min(end_x + GetLayoutConstant(NEW_TAB_BUTTON_WIDTH) +
                              kNewTabCaptionRestoredSpacing,
                          old_end_x);
       }
     }
   }
-  return gfx::Rect(x, NonClientTopBorderHeight(), std::max(0, end_x - x),
+  return gfx::Rect(x, NonClientTopBorderHeight(false), std::max(0, end_x - x),
                    tabstrip->GetPreferredSize().height());
 }
 
-int GlassBrowserFrameView::GetTopInset() const {
-  return GetClientAreaInsets().top();
+int GlassBrowserFrameView::GetTopInset(bool restored) const {
+  return GetClientAreaInsets(restored).top();
 }
 
 int GlassBrowserFrameView::GetThemeBackgroundXInset() const {
   return 0;
 }
 
 void GlassBrowserFrameView::UpdateThrobber(bool running) {
   if (throbber_running_) {
     if (running) {
       DisplayNextThrobberFrame();
     } else {
       StopThrobber();
     }
   } else if (running) {
     StartThrobber();
   }
 }
 
 gfx::Size GlassBrowserFrameView::GetMinimumSize() const {
   gfx::Size min_size(browser_view()->GetMinimumSize());
 
   // Account for the client area insets.
-  gfx::Insets insets = GetClientAreaInsets();
+  gfx::Insets insets = GetClientAreaInsets(false);
   min_size.Enlarge(insets.width(), insets.height());
   // Client area insets do not include the shadow thickness.
   min_size.Enlarge(2 * kContentEdgeShadowThickness, 0);
 
   // Ensure that the minimum width is enough to hold a tab strip with minimum
   // width at its usual insets.
   if (browser_view()->IsTabStripVisible()) {
     TabStrip* tabstrip = browser_view()->tabstrip();
     int min_tabstrip_width = tabstrip->GetMinimumSize().width();
     int min_tabstrip_area_width =
@@ skipping 18 matching lines @@
     // If we don't have a tabstrip, we're either a popup or an app window, in
     // which case we have a standard size non-client area and can just use
     // AdjustWindowRectEx to obtain it. We check for a non-null window handle in
     // case this gets called before the window is actually created.
     RECT rect = client_bounds.ToRECT();
     AdjustWindowRectEx(&rect, GetWindowLong(hwnd, GWL_STYLE), FALSE,
                        GetWindowLong(hwnd, GWL_EXSTYLE));
     return gfx::Rect(rect);
   }
 
-  gfx::Insets insets = GetClientAreaInsets();
+  gfx::Insets insets = GetClientAreaInsets(false);
   return gfx::Rect(std::max(0, client_bounds.x() - insets.left()),
                    std::max(0, client_bounds.y() - insets.top()),
                    client_bounds.width() + insets.width(),
                    client_bounds.height() + insets.height());
 }
 
 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 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();
+  int nonclient_border_thickness = NonClientBorderThickness(false);
   if (gfx::Rect(nonclient_border_thickness,
                 gfx::win::GetSystemMetricsInDIP(SM_CYSIZEFRAME),
                 gfx::win::GetSystemMetricsInDIP(SM_CXSMICON),
                 gfx::win::GetSystemMetricsInDIP(SM_CYSMICON)).Contains(point))
     return (frame_component == HTCLIENT) ? HTCLIENT : HTSYSMENU;
 
   if (frame_component != HTNOWHERE)
     return frame_component;
 
-  int frame_top_border_height = FrameTopBorderHeight();
+  int frame_top_border_height = FrameTopBorderHeight(false);
   // We want the resize corner behavior to apply to the kResizeCornerWidth
   // pixels at each end of the top and bottom edges.  Because |point|'s x
   // coordinate is based on the DWM-inset portion of the window (so, it's 0 at
   // the first pixel inside the left DWM margin), we need to subtract the DWM
   // margin thickness, which we calculate as the total frame border thickness
   // minus the nonclient border thickness.
   const int dwm_margin = FrameBorderThickness() - nonclient_border_thickness;
   int window_component = GetHTComponentForFrame(point, frame_top_border_height,
       nonclient_border_thickness, frame_top_border_height,
       kResizeCornerWidth - dwm_margin, frame()->widget_delegate()->CanResize());
@@ skipping 57 matching lines @@
       new_avatar_button()->GetMirroredBounds().Intersects(rect);
   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 {
+int GlassBrowserFrameView::FrameTopBorderHeight(bool restored) const {
   // We'd like to use FrameBorderThickness() here, but the maximized Aero glass
   // frame has a 0 frame border around most edges and a CYSIZEFRAME-thick border
   // at the top (see AeroGlassFrame::OnGetMinMaxInfo()).
-  return frame()->IsFullscreen() ?
+  return (frame()->IsFullscreen() && !restored) ?
       0 : gfx::win::GetSystemMetricsInDIP(SM_CYSIZEFRAME);
 }
 
-int GlassBrowserFrameView::NonClientBorderThickness() const {
-  if (frame()->IsMaximized() || frame()->IsFullscreen())
+int GlassBrowserFrameView::NonClientBorderThickness(bool restored) const {
+  if ((frame()->IsMaximized() || frame()->IsFullscreen()) && !restored)
     return 0;
 
   return (base::win::GetVersion() <= base::win::VERSION_WIN8_1)
              ? kNonClientBorderThicknessPreWin10
              : kNonClientBorderThicknessWin10;
 }
 
-int GlassBrowserFrameView::NonClientTopBorderHeight() const {
-  if (frame()->IsFullscreen())
+int GlassBrowserFrameView::NonClientTopBorderHeight(bool restored) const {
+  if (frame()->IsFullscreen() && !restored)
     return 0;
 
-  const int top = FrameTopBorderHeight();
+  const int top = FrameTopBorderHeight(restored);
   // The tab top inset is equal to the height of any shadow region above the
   // tabs, plus a 1 px top stroke.  In maximized mode, we want to push the
   // shadow region off the top of the screen but leave the top stroke.
   // Annoyingly, the pre-MD layout uses different heights for the hit-test
   // exclusion region (which we want here, since we're trying to size the border
   // so that the region above the tab's hit-test zone matches) versus the shadow
   // thickness.
   const int exclusion = GetLayoutConstant(TAB_TOP_EXCLUSION_HEIGHT);
-  return frame()->IsMaximized() ?
+  return (frame()->IsMaximized() && !restored) ?
       (top - GetLayoutInsets(TAB).top() + 1) :
       (top + kNonClientRestoredExtraThickness - exclusion);
 }
 
 void GlassBrowserFrameView::PaintToolbarBackground(gfx::Canvas* canvas) {
   ui::ThemeProvider* tp = GetThemeProvider();
 
   gfx::Rect toolbar_bounds(browser_view()->GetToolbarBounds());
   gfx::Point toolbar_origin(toolbar_bounds.origin());
   View::ConvertPointToTarget(browser_view(), this, &toolbar_origin);
   toolbar_bounds.set_origin(toolbar_origin);
   int x = toolbar_bounds.x();
   int w = toolbar_bounds.width();
 
   // Toolbar background.
   int y = toolbar_bounds.y();
   // Tile the toolbar image starting at the frame edge on the left and where
   // the tabstrip is on the top.
   gfx::ImageSkia* theme_toolbar = tp->GetImageSkiaNamed(IDR_THEME_TOOLBAR);
   int dest_y = y;
   // In the pre-MD world, the toolbar top edge is drawn using the
   // IDR_CONTENT_TOP_XXX images, which overlay the toolbar.  The top 2 px of
   // these images is the actual top edge, and is partly transparent, so the
   // toolbar background shouldn't be drawn over it.
   const int kPreMDToolbarTopEdgeExclusion = 2;
   if (browser_view()->IsTabStripVisible())
     dest_y += kPreMDToolbarTopEdgeExclusion;
   canvas->TileImageInt(
       *theme_toolbar, x + GetThemeBackgroundXInset(),
-      dest_y - GetTopInset() + Tab::GetYOffsetForActiveTabBackground(),
+      dest_y - GetTopInset(false) + Tab::GetYOffsetForActiveTabBackground(),
       x, dest_y, w, theme_toolbar->height());
 
   // Toolbar edges.
   if (browser_view()->IsTabStripVisible()) {
     // Pre-Windows 10, we draw toolbar left and right edges and top corners,
     // partly atop the window border.  In Windows 10+, we don't draw our own
     // window border but rather go right to the system border, so we need only
     // draw the toolbar top edge.
     int center_x = x;
     int center_w = w;
@@ skipping 49 matching lines @@
 void GlassBrowserFrameView::PaintRestoredClientEdge(gfx::Canvas* canvas) {
   ui::ThemeProvider* tp = GetThemeProvider();
   gfx::Rect client_area_bounds = CalculateClientAreaBounds(width(), height());
 
   // The client edges start below the toolbar upper corner images regardless
   // of how tall the toolbar itself is.
   int client_area_top = frame()->client_view()->y() +
       browser_view()->GetToolbarBounds().y() +
       tp->GetImageSkiaNamed(IDR_CONTENT_TOP_LEFT_CORNER)->height();
   int client_area_bottom =
-      std::max(client_area_top, height() - NonClientBorderThickness());
+      std::max(client_area_top, height() - NonClientBorderThickness(false));
   int client_area_height = client_area_bottom - client_area_top;
 
   // Draw the client edge images.
   gfx::ImageSkia* right = tp->GetImageSkiaNamed(IDR_CONTENT_RIGHT_SIDE);
   canvas->TileImageInt(*right, client_area_bounds.right(), client_area_top,
                        right->width(), client_area_height);
   canvas->DrawImageInt(
       *tp->GetImageSkiaNamed(IDR_CONTENT_BOTTOM_RIGHT_CORNER),
       client_area_bounds.right(), client_area_bottom);
   gfx::ImageSkia* bottom = tp->GetImageSkiaNamed(IDR_CONTENT_BOTTOM_CENTER);
@@ skipping 44 matching lines @@
   // FrameTopBorderHeight() pixels from the top of the window; all those top
   // border pixels are offscreen, so this result in caption buttons flush with
   // the top of the screen.  In restored mode, the caption buttons are first
   // placed just below a 2 px border at the top of the window (which is the
   // first two pixels' worth of FrameTopBorderHeight()), then extended upwards
   // one extra pixel to overlap part of this border.
   //
   // To match both of these, we size the button as if it's always the extra one
   // 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;
+  int button_y = frame()->IsMaximized() ? (FrameTopBorderHeight(false) - 1) : 1;
   new_avatar_button()->SetBounds(
       button_x,
       button_y,
       label_size.width(),
       gfx::win::GetSystemMetricsInDIP(SM_CYMENUSIZE) + 1);
 }
 
 void GlassBrowserFrameView::LayoutIncognitoIcon() {
   const gfx::Insets insets(GetLayoutInsets(AVATAR_ICON));
   gfx::Size size;
   // During startup it's possible to reach here before the browser view has been
   // added to the view hierarchy.  In this case it won't have a widget and thus
   // can't access the theme provider, which is required to get the incognito
   // icon.  Use an empty size in this case, which will still place the tabstrip
   // at the correct coordinates for a non-incognito window.  We should get
   // another layout call after the browser view has a widget anyway.
   if (browser_view()->GetWidget())
     size = browser_view()->GetOTRAvatarIcon().size();
-  int x = NonClientBorderThickness();
+  int x = NonClientBorderThickness(false);
   // In RTL, the icon needs to start after the caption buttons.
   if (base::i18n::IsRTL()) {
     x = width() - frame()->GetMinimizeButtonOffset() +
         (new_avatar_button() ?
             (new_avatar_button()->width() + kNewAvatarButtonOffset) : 0);
   }
-  const int bottom =
-      GetTopInset() + browser_view()->GetTabStripHeight() - insets.bottom();
+  const int bottom = GetTopInset(false) + browser_view()->GetTabStripHeight() -
+      insets.bottom();
   const int y = (ui::MaterialDesignController::IsModeMaterial() ||
                  !frame()->IsMaximized()) ?
-      (bottom - size.height()) : FrameTopBorderHeight();
+      (bottom - size.height()) : FrameTopBorderHeight(false);
   incognito_bounds_.SetRect(x + (avatar_button() ? insets.left() : 0), y,
                             avatar_button() ? size.width() : 0, bottom - y);
   if (avatar_button())
     avatar_button()->SetBoundsRect(incognito_bounds_);
 }
 
 void GlassBrowserFrameView::LayoutClientView() {
   client_view_bounds_ = CalculateClientAreaBounds(width(), height());
 }
 
-gfx::Insets GlassBrowserFrameView::GetClientAreaInsets() const {
+gfx::Insets GlassBrowserFrameView::GetClientAreaInsets(bool restored) const {
   if (!browser_view()->IsTabStripVisible())
     return gfx::Insets();
 
-  const int top_height = NonClientTopBorderHeight();
-  const int border_thickness = NonClientBorderThickness();
+  const int top_height = NonClientTopBorderHeight(restored);
+  const int border_thickness = NonClientBorderThickness(restored);
   return gfx::Insets(top_height,
                      border_thickness,
                      border_thickness,
                      border_thickness);
 }
 
 gfx::Rect GlassBrowserFrameView::CalculateClientAreaBounds(int width,
                                                            int height) const {
   gfx::Rect bounds(0, 0, width, height);
-  bounds.Inset(GetClientAreaInsets());
+  bounds.Inset(GetClientAreaInsets(false));
   return bounds;
 }
 
 void GlassBrowserFrameView::StartThrobber() {
   if (!throbber_running_) {
     throbber_running_ = true;
     throbber_frame_ = 0;
     InitThrobberIcons();
     SendMessage(views::HWNDForWidget(frame()), WM_SETICON,
                 static_cast<WPARAM>(ICON_SMALL),
@@ skipping 62 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;
   }
 }