Draw popup window toolbars as only containing a location bar.

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/compiler_specific.h"
@@ skipping 14 matching lines @@
 #include "chrome/grit/generated_resources.h"
 #include "components/signin/core/browser/signin_header_helper.h"
 #include "components/signin/core/common/profile_management_switches.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/theme_resources.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/hit_test.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/material_design/material_design_controller.h"
-#include "ui/base/resource/resource_bundle.h"
 #include "ui/base/theme_provider.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/path.h"
 #include "ui/resources/grit/ui_resources.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/image_view.h"
@@ skipping 567 matching lines @@
       tp->GetImageSkiaNamed(IDR_WINDOW_BOTTOM_RIGHT_CORNER));
   frame_background_->PaintRestored(canvas, this);
 
   // Note: When we don't have a toolbar, we need to draw some kind of bottom
   // edge here.  Because the App Window graphics we use for this have an
   // attached client edge and their sizing algorithm is a little involved, we do
   // all this in PaintRestoredClientEdge().
 }
 
 void OpaqueBrowserFrameView::PaintMaximizedFrameBorder(gfx::Canvas* canvas) {
-  ui::ThemeProvider* tp = GetThemeProvider();
   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());
   frame_background_->set_maximized_top_inset(
       GetTopInset(true) - GetTopInset(false));
-
   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.
-    gfx::ImageSkia* top_center = tp->GetImageSkiaNamed(IDR_APP_TOP_CENTER);
-    int edge_height = top_center->height() - kClientEdgeThickness;
-    canvas->TileImageInt(*top_center, 0,
-        frame()->client_view()->y() - edge_height, width(), edge_height);
-  }
 }
 
 void OpaqueBrowserFrameView::PaintToolbarBackground(gfx::Canvas* canvas) {
   gfx::Rect toolbar_bounds(browser_view()->GetToolbarBounds());
   if (toolbar_bounds.IsEmpty())
     return;
   gfx::Point toolbar_origin(toolbar_bounds.origin());
   ConvertPointToTarget(browser_view(), this, &toolbar_origin);
   toolbar_bounds.set_origin(toolbar_origin);
-  int x = toolbar_bounds.x();
-  const int y = toolbar_bounds.y();
-  const int w = toolbar_bounds.width();
   const int h = toolbar_bounds.height();
+  ui::ThemeProvider* tp = GetThemeProvider();
+  const SkColor separator_color =
+      tp->GetColor(ThemeProperties::COLOR_TOOLBAR_SEPARATOR);
 
   // Background.
-  const bool normal_mode = browser_view()->IsTabStripVisible();
-  if (normal_mode) {
+  if (browser_view()->IsTabStripVisible()) {
     // We need to create a separate layer to hold the background, so we can mask
     // off the corners before compositing onto the frame.
+    int x = toolbar_bounds.x();
+    const int y = toolbar_bounds.y();
+    const int w = toolbar_bounds.width();
     canvas->sk_canvas()->saveLayer(
         gfx::RectToSkRect(gfx::Rect(x - kContentEdgeShadowThickness, y,
                                     w + kContentEdgeShadowThickness * 2, h)),
         nullptr);
-  }
 
-  // The top stroke is drawn using the IDR_CONTENT_TOP_XXX images, which overlay
-  // the toolbar.  The top 2 px of these images is the actual top stroke +
-  // shadow, and is partly transparent, so the toolbar background shouldn't be
-  // drawn over it.  Furthermore, the toolbar may be in popup mode, where we
-  // don't want rounded corners at all, and in that case dividing the toolbar
-  // assets at this point, plus manipulating the horizontal offset of the top
-  // pieces, lets us make the toolbar look almost as if it's intended to have
-  // square corners.
-  const int split_point = std::min(kContentEdgeShadowThickness, h);
-  int split_y = y + split_point;
-  int split_h = h - split_point;
-  ui::ThemeProvider* tp = GetThemeProvider();
-  if (split_h) {
-    // Tile the toolbar image starting at the frame edge on the left and where
-    // the horizontal tabstrip is (or would be) on the top.
-    const int kToolbarBackground = IDR_THEME_TOOLBAR;
-    // Avoid theming popup or app windows.
-    gfx::ImageSkia* bg = normal_mode ?
-        tp->GetImageSkiaNamed(kToolbarBackground) :
-        ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
-            kToolbarBackground);
-    const int bg_y =
-        GetTopInset(false) + Tab::GetYInsetForActiveTabBackground();
-    canvas->TileImageInt(*bg, x + GetThemeBackgroundXInset(), split_y - bg_y, x,
-                         split_y, w, split_h);
-  }
+    // The top stroke is drawn using the IDR_CONTENT_TOP_XXX images, which
+    // overlay the toolbar.  The top 2 px of these images is the actual top
+    // stroke + shadow, and is partly transparent, so the toolbar background
+    // shouldn't be drawn over it.
+    const int split_point = std::min(kContentEdgeShadowThickness, h);
+    if (h > split_point) {
+      // Tile the toolbar image starting at the frame edge on the left and where
+      // the tabstrip is on the top.
+      const int split_y = y + split_point;
+      const int bg_y =
+          GetTopInset(false) + Tab::GetYInsetForActiveTabBackground();
+      canvas->TileImageInt(*tp->GetImageSkiaNamed(IDR_THEME_TOOLBAR),
+                           x + GetThemeBackgroundXInset(), split_y - bg_y, x,
+                           split_y, w, h - split_point);
+    }
 
-  gfx::ImageSkia* left = tp->GetImageSkiaNamed(IDR_CONTENT_TOP_LEFT_CORNER);
-  const int left_x = x - kContentEdgeShadowThickness;
-  int img_w = left->width();
-  gfx::ImageSkia* right = tp->GetImageSkiaNamed(IDR_CONTENT_TOP_RIGHT_CORNER);
-  int right_x = toolbar_bounds.right() + kContentEdgeShadowThickness - img_w;
-  if (normal_mode) {
     // Mask out the corners.
+    gfx::ImageSkia* left = tp->GetImageSkiaNamed(IDR_CONTENT_TOP_LEFT_CORNER);
+    const int img_w = left->width();
+    x -= kContentEdgeShadowThickness;
     SkPaint paint;
     paint.setXfermodeMode(SkXfermode::kDstIn_Mode);
     canvas->DrawImageInt(
         *tp->GetImageSkiaNamed(IDR_CONTENT_TOP_LEFT_CORNER_MASK), 0, 0, img_w,
-        h, left_x, y, img_w, h, false, paint);
+        h, x, y, img_w, h, false, paint);
+    const int right_x =
+        toolbar_bounds.right() + kContentEdgeShadowThickness - img_w;
     canvas->DrawImageInt(
         *tp->GetImageSkiaNamed(IDR_CONTENT_TOP_RIGHT_CORNER_MASK), 0, 0, img_w,
         h, right_x, y, img_w, h, false, paint);
     canvas->Restore();
 
     // Corner and side strokes.
-    canvas->DrawImageInt(*left, 0, 0, img_w, h, left_x, y, img_w, h, false);
-    canvas->DrawImageInt(*right, 0, 0, img_w, h, right_x, y, img_w, h, false);
-  } else {
-    // Corner and side strokes.
-    if (split_h) {
-      const int img_h = left->height() - split_h;
-      canvas->DrawImageInt(*left, 0, img_h, img_w, split_h, left_x, split_y,
-                           img_w, split_h, false);
-      canvas->DrawImageInt(*right, 0, img_h, img_w, split_h, right_x, split_y,
-                           img_w, split_h, false);
+    canvas->DrawImageInt(*left, 0, 0, img_w, h, x, y, img_w, h, false);
+    canvas->DrawImageInt(*tp->GetImageSkiaNamed(IDR_CONTENT_TOP_RIGHT_CORNER),
+                         0, 0, img_w, h, right_x, y, img_w, h, false);
+
+    // Top stroke.
+    x += img_w;
+    canvas->TileImageInt(*tp->GetImageSkiaNamed(IDR_CONTENT_TOP_CENTER), x, y,
+                         right_x - x, split_point);
+
+    if (ui::MaterialDesignController::IsModeMaterial()) {
+      // Toolbar/content separator.
+      toolbar_bounds.Inset(kClientEdgeThickness, 0);
+      BrowserView::Paint1pxHorizontalLine(canvas, separator_color,
+                                          toolbar_bounds);
+      return;
     }
-    --img_w;
-    canvas->DrawImageInt(*left, 1, 0, img_w, split_point, left_x, y, img_w,
-                         split_point, false);
-    ++right_x;
-    canvas->DrawImageInt(*right, 0, 0, img_w, split_point, right_x, y, img_w,
-                         split_point, false);
   }
 
-  // Top stroke.
-  x = left_x + img_w;
-  canvas->TileImageInt(*tp->GetImageSkiaNamed(IDR_CONTENT_TOP_CENTER), x, y,
-                       right_x - x, split_point);
-
   // Toolbar/content separator.
-  const SkColor separator_color =
-      tp->GetColor(ThemeProperties::COLOR_TOOLBAR_SEPARATOR);
-  if (ui::MaterialDesignController::IsModeMaterial()) {
-    toolbar_bounds.Inset(kClientEdgeThickness, 0);
-    BrowserView::Paint1pxHorizontalLine(canvas, separator_color,
-                                        toolbar_bounds);
-  } else {
-    toolbar_bounds.Inset(kClientEdgeThickness, h - kClientEdgeThickness,
-                         kClientEdgeThickness, 0);
-    canvas->FillRect(toolbar_bounds, separator_color);
-  }
+  toolbar_bounds.Inset(kClientEdgeThickness, h - kClientEdgeThickness,
+                        kClientEdgeThickness, 0);
+  canvas->FillRect(toolbar_bounds, separator_color);
 }
 
 void OpaqueBrowserFrameView::PaintClientEdge(gfx::Canvas* canvas) {
-  ui::ThemeProvider* tp = GetThemeProvider();
-  int y = frame()->client_view()->y();
-
   gfx::Rect client_bounds =
       layout_->CalculateClientAreaBounds(width(), height());
   const int x = client_bounds.x();
+  int y = client_bounds.y();
   const int w = client_bounds.width();
   const int right = client_bounds.right();
-  const SkColor toolbar_color = tp->GetColor(ThemeProperties::COLOR_TOOLBAR);
+  const bool normal_mode = browser_view()->IsTabStripVisible();
+  ui::ThemeProvider* tp = GetThemeProvider();
+  const SkColor toolbar_color = normal_mode ?
+      tp->GetColor(ThemeProperties::COLOR_TOOLBAR) :
+      ThemeProperties::GetDefaultColor(ThemeProperties::COLOR_TOOLBAR);
 
-  if (IsToolbarVisible()) {
+  const gfx::Rect toolbar_bounds(browser_view()->GetToolbarBounds());
+  if (normal_mode) {
     // The client edge images start below the toolbar.
-    y += browser_view()->GetToolbarBounds().bottom();
+    y += toolbar_bounds.bottom();
   } else {
     // The toolbar isn't going to draw a top edge for us, so draw one ourselves.
+    if (IsToolbarVisible()) {
+      y += toolbar_bounds.y() + kContentEdgeShadowThickness +
+          kClientEdgeThickness;
+    }
     gfx::ImageSkia* top_left = tp->GetImageSkiaNamed(IDR_APP_TOP_LEFT);
     const int img_w = top_left->width();
     const int height = top_left->height();
     const int top_y = y - height;
     canvas->DrawImageInt(*top_left, 0, 0, img_w, height, x - img_w, top_y,
                          img_w, height, false);
     canvas->TileImageInt(*tp->GetImageSkiaNamed(IDR_APP_TOP_CENTER), 0, 0, x,
                          top_y, w, height);
     canvas->DrawImageInt(*tp->GetImageSkiaNamed(IDR_APP_TOP_RIGHT), 0, 0, img_w,
                          height, right, top_y, img_w, height, false);
+    client_bounds.set_y(y);
     client_bounds.Inset(-kClientEdgeThickness, -kClientEdgeThickness,
                         -kClientEdgeThickness, client_bounds.height());
     canvas->FillRect(client_bounds, toolbar_color);
   }
 
   // In maximized mode, the only edge to draw is the top one, so we're done.
   if (layout_->IsTitleBarCondensed())
     return;
 
   const int bottom = std::max(y, height() - NonClientBorderThickness());
   int height = bottom - y;
 
   // Draw the client edge images.
   gfx::ImageSkia* right_image = tp->GetImageSkiaNamed(IDR_CONTENT_RIGHT_SIDE);
   const int img_w = right_image->width();
   canvas->TileImageInt(*right_image, right, y, img_w, height);
   canvas->DrawImageInt(*tp->GetImageSkiaNamed(IDR_CONTENT_BOTTOM_RIGHT_CORNER),
                        right, bottom);
   gfx::ImageSkia* bottom_image =
       tp->GetImageSkiaNamed(IDR_CONTENT_BOTTOM_CENTER);
   canvas->TileImageInt(*bottom_image, x, bottom, w, bottom_image->height());
   canvas->DrawImageInt(*tp->GetImageSkiaNamed(IDR_CONTENT_BOTTOM_LEFT_CORNER),
                        x - img_w, bottom);
-  gfx::ImageSkia* left_image = tp->GetImageSkiaNamed(IDR_CONTENT_LEFT_SIDE);
-  canvas->TileImageInt(*left_image, x - img_w, y, img_w, height);
+  canvas->TileImageInt(*tp->GetImageSkiaNamed(IDR_CONTENT_LEFT_SIDE), x - img_w,
+                       y, img_w, height);
 
   // Draw the toolbar color so that the client edges show the right color even
   // where not covered by the toolbar image.  NOTE: We do this after drawing the
   // images because the images are meant to alpha-blend atop the frame whereas
   // these rects are meant to be fully opaque, without anything overlaid.
   gfx::Rect side(x - kClientEdgeThickness, y, kClientEdgeThickness,
                  bottom + kClientEdgeThickness - y);
   canvas->FillRect(side, toolbar_color);
   canvas->FillRect(gfx::Rect(x, bottom, w, kClientEdgeThickness),
                    toolbar_color);
   side.set_x(right);
   canvas->FillRect(side, toolbar_color);
 }