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 85 matching lines @@
 
 #if !defined(OS_CHROMEOS)
 #include "chrome/browser/ui/views/first_run_bubble.h"
 #endif
 
 using content::WebContents;
 using views::View;
 
 namespace {
 
+void DrawScaledRoundRect(gfx::Canvas* canvas,

[Peter Kasting, 2015/10/08 21:33:06]

Nit: I'd add a comment about what this does, in particular how the round rect
relates to |bounds|.

[jonross, 2015/10/09 15:59:24]

Done.

+                         SkPaint::Style style,
+                         SkColor color,
+                         gfx::Rect bounds) {
+  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(style);
+  paint.setColor(color);
+  paint.setAntiAlias(true);
+
+  const float kOffset = 0.5f;
+  gfx::RectF border_rect_f(bounds);
+  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);
+  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 1136 matching lines @@
   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.
   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()) {
+    DrawScaledRoundRect(canvas, SkPaint::kFill_Style, 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();
+    DrawScaledRoundRect(recorder.canvas(), SkPaint::Style::kStroke_Style,
+                        SkColorSetARGB(0x40, 0x00, 0x00, 0x00), border_rect);

[Peter Kasting, 2015/10/08 21:33:06]

I don't think this is right for popup windows, where we want a rectangular
border rather than a round one.

Also, won't this draw the stroke atop the fill?  I'm not sure that's what we
want; do we want the fill inside the stroke instead?  If so that's doable, I can
show you the technique to do it.

[jonross, 2015/10/09 15:14:17]

I looked at the spec, to get the desired alpha blend we will not want to draw
the stroke atop the fill, but will want the fill inset.

[Peter Kasting, 2015/10/09 16:03:32]

That's what I thought.

There are several ways to do this, but the easiest is probably something like
this:

(1) Get the path for the round rect stroke.
(2) Create an SkPaint for stroking.
(3) Use the stroke paint to convert the path to a corresponding fill path for
the stroke, i.e. a fill that, if drawn, would look exactly like a stroke.
(4) Subtract this fill from your main path.  Now the main path goes up to, but
not over, the stroke.
(5) Draw both fill paths with a fill-style SkPaint.  Remember to turn AA on and
set the right colors for each.

For (1), use SkPath::addRoundRect().
For (2), use SkPaint::setStyle(kStroke_Style); and setStrokeWidth();.
For (3), use SkPaint::getFillPath(); you want paint.getFillPath(path, &stroke);
where |stroke| is a new SkPath.
For (4), use the Op() function in SkPathOps.h; you want Op(path, stroke,
kDifference_SkPathOp, &path);.

   } 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();
   }
 }