Add support for linear gradients, implemented as skia shaders.

sky/engine/tonic/dart_converter.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_DART_CONVERTER_H_
 #define SKY_ENGINE_TONIC_DART_CONVERTER_H_
 
 #include <string>
 #include "sky/engine/tonic/dart_state.h"
 #include "sky/engine/tonic/dart_string.h"
 #include "sky/engine/tonic/dart_string_cache.h"
 #include "sky/engine/tonic/dart_value.h"
 #include "sky/engine/wtf/text/StringUTF8Adaptor.h"
 #include "sky/engine/wtf/text/WTFString.h"
 
 namespace blink {
 
 // DartConvert converts types back and forth from Sky to Dart. The template
 // parameter |T| determines what kind of type conversion to perform.
 template <typename T, typename Enable = void>
-struct DartConverter {};
+struct DartConverter {
+};
+
+// This is to work around the fact that typedefs do not create new types. If you
+// have a typedef, and want it to use a different converter, specialize this
+// template and override the types here.
+// Ex:
+//   typedef int ColorType;  // Want to use a different converter.
+//   class ColorConverterType {};  // Dummy type.
+//   template<> struct DartConvertType<ColorConverterType> {
+//     using ConverterType = ColorConverterType;
+//     using ValueType = ColorType;
+//   };
+template <typename T>
+struct DartConverterTypes {
+  using ConverterType = T;
+  using ValueType = T;
+};
 
 ////////////////////////////////////////////////////////////////////////////////
 // Boolean
 
 template <>
 struct DartConverter<bool> {
   static Dart_Handle ToDart(bool val) { return Dart_NewBoolean(val); }
 
   static void SetReturnValue(Dart_NativeArguments args, bool val) {
     Dart_SetBooleanReturnValue(args, val);
@@ skipping 188 matching lines @@
   static Dart_Handle ToDart(DartState* state, const AtomicString& val) {
     return DartConverter<String>::ToDart(state, val.string());
   }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // Collections
 
 template <typename T>
 struct DartConverter<Vector<T>> {
-  static Dart_Handle ToDart(const Vector<T>& val) {
+  using ValueType = typename DartConverterTypes<T>::ValueType;
+  using ConverterType = typename DartConverterTypes<T>::ConverterType;
+
+  static Dart_Handle ToDart(const Vector<ValueType>& val) {
     Dart_Handle list = Dart_NewList(val.size());
     if (Dart_IsError(list))
       return list;
     for (size_t i = 0; i < val.size(); i++) {
       Dart_Handle result =
-          Dart_ListSetAt(list, i, DartConverter<T>::ToDart(val[i]));
+          Dart_ListSetAt(list, i,
+                         DartConverter<ConverterType>::ToDart(val[i]));
       if (Dart_IsError(result))
         return result;
     }
     return list;
   }
 
-  static Vector<T> FromDart(Dart_Handle handle) {
-    Vector<T> result;
+  static Vector<ValueType> FromDart(Dart_Handle handle) {
+    Vector<ValueType> result;
     if (!Dart_IsList(handle))
       return result;
     intptr_t length = 0;
     Dart_ListLength(handle, &length);
     result.reserveCapacity(length);
     for (intptr_t i = 0; i < length; ++i) {
       Dart_Handle item = Dart_ListGetAt(handle, i);
       DCHECK(!Dart_IsError(item));
       DCHECK(item);
-      result.append(DartConverter<T>::FromDart(item));
+      result.append(DartConverter<ConverterType>::FromDart(item));
     }
     return result;
   }
 
-  static Vector<T> FromArguments(Dart_NativeArguments args,
-                                 int index,
-                                 Dart_Handle& exception,
-                                 bool auto_scope = true) {
+  static Vector<ValueType> FromArguments(Dart_NativeArguments args,
+                                          int index,
+                                          Dart_Handle& exception,
+                                          bool auto_scope = true) {
     // TODO(abarth): What should we do with auto_scope?
     return FromDart(Dart_GetNativeArgument(args, index));
   }
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // DartValue
 
 template <>
 struct DartConverter<DartValue*> {
@@ skipping 62 matching lines @@
 
 
 // Alias Dart_NewStringFromCString for less typing.
 inline Dart_Handle ToDart(const char* val) {
   return Dart_NewStringFromCString(val);
 }
 
 }  // namespace blink
 
 #endif  // SKY_ENGINE_TONIC_DART_CONVERTER_H_