paint: Introduce PaintImage that wraps SkImage in paint calls.

cc/paint/paint_image.h

Index: cc/paint/paint_image.h
diff --git a/cc/paint/paint_image.h b/cc/paint/paint_image.h
new file mode 100644
index 0000000000000000000000000000000000000000..cab5c36f7e2b99c99ac1d711644f02ff968a412b
--- /dev/null
+++ b/cc/paint/paint_image.h
@@ -0,0 +1,39 @@
+// Copyright 2017 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.
+
+#ifndef CC_PAINT_PAINT_IMAGE_H_
+#define CC_PAINT_PAINT_IMAGE_H_
+
+#include "cc/paint/paint_export.h"
+
+#include "third_party/skia/include/core/SkImage.h"
+
+namespace cc {
+
+class CC_PAINT_EXPORT PaintImage {

[Khushal, 2017/04/11 02:19:46]

Add a TODO for a persistent id for PaintImage, while the SkImage can still be
updated?

[vmpstr, 2017/04/11 18:58:33]

Done.

+ public:
+  // TODO(vmpstr): Work towards removing "UNKNOWN" value.
+  enum class AnimationType { UNKNOWN, ANIMATED, STATIC };

[Khushal, 2017/04/11 02:19:46]

Do you think we actually need the animation and completion values versus just a
bool, like, can_async_decode_? Blink can set this value based on whether the
image is animated. Similarly the completion state, not sure if we need it right
now.

[vmpstr, 2017/04/11 18:58:33]

I'd rather keep the logic for deciding that in cc. Additionally, this is useful
to know for any future animated images in the compositor, whereas
can_async_decode is somewhat limited in the information it provides. I'd also
like to keep a notion of unknown, since it is again up to cc to decide what that
means as opposed to relying on logic in blink to decide whether or not it's ok
to async decode the image. 

[Khushal, 2017/04/11 20:55:01]

We are using ANIMATED here for the frames in skcanvas_video_renderer, which I
don't think will be the kind of animation that cc will want to care about. Use
something else for this?

My feeling was that it might be easier to just say that based on the info the
caller has, it gets to tell cc whether something is suitable for async updates
or not. Like later for the case of an async attribute for images or the
CrossFadeImageGenerator. If you feel it would be better to have the info for
making that decision plumbed through so it happens later, that should work too.

+
+  // TODO(vmpstr): Work towards removing "UNKNOWN" value.
+  enum class CompletionState { UNKNOWN, DONE, PARTIALLY_DONE };
+
+  PaintImage(sk_sp<const SkImage> sk_image,
+             AnimationType animation_type,
+             CompletionState completion_state);
+  ~PaintImage();
+
+  const sk_sp<const SkImage>& sk_image() const { return sk_image_; }
+  AnimationType animation_type() const { return animation_type_; }
+  CompletionState completion_state() const { return completion_state_; }
+
+ private:
+  sk_sp<const SkImage> sk_image_;
+  AnimationType animation_type_;
+  CompletionState completion_state_;
+};
+
+}  // namespace cc
+
+#endif  // CC_PAINT_PAINT_IMAGE_H_