PaymentRequest Mojo bindings.

mojo/public/cpp/bindings/wtf_array.h

 // 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.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_WTF_ARRAY_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_WTF_ARRAY_H_
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/move.h"
 #include "mojo/public/cpp/bindings/lib/array_internal.h"
 #include "mojo/public/cpp/bindings/lib/bindings_internal.h"
 #include "mojo/public/cpp/bindings/lib/template_util.h"
 #include "mojo/public/cpp/bindings/lib/value_traits.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 #include "third_party/WebKit/Source/wtf/Vector.h"
 
+namespace blink {
+class HeapAllocator;
+}
+
 namespace mojo {
 
 // Represents an array backed by WTF::Vector. Comparing with WTF::Vector,
 // mojo::WTFArray is move-only and can be null.
 // It is easy to convert between WTF::Vector<T> and mojo::WTFArray<T>:
 //   - constructor WTFArray(WTF::Vector<T>&&) takes the contents of a
 //     WTF::Vector<T>;
 //   - method PassStorage() passes the underlying WTF::Vector.
 template <typename T>
 class WTFArray {
@@ skipping 194 matching lines @@
 
   void Take(WTFArray* other) {
     operator=(nullptr);
     Swap(other);
   }
 
   WTF::Vector<T> vec_;
   bool is_null_;
 };
 
+// A |TypeConverter| that will create a |WTFArray<T>| containing a copy of the
+// contents of a |WTF::Vector<E, 0, blink::HeapAllocator>|, using
+// |TypeConverter<T, E>| to copy each element. The returned array will always be
+// non-null.
+template <typename T, typename E>
+struct TypeConverter<WTFArray<T>, WTF::Vector<E, 0, blink::HeapAllocator>> {

[yzshen1, 2016/03/29 22:49:31]

Is it a common operation to use a non-default allocator? It is unfortunate
because it requires a deep copy. :/

Can this converter be generalized to have the allocator as a template parameter
as well? That way we don't have to have blink::HeapAllocator here which seems a
little weird?

An alternative is to consider putting it somewhere inside blink, because mojo
bindings itself doesn't need this converter, putting it inside blink reduces
what the bindings has to know about blink.

WDYT? Thanks!

[please use gerrit instead, 2016/03/29 23:08:11]

The blink::HeapAllocator is used in blink::HeapVector<E>, which is a subclass of
WTF::Vector<E, 0, blink::HeapAllocator>. That's the type used by code generated
from WebIDL. These objects represent their JavaScript counterparts. See:

https://code.google.com/p/chromium/codesearch#chromium/src/out/Debug/gen/blin...

...for an example of a blink::HeapVector<E> generated from:

https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...
Why does this require a deep copy?
Unfortunately, "struct TypeConverter" needs to be a template of exactly two
typenames. See:

https://code.google.com/p/chromium/codesearch#chromium/src/mojo/public/cpp/bi...
I'm OK with that.

esprehn@: where would be a good place for such a common code?

[yzshen1, 2016/03/29 23:20:15]

I mean, this TypeConverter is a deep copy.
The TypeConverter takes exactly two template parameters, but I think you can do:

template <typename T, typename E, typename Allocator>
struct TypeConverter<WTFArray<T>, WTF::Vector<E, 0, Allocator>> {
};

+  static WTFArray<T> Convert(
+      const WTF::Vector<E, 0, blink::HeapAllocator>& input) {
+    WTFArray<T> result(input.size());
+    for (size_t i = 0; i < input.size(); ++i)
+      result[i] = TypeConverter<T, E>::Convert(input[i]);
+    return std::move(result);
+  }
+};
+
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_WTF_ARRAY_H_