Stylize PlaceholderImages with icons.

third_party/WebKit/Source/platform/graphics/PlaceholderImage.cpp

 // Copyright 2016 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 "platform/graphics/PlaceholderImage.h"
 
 #include "platform/geometry/FloatRect.h"
-#include "platform/graphics/Color.h"
+#include "platform/geometry/IntPoint.h"
+#include "platform/geometry/IntRect.h"
+#include "platform/graphics/BitmapImage.h"
+#include "platform/graphics/GraphicsContext.h"
 #include "platform/graphics/ImageObserver.h"
+#include "platform/graphics/paint/PaintCanvas.h"
+#include "platform/graphics/paint/PaintFlags.h"
 #include "platform/graphics/paint/PaintRecord.h"
 #include "platform/graphics/paint/PaintRecorder.h"
+#include "platform/wtf/StdLibExtras.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkRect.h"
 #include "third_party/skia/include/core/SkSize.h"
 
 namespace blink {
 
-namespace {
-
-// Gray with 40% opacity.
-const RGBA32 kFillColor = 0x66808080;
-
-}  // namespace
+PlaceholderImage::PlaceholderImage(ImageObserver* observer, const IntSize& size)
+    : Image(observer), size_(size) {}
 
 PlaceholderImage::~PlaceholderImage() {}
 
 sk_sp<SkImage> PlaceholderImage::ImageForCurrentFrame() {
   if (image_for_current_frame_)
     return image_for_current_frame_;
 
   const FloatRect dest_rect(0.0f, 0.0f, static_cast<float>(size_.Width()),
                             static_cast<float>(size_.Height()));
+
   PaintRecorder paint_recorder;
   Draw(paint_recorder.beginRecording(dest_rect), PaintFlags(), dest_rect,
        dest_rect, kDoNotRespectImageOrientation, kClampImageToSourceRect);
 
   image_for_current_frame_ = SkImage::MakeFromPicture(
       ToSkPicture(paint_recorder.finishRecordingAsPicture(), dest_rect),
       SkISize::Make(size_.Width(), size_.Height()), nullptr, nullptr,
       SkImage::BitDepth::kU8, SkColorSpace::MakeSRGB());
 
   return image_for_current_frame_;
 }
 
 void PlaceholderImage::Draw(PaintCanvas* canvas,
                             const PaintFlags& base_flags,
                             const FloatRect& dest_rect,
                             const FloatRect& src_rect,
-                            RespectImageOrientationEnum,
-                            ImageClampingMode) {
+                            RespectImageOrientationEnum respect_orientation,
+                            ImageClampingMode image_clamping_mode) {
   if (!src_rect.Intersects(FloatRect(0.0f, 0.0f,
                                      static_cast<float>(size_.Width()),
                                      static_cast<float>(size_.Height())))) {
     return;
   }
 
+  // Placeholder image visual specifications:
+  // https://docs.google.com/document/d/1BHeA1azbgCdZgCnr16VN2g7A9MHPQ_dwKn5szh8evMQ/edit
+
   PaintFlags flags(base_flags);
   flags.setStyle(PaintFlags::kFill_Style);
-  flags.setColor(kFillColor);
+  flags.setColor(SkColorSetARGBMacro(0x80, 0xD9, 0xD9, 0xD9));

[f(malita), 2017/06/06 14:04:21]

nit: SkColorSetARGB()

[sclittle, 2017/06/07 19:43:54]

Done.

   canvas->drawRect(dest_rect, flags);
+
+  constexpr int kIconWidth = 24;
+  constexpr int kIconHeight = 24;
+  constexpr int kIconPaddingX = 8;
+  constexpr int kIconPaddingY = 5;
+
+  if (dest_rect.Width() < kIconWidth + 2 * kIconPaddingX ||
+      dest_rect.Height() < kIconHeight + 2 * kIconPaddingY) {
+    return;
+  }
+
+  DEFINE_STATIC_REF(Image, icon_image,
+                    (Image::LoadPlatformResource("placeholderIcon")));
+  DCHECK(!icon_image->IsNull());
+
+  FloatRect icon_dest_rect(
+      dest_rect.X() + (dest_rect.Width() - kIconWidth) / 2.0f,
+      dest_rect.Y() + (dest_rect.Height() - kIconHeight) / 2.0f, kIconWidth,
+      kIconHeight);
+
+  // Note that the |icon_image| is not scaled according to dest_rect / src_rect,
+  // and is always drawn at the same size. This is so that placeholder icons are
+  // visible (e.g. when replacing a large image that's scaled down to a small
+  // area) and so that all placeholder images on the same page look consistent.
+  icon_image->Draw(canvas, base_flags, icon_dest_rect,
+                   IntRect(IntPoint::Zero(), icon_image->Size()),
+                   kDoNotRespectImageOrientation, kClampImageToSourceRect);
+}
+
+void PlaceholderImage::DrawPattern(GraphicsContext& context,
+                                   const FloatRect& src_rect,
+                                   const FloatSize& scale,
+                                   const FloatPoint& phase,
+                                   SkBlendMode mode,
+                                   const FloatRect& dest_rect,
+                                   const FloatSize& repeat_spacing) {
+  DCHECK(context.Canvas());
+
+  PaintFlags flags = context.FillFlags();
+  flags.setBlendMode(mode);
+
+  // Ignore the pattern specifications and just draw a single placeholder image
+  // over the whole |dest_rect|. This is done in order to prevent repeated icons
+  // from cluttering tiled background images.
+  Draw(context.Canvas(), flags, dest_rect, src_rect,
+       kDoNotRespectImageOrientation, kClampImageToSourceRect);
 }
 
 void PlaceholderImage::DestroyDecodedData() {
   image_for_current_frame_.reset();
 }
 
 }  // namespace blink