Refactor ShadowImageSource into ui/gfx/skia_util for better reuse

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"
 #include "base/macros.h"
 #include "skia/ext/image_operations.h"
+#include "third_party/skia/include/core/SkDrawLooper.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/image/canvas_image_source.h"
 #include "ui/gfx/image/image_skia.h"
@@ skipping 367 matching lines @@
     return ImageSkiaRep(shadow_bitmap, image_rep.scale());
   }
 
  private:
   const ImageSkia source_;
   const ShadowValues shaodws_in_dip_;
 
   DISALLOW_COPY_AND_ASSIGN(DropShadowSource);
 };
 
+// An image source that is 1dp 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:
+  void Draw(Canvas* canvas) override {
+    SkPaint paint;
+    paint.setLooper(CreateShadowDrawLooperCorrectBlur(shadows_));
+    canvas->DrawRect(RectF(0, fades_down_ ? -1 : size().height(), 1, 1), paint);
+  }
+
+ private:
+  static int GetHeightForShadows(const std::vector<ShadowValue>& shadows) {
+    int height = 0;
+    for (const auto& shadow : shadows) {
+      height = std::max(height, shadow.y() + ToCeiledInt(shadow.blur() / 2));
+    }
+    return height;
+  }
+
+  const std::vector<ShadowValue> shadows_;
+
+  // The orientation of the shadow (true for shadows that emanate downwards).
+  bool fades_down_;
+
+  DISALLOW_COPY_AND_ASSIGN(HorizontalShadowSource);
+};
+
 // RotatedSource generates image reps that are rotations of those in
 // |source| that represent requested scale factors.
 class RotatedSource : public ImageSkiaSource {
  public:
   RotatedSource(const ImageSkia& source,
                 SkBitmapOperations::RotationAmount rotation)
     : source_(source),
       rotation_(rotation) {
   }
   ~RotatedSource() override {}
@@ skipping 140 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::CreateHorizontalShadow(
+    const std::vector<ShadowValue>& shadows,
+    bool fades_down) {
+  HorizontalShadowSource* 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();
 
   return ImageSkia(new RotatedSource(source, rotation),
       SkBitmapOperations::ROTATION_180_CW == rotation ?
           source.size() :
           gfx::Size(source.height(), source.width()));
 
 }
 
 // static
 ImageSkia ImageSkiaOperations::CreateIconWithBadge(const ImageSkia& icon,
                                                    const ImageSkia& badge) {
   if (icon.isNull())
     return ImageSkia();
 
   if (badge.isNull())
     return icon;
 
   return ImageSkia(new IconWithBadgeSource(icon, badge), icon.size());
 }
 
 }  // namespace gfx