Support for decoding images in lists

sky/engine/bindings/scripts/dart_types.py

@@ -118,6 +118,7 @@ CPP_SPECIAL_CONVERSION_RULES = {
     # dart_value_to_cpp_value using CPP_SPECIAL_CONVERSION_RULES directly
     # instead of calling cpp_type.
     'Float32List': 'Float32List',
+    'Uint8List': 'Uint8List',
     'Offset': 'Offset',
     'Paint': 'Paint',
     'Point': 'Point',
@@ -379,6 +380,7 @@ DART_TO_CPP_VALUE = {
     # Pass-by-value types.
     'Color': pass_by_value_format('CanvasColor'),
     'Float32List': pass_by_value_format('Float32List'),
+    'Uint8List': pass_by_value_format('Uint8List'),
     'Offset': pass_by_value_format('Offset'),
     'Paint': pass_by_value_format('Paint'),
     'Point': pass_by_value_format('Point'),
@@ -664,6 +666,7 @@ DART_SET_RETURN_VALUE = {
     'TypedList': 'Dart_SetReturnValue(args, DartUtilities::arrayBufferViewToDart({cpp_value}))',
     'Color': 'DartConverter<CanvasColor>::SetReturnValue(args, {cpp_value})',
     'Float32List': 'DartConverter<Float32List>::SetReturnValue(args, {cpp_value})',
+    'Uint8List': 'DartConverter<Uint8List>::SetReturnValue(args, {cpp_value})',
 }
 
 

sky/engine/core/loader/CanvasImageDecoder.cpp

@@ -12,16 +12,21 @@
 namespace blink {
 
 PassRefPtr<CanvasImageDecoder> CanvasImageDecoder::create(
-    mojo::ScopedDataPipeConsumerHandle handle,
     PassOwnPtr<ImageDecoderCallback> callback) {
-  return adoptRef(new CanvasImageDecoder(handle.Pass(), callback));
+  return adoptRef(new CanvasImageDecoder(callback));
 }
 
-CanvasImageDecoder::CanvasImageDecoder(
-    mojo::ScopedDataPipeConsumerHandle handle,
-    PassOwnPtr<ImageDecoderCallback> callback)
+CanvasImageDecoder::CanvasImageDecoder(PassOwnPtr<ImageDecoderCallback> callback)
     : callback_(callback), weak_factory_(this) {
   CHECK(callback_);
+  buffer_ = SharedBuffer::create();
+}
+
+CanvasImageDecoder::~CanvasImageDecoder() {
+}
+
+void CanvasImageDecoder::initWithConsumer(mojo::ScopedDataPipeConsumerHandle handle) {
+  CHECK(!drainer_);
   if (!handle.is_valid()) {
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(&CanvasImageDecoder::RejectCallback,
@@ -29,11 +34,14 @@ CanvasImageDecoder::CanvasImageDecoder(
     return;
   }
 
-  buffer_ = SharedBuffer::create();
   drainer_ = adoptPtr(new mojo::common::DataPipeDrainer(this, handle.Pass()));
 }
 
-CanvasImageDecoder::~CanvasImageDecoder() {
+void CanvasImageDecoder::initWithList(const Uint8List& list) {
+  CHECK(!drainer_);
+
+  OnDataAvailable(list.data(), list.num_elements());
+  OnDataComplete();
 }
 
 void CanvasImageDecoder::OnDataAvailable(const void* data, size_t num_bytes) {

sky/engine/core/loader/CanvasImageDecoder.h

@@ -11,6 +11,7 @@
 #include "sky/engine/core/loader/ImageDecoderCallback.h"
 #include "sky/engine/platform/SharedBuffer.h"
 #include "sky/engine/tonic/dart_wrappable.h"
+#include "sky/engine/tonic/uint8_list.h"
 #include "sky/engine/wtf/OwnPtr.h"
 #include "sky/engine/wtf/text/AtomicString.h"
 
@@ -21,15 +22,18 @@ class CanvasImageDecoder : public mojo::common::DataPipeDrainer::Client,
                            public DartWrappable {
   DEFINE_WRAPPERTYPEINFO();
  public:
-  static PassRefPtr<CanvasImageDecoder> create(mojo::ScopedDataPipeConsumerHandle handle, PassOwnPtr<ImageDecoderCallback> callback);
+  static PassRefPtr<CanvasImageDecoder> create(PassOwnPtr<ImageDecoderCallback> callback);
   virtual ~CanvasImageDecoder();
 
   // mojo::common::DataPipeDrainer::Client
   void OnDataAvailable(const void*, size_t) override;
   void OnDataComplete() override;
 
+  void initWithConsumer(mojo::ScopedDataPipeConsumerHandle handle);
+  void initWithList(const Uint8List& list);
+
  private:
-  CanvasImageDecoder(mojo::ScopedDataPipeConsumerHandle handle, PassOwnPtr<ImageDecoderCallback> callback);
+  CanvasImageDecoder(PassOwnPtr<ImageDecoderCallback> callback);
 
   void RejectCallback();
 

sky/engine/core/loader/ImageDecoder.idl

@@ -3,7 +3,9 @@
 // found in the LICENSE file.
 
 [
-  Constructor(MojoDataPipeConsumer consumer, ImageDecoderCallback callback),
+  Constructor(ImageDecoderCallback callback),
   ImplementedAs=CanvasImageDecoder,
 ] interface ImageDecoder {
+  void initWithConsumer(MojoDataPipeConsumer consumer);
+  void initWithList(Uint8List list);
 };

sky/engine/tonic/BUILD.gn

@@ -53,6 +53,8 @@ source_set("tonic") {
     "float32_list.cc",
     "float32_list.h",
     "mojo_converter.h",
+    "uint8_list.cc",
+    "uint8_list.h",
   ]
 
   deps = [

sky/engine/tonic/uint8_list.cc

+// Copyright 2015 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 "sky/engine/tonic/dart_error.h"
+#include "sky/engine/tonic/uint8_list.h"
+
+namespace blink {
+
+Uint8List::Uint8List(Dart_Handle list)
+    : data_(nullptr), num_elements_(0), dart_handle_(list) {
+  if (Dart_IsNull(list))
+    return;
+
+  Dart_TypedData_Type type;
+  Dart_TypedDataAcquireData(
+      list, &type, reinterpret_cast<void**>(&data_), &num_elements_);
+  DCHECK(!LogIfError(list));
+  ASSERT(type == Dart_TypedData_kUint8);
+}
+
+Uint8List::Uint8List(Uint8List&& other)
+    : data_(other.data_),
+      num_elements_(other.num_elements_),
+      dart_handle_(other.dart_handle_) {
+  other.data_ = nullptr;
+  other.dart_handle_ = nullptr;
+}
+
+Uint8List::~Uint8List() {
+  if (data_)
+    Dart_TypedDataReleaseData(dart_handle_);
+}
+
+Uint8List DartConverter<Uint8List>::FromArgumentsWithNullCheck(
+    Dart_NativeArguments args,
+    int index,
+    Dart_Handle& exception) {
+  Dart_Handle list = Dart_GetNativeArgument(args, index);
+  DCHECK(!LogIfError(list));
+
+  Uint8List result(list);
+  return result;
+}
+
+void DartConverter<Uint8List>::SetReturnValue(Dart_NativeArguments args,
+                                                Uint8List val) {
+  Dart_SetReturnValue(args, val.dart_handle());
+}
+
+
+} // namespace blink

sky/engine/tonic/uint8_list.h

+// Copyright 2015 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 SKY_ENGINE_TONIC_UINT8_LIST_H_
+#define SKY_ENGINE_TONIC_UINT8_LIST_H_
+
+#include "dart/runtime/include/dart_api.h"
+#include "sky/engine/tonic/dart_converter.h"
+
+namespace blink {
+
+// A simple wrapper around a Dart Uint8List. It uses Dart_TypedDataAcquireData
+// to obtain a raw pointer to the data, which is released when this object is
+// destroyed.
+//
+// This is designed to be used with DartConverter only.
+class Uint8List {
+ public:
+  explicit Uint8List(Dart_Handle list);
+  Uint8List(Uint8List&& other);
+  ~Uint8List();
+
+  uint8& at(intptr_t i)
+  {
+      CHECK(i < num_elements_);
+      return data_[i];
+  }
+  const uint8& at(intptr_t i) const
+  {
+      CHECK(i < num_elements_);
+      return data_[i];
+  }
+
+  uint8& operator[](intptr_t i) { return at(i); }
+  const uint8& operator[](intptr_t i) const { return at(i); }
+
+  const uint8* data() const { return data_; }
+  intptr_t num_elements() const { return num_elements_; }
+  Dart_Handle dart_handle() const { return dart_handle_; }
+
+ private:
+  uint8* data_;
+  intptr_t num_elements_;
+  Dart_Handle dart_handle_;
+
+  Uint8List(const Uint8List& other) = delete;
+};
+
+template <>
+struct DartConverter<Uint8List> {
+  static void SetReturnValue(Dart_NativeArguments args, Uint8List val);
+
+  static Uint8List FromArgumentsWithNullCheck(Dart_NativeArguments args,
+                                                int index,
+                                                Dart_Handle& exception);
+};
+
+} // namespace blink
+
+#endif  // SKY_ENGINE_TONIC_UINT8_LIST_H_

sky/packages/sky/lib/src/services/asset_bundle.dart

@@ -70,7 +70,8 @@ class MojoAssetBundle extends AssetBundle {
     return _imageCache.putIfAbsent(key, () {
       Completer<sky.Image> completer = new Completer<sky.Image>();
       load(key).then((assetData) {
-        new sky.ImageDecoder(assetData.handle.h, completer.complete);
+        new sky.ImageDecoder(completer.complete)
+               ..initWithConsumer(assetData.handle.h);
       });
       return new ImageResource(completer.future);
     });

sky/packages/sky/lib/src/services/image_cache.dart

@@ -23,7 +23,8 @@ class _ImageCache {
           print("Failed (${response.statusCode}) to load image ${url}");
           completer.complete(null);
         } else {
-          new sky.ImageDecoder(response.body.handle.h, completer.complete);
+          new sky.ImageDecoder(completer.complete)
+                 ..initWithConsumer(response.body.handle.h);
         }
       });
       return new ImageResource(completer.future);