Update WM shadows for MD.

ui/gfx/image/image_skia_operations.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 "ui/gfx/image/image_skia_operations.h"
 
 #include <stddef.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 352 matching lines @@
   skia::ImageOperations::ResizeMethod resize_method_;
   const Size target_dip_size_;
 
   DISALLOW_COPY_AND_ASSIGN(ResizeSource);
 };
 
 // DropShadowSource generates image reps with drop shadow for image reps in
 // |source| that represent requested scale factors.
 class DropShadowSource : public ImageSkiaSource {
  public:
-  DropShadowSource(const ImageSkia& source,
-                   const ShadowValues& shadows_in_dip)
-      : source_(source),
-        shaodws_in_dip_(shadows_in_dip) {
-  }
+  DropShadowSource(const ImageSkia& source, const ShadowValues& shadows_in_dip)
+      : source_(source), shadows_in_dip_(shadows_in_dip) {}
   ~DropShadowSource() override {}
 
   // gfx::ImageSkiaSource overrides:
   ImageSkiaRep GetImageForScale(float scale) override {
     const ImageSkiaRep& image_rep = source_.GetRepresentation(scale);
 
     ShadowValues shadows_in_pixel;
-    for (size_t i = 0; i < shaodws_in_dip_.size(); ++i)
-      shadows_in_pixel.push_back(shaodws_in_dip_[i].Scale(scale));
+    for (size_t i = 0; i < shadows_in_dip_.size(); ++i)
+      shadows_in_pixel.push_back(shadows_in_dip_[i].Scale(scale));
 
     const SkBitmap shadow_bitmap = SkBitmapOperations::CreateDropShadow(
         image_rep.sk_bitmap(),
         shadows_in_pixel);
     return ImageSkiaRep(shadow_bitmap, image_rep.scale());
   }
 
  private:
   const ImageSkia source_;
-  const ShadowValues shaodws_in_dip_;
+  const ShadowValues shadows_in_dip_;
 
   DISALLOW_COPY_AND_ASSIGN(DropShadowSource);
 };
 
-// An image source that is 1dp wide, suitable for tiling horizontally.
+class ShadowNineboxSource : public CanvasImageSource {
+ public:
+  ShadowNineboxSource(const std::vector<ShadowValue>& shadows,
+                      float corner_radius)
+      : CanvasImageSource(CalculateSize(shadows, corner_radius), false),
+        shadows_(shadows),
+        corner_radius_(corner_radius) {}

[James Cook, 2016/12/05 23:38:35]

nit: DCHECK something about shadows.size() or .empty() -- it should be
non-empty, right?

[Evan Stade, 2016/12/06 00:53:21]

Done.

+  ~ShadowNineboxSource() override {}
+
+  // CanvasImageSource overrides:
+  void Draw(Canvas* canvas) override {
+    SkPaint paint;
+    paint.setLooper(CreateShadowDrawLooperCorrectBlur(shadows_));
+    Insets insets = -ShadowValue::GetMargin(shadows_);
+    gfx::Rect bounds(size());
+    bounds.Inset(insets);
+    gfx::RectF rrect_bounds(bounds);

[James Cook, 2016/12/05 23:38:35]

nit: Either rounded_rect_bounds or comment that rrect = rounded rect in
skia-land

[Evan Stade, 2016/12/06 00:53:21]

removed variable

+    SkRRect r_rect = SkRRect::MakeRectXY(gfx::RectFToSkRect(rrect_bounds),
+                                         corner_radius_, corner_radius_);
+
+    // Clip out the center so it's not painted with the shadow.
+    canvas->sk_canvas()->clipRRect(r_rect, SkRegion::kDifference_Op, true);
+    // Clipping alone is not enough --- due to anti aliasing there will still be
+    // some of the fill color in the rounded corners. We must make the fill
+    // color transparent.
+    paint.setColor(SK_ColorTRANSPARENT);
+    canvas->sk_canvas()->drawRRect(r_rect, paint);
+  }
+
+ private:
+  static Size CalculateSize(const std::vector<ShadowValue>& shadows,
+                            float corner_radius) {
+    Insets insets = ShadowValue::GetBlurRegion(shadows);
+    return Size(insets.width() + 2 * corner_radius,
+                insets.height() + 2 * corner_radius);
+  }
+
+  const std::vector<ShadowValue> shadows_;
+
+  float corner_radius_;
+
+  DISALLOW_COPY_AND_ASSIGN(ShadowNineboxSource);
+};
+
+// An image source that is 1px wide, suitable for tiling horizontally.
 class HorizontalShadowSource : public CanvasImageSource {
  public:
   HorizontalShadowSource(const std::vector<ShadowValue>& shadows,
                          bool fades_down)
       : CanvasImageSource(Size(1, GetHeightForShadows(shadows)), false),
         shadows_(shadows),
         fades_down_(fades_down) {}
   ~HorizontalShadowSource() override {}
 
   // CanvasImageSource overrides:
@@ skipping 173 matching lines @@
     return ImageSkia();
 
   const gfx::Insets shadow_padding = -gfx::ShadowValue::GetMargin(shadows);
   gfx::Size shadow_image_size = source.size();
   shadow_image_size.Enlarge(shadow_padding.width(),
                             shadow_padding.height());
   return ImageSkia(new DropShadowSource(source, shadows), shadow_image_size);
 }
 
 // static
+ImageSkia ImageSkiaOperations::CreateShadowNinebox(const ShadowValues& shadows,
+                                                   float corner_radius) {
+  auto source = new ShadowNineboxSource(shadows, corner_radius);
+  return ImageSkia(source, source->size());
+}
+
+// static
 ImageSkia ImageSkiaOperations::CreateHorizontalShadow(
     const std::vector<ShadowValue>& shadows,
     bool fades_down) {
-  HorizontalShadowSource* source =
-      new HorizontalShadowSource(shadows, fades_down);
+  auto source = new HorizontalShadowSource(shadows, fades_down);
   return ImageSkia(source, source->size());
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateRotatedImage(
       const ImageSkia& source,
       SkBitmapOperations::RotationAmount rotation) {
   if (source.isNull())
     return ImageSkia();
 
@@ skipping 10 matching lines @@
   if (icon.isNull())
     return ImageSkia();
 
   if (badge.isNull())
     return icon;
 
   return ImageSkia(new IconWithBadgeSource(icon, badge), icon.size());
 }
 
 }  // namespace gfx