Update LocationBarView Background

chrome/browser/ui/views/location_bar/location_bar_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/location_bar/location_bar_view.h"
 
 #include <algorithm>
 #include <map>
 
 #include "base/i18n/rtl.h"
@@ skipping 52 matching lines @@
 #include "components/search_engines/template_url_service.h"
 #include "components/translate/core/browser/language_state.h"
 #include "components/ui/zoom/zoom_controller.h"
 #include "components/ui/zoom/zoom_event_manager.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/feature_switch.h"
 #include "grit/components_scaled_resources.h"
 #include "grit/theme_resources.h"
+#include "third_party/skia/include/core/SkPath.h"
+#include "third_party/skia/include/pathops/SkPathOps.h"
 #include "ui/accessibility/ax_view_state.h"
 #include "ui/base/dragdrop/drag_drop_types.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/compositor/paint_recorder.h"
 #include "ui/events/event.h"
 #include "ui/gfx/animation/slide_animation.h"
 #include "ui/gfx/canvas.h"
@@ skipping 13 matching lines @@
 
 #if !defined(OS_CHROMEOS)
 #include "chrome/browser/ui/views/first_run_bubble.h"
 #endif
 
 using content::WebContents;
 using views::View;
 
 namespace {
 
+// Removes the current image scaling on |canvas|, returning the scale value.
+// Also adjusts |rect| based on the scaling. Call canvas->Restore() to return
+// to default scaling.
+float SetupScaledPainting(gfx::Canvas* canvas, gfx::RectF* rect) {
+  const float display_scale = canvas->image_scale();
+  canvas->Save();
+  SkScalar scale_factor = 1.0f / display_scale;
+  canvas->sk_canvas()->scale(scale_factor, scale_factor);
+
+  const float kOffset = 0.5f;
+  rect->Scale(display_scale);
+  gfx::InsetsF insets(kOffset, kOffset, kOffset, kOffset);
+  rect->Inset(insets);

[Evan Stade, 2015/10/09 20:00:24]

you can just do rect->Inset(kOffset, kOffset)

[jonross, 2015/10/19 20:29:02]

Done.

+
+  return display_scale;
+}
+
+// Draws a filled rect in the native coordinates of the display. Where |bounds|
+// is in the coordinate space of LocationBarView. The actual rect drawn will be
+// reduced by the region of |bounds| required to render a one pixel thick
+// border.
+void DrawScaledBackgroundRect(gfx::Canvas* canvas,
+                              SkColor color,
+                              gfx::Rect bounds) {
+  gfx::RectF border_rect_f(bounds);
+  const float display_scale = SetupScaledPainting(canvas, &border_rect_f);
+  const SkScalar kCornerRadius = SkDoubleToScalar(2.5f * display_scale);
+
+  SkPath path;
+  path.addRoundRect(gfx::RectFToSkRect(border_rect_f), kCornerRadius,
+                    kCornerRadius);
+
+  SkPaint stroke_paint;
+  stroke_paint.setStyle(SkPaint::Style::kStroke_Style);
+  stroke_paint.setStrokeWidth(1);
+
+  SkPath stroke_path;
+  stroke_paint.getFillPath(path, &stroke_path);
+
+  SkPath fill_path;
+  Op(path, stroke_path, kDifference_SkPathOp, &fill_path);
+
+  SkPaint paint;
+  paint.setStyle(SkPaint::kFill_Style);
+  paint.setColor(color);
+  paint.setAntiAlias(true);
+
+  canvas->sk_canvas()->drawPath(fill_path, paint);
+  canvas->Restore();
+}
+
+// Draws a one pixel thick border in the native coordinates of the display.
+// Where |bounds| is in the coordinate space of LocationBarView. If |round| the
+// drawn rect will have rounded corners.
+void DrawScaledBorderRect(gfx::Canvas* canvas,
+                          SkColor color,
+                          gfx::Rect bounds,
+                          bool round) {
+  gfx::RectF border_rect_f(bounds);
+  const float display_scale = SetupScaledPainting(canvas, &border_rect_f);
+
+  SkPaint paint;
+  paint.setStyle(SkPaint::Style::kStroke_Style);
+  paint.setColor(color);
+  paint.setAntiAlias(true);
+
+  const SkScalar kCornerRadius = SkDoubleToScalar(2.5f * display_scale);
+  if (round) {
+    canvas->sk_canvas()->drawRoundRect(gfx::RectFToSkRect(border_rect_f),
+                                       kCornerRadius, kCornerRadius, paint);
+  } else {
+    canvas->sk_canvas()->drawRect(gfx::RectFToSkRect(border_rect_f), paint);
+  }
+  canvas->Restore();
+}
+
 int GetEditLeadingInternalSpace() {
   // The textfield has 1 px of whitespace before the text in the RTL case only.
   return base::i18n::IsRTL() ? 1 : 0;
 }
 
 }  // namespace
 
 
 // LocationBarView -----------------------------------------------------------
 
@@ skipping 1130 matching lines @@
   // Explicitly focus the omnibox so a focus ring will be displayed around it on
   // Windows.
   omnibox_view_->SetFocus();
 }
 
 void LocationBarView::OnPaint(gfx::Canvas* canvas) {
   View::OnPaint(canvas);
 
   // Fill the location bar background color behind the border.  Parts of the
   // border images are meant to rest atop the toolbar background and parts atop
   // the omnibox background, so we can't just blindly fill our entire bounds.

[Evan Stade, 2015/10/09 20:34:38]

I don't think this is still true for material mode. The edge thickness is 0.
Hence you could just pass the entire bounds. This makes me think it would be
fine to implement a round rect version of views::Background and not pass bounds
at all (passing color in the constructor).

[jonross, 2015/10/19 20:29:02]

Done.

   gfx::Rect bounds(GetContentsBounds());
   bounds.Inset(GetHorizontalEdgeThickness(), GetVerticalEdgeThickness());
   SkColor color(GetColor(SecurityStateModel::NONE, BACKGROUND));
   if (is_popup_mode_) {
     canvas->FillRect(bounds, color);
+  } else if (ui::MaterialDesignController::IsModeMaterial()) {
+    DrawScaledBackgroundRect(canvas, color, bounds);
   } else {
     SkPaint paint;
     paint.setStyle(SkPaint::kFill_Style);
     paint.setColor(color);
     const int kBorderCornerRadius = 2;
     canvas->DrawRoundRect(bounds, kBorderCornerRadius, paint);
   }
 
   // The border itself will be drawn in PaintChildren() since it includes an
   // inner shadow which should be drawn over the contents.
@@ skipping 11 matching lines @@
   if (show_focus_rect_ && HasFocus())
     recorder.canvas()->DrawFocusRect(omnibox_view_->bounds());
 
   // Maximized popup windows don't draw the horizontal edges.  We implement this
   // by simply expanding the paint area outside the view by the edge thickness.
   gfx::Rect border_rect(GetContentsBounds());
   if (is_popup_mode_ && (GetHorizontalEdgeThickness() == 0))
     border_rect.Inset(-kPopupEdgeThickness, 0);
 
   if (ui::MaterialDesignController::IsModeMaterial()) {
-    gfx::Canvas* canvas = recorder.canvas();
-    const float display_scale = canvas->image_scale();
-    canvas->Save();
-    SkScalar scale_factor = 1.0f / display_scale;
-    canvas->sk_canvas()->scale(scale_factor, scale_factor);
-
-    SkPaint paint;
-    paint.setStyle(SkPaint::Style::kStroke_Style);
-    paint.setColor(SkColorSetARGB(0x40, 0x00, 0x00, 0x00));
-    paint.setStrokeWidth(1);
-    paint.setAntiAlias(true);
-
-    const float kOffset = 0.5f;
-    gfx::RectF border_rect_f(border_rect);
-    border_rect_f.Scale(display_scale);
-    gfx::InsetsF insets(kOffset, kOffset, kOffset, kOffset);
-    border_rect_f.Inset(insets);
-
-    const SkScalar kCornerRadius = SkDoubleToScalar(2.5f * display_scale);
-    canvas->sk_canvas()->drawRoundRect(gfx::RectFToSkRect(border_rect_f),
-                                       kCornerRadius, kCornerRadius, paint);
-    recorder.canvas()->Restore();
+    DrawScaledBorderRect(recorder.canvas(),
+                         SkColorSetARGB(0x4D, 0x00, 0x00, 0x00), border_rect,
+                         !is_popup_mode_);

[Peter Kasting, 2015/10/12 23:45:44]

In the MD world, I don't think we actually need to do this in PaintChildren();
we can do it in Paint().  This simplifies things because you can draw the
background and border in the same function.

This will also allow you to fix what looks like an inconsistency here where the
popup mode border is drawn atop the background, but the normal border is drawn
outside it.

[jonross, 2015/10/19 20:29:02]

Done.

   } else {
     views::Painter::PaintPainterAt(recorder.canvas(), border_painter_.get(),
                                    border_rect);
   }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LocationBarView, private views::ButtonListener implementation:
 
 void LocationBarView::ButtonPressed(views::Button* sender,
@@ skipping 97 matching lines @@
 
 void LocationBarView::ModelChanged(const SearchModel::State& old_state,
                                    const SearchModel::State& new_state) {
   const bool visible = !GetToolbarModel()->input_in_progress() &&
       new_state.voice_search_supported;
   if (mic_search_view_->visible() != visible) {
     mic_search_view_->SetVisible(visible);
     Layout();
   }
 }