paint: Introduce PaintImage that wraps SkImage in paint calls.

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

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006 Apple Computer, Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 17 matching lines @@
 
 #include "platform/Length.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/SharedBuffer.h"
 #include "platform/geometry/FloatPoint.h"
 #include "platform/geometry/FloatRect.h"
 #include "platform/geometry/FloatSize.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/DeferredImageDecoder.h"
 #include "platform/graphics/GraphicsContext.h"
+#include "platform/graphics/paint/PaintImage.h"
 #include "platform/graphics/paint/PaintRecorder.h"
 #include "platform/graphics/paint/PaintShader.h"
 #include "platform/instrumentation/PlatformInstrumentation.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/network/mime/MIMETypeRegistry.h"
 #include "platform/wtf/StdLibExtras.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebData.h"
 #include "third_party/skia/include/core/SkImage.h"
 
@@ skipping 174 matching lines @@
   StartAnimation();
 }
 
 namespace {
 
 sk_sp<PaintShader> CreatePatternShader(sk_sp<const SkImage> image,
                                        const SkMatrix& shader_matrix,
                                        const PaintFlags& paint,
                                        const FloatSize& spacing,
                                        SkShader::TileMode tmx,
-                                       SkShader::TileMode tmy) {
+                                       SkShader::TileMode tmy,
+                                       bool animated,
+                                       bool complete) {
   if (spacing.IsZero())
     return MakePaintShaderImage(image, tmx, tmy, &shader_matrix);
 
   // Arbitrary tiling is currently only supported for SkPictureShader, so we use
   // that instead of a plain bitmap shader to implement spacing.
   const SkRect tile_rect = SkRect::MakeWH(image->width() + spacing.Width(),
                                           image->height() + spacing.Height());
 
   PaintRecorder recorder;
   PaintCanvas* canvas = recorder.beginRecording(tile_rect);
-  canvas->drawImage(image, 0, 0, &paint);
+  auto animation_type = animated ? PaintImage::AnimationType::ANIMATED
+                                 : PaintImage::AnimationType::STATIC;
+  auto completion_state = complete
+                              ? PaintImage::CompletionState::DONE
+                              : PaintImage::CompletionState::PARTIALLY_DONE;
+  canvas->drawImage(
+      PaintImage(std::move(image), animation_type, completion_state), 0, 0,

[pdr., 2017/04/12 17:37:05]

It looks like PaintImage is used as a single-frame image but isn't your
long-term plan to fully wrap animated gifs so that PaintImage holds more than a
single frame?

[vmpstr, 2017/04/12 18:58:44]

Yeah, that's the plan. I'm just trying to stage this in pieces, so for now I
just want to introduce a PaintImage which we can work with in cc. When we're
properly plumbing all of the cc stuff, then we'll go back and see how to pack
the full gif into it.

+      &paint);
 
   return MakePaintShaderRecord(recorder.finishRecordingAsPicture(), tmx, tmy,
                                &shader_matrix, nullptr);
 }
 
 SkShader::TileMode ComputeTileMode(float left,
                                    float right,
                                    float min,
                                    float max) {
   DCHECK(left < right);
@@ skipping 54 matching lines @@
   PaintFlags flags = context.FillFlags();
   flags.setColor(SK_ColorBLACK);
   flags.setBlendMode(composite_op);
   flags.setFilterQuality(
       context.ComputeFilterQuality(this, dest_rect, norm_src_rect));
   flags.setAntiAlias(context.ShouldAntialias());
   flags.setShader(
       CreatePatternShader(std::move(image), local_matrix, flags,
                           FloatSize(repeat_spacing.Width() / scale.Width(),
                                     repeat_spacing.Height() / scale.Height()),
-                          tmx, tmy));
+                          tmx, tmy, MaybeAnimated(), CurrentFrameIsComplete()));
   // If the shader could not be instantiated (e.g. non-invertible matrix),
   // draw transparent.
   // Note: we can't simply bail, because of arbitrary blend mode.
   if (!flags.getShader())
     flags.setColor(SK_ColorTRANSPARENT);
 
   context.DrawRect(dest_rect, flags);
 
   if (CurrentFrameIsLazyDecoded())
     PlatformInstrumentation::DidDrawLazyPixelRef(image_id);
@@ skipping 51 matching lines @@
   FloatRect subset = dest;
   subset.SetX((dest.X() - tile.X()) / scale.Width());
   subset.SetY((dest.Y() - tile.Y()) / scale.Height());
   subset.SetWidth(dest.Width() / scale.Width());
   subset.SetHeight(dest.Height() / scale.Height());
 
   return subset;
 }
 
 }  // namespace blink