Mojo C++ bindings: add a new mode to generator to use native STL/WTF types

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/macros.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/wtf_clone_equals_util.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 #include "third_party/WebKit/Source/wtf/Vector.h"
 
 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>;
@@ skipping 115 matching lines @@
   // "cloned" from the corresponding value of this array. If the element type
   // defines a Clone() method, it will be used; otherwise copy
   // constructor/assignment will be used.
   //
   // Please note that calling this method will fail compilation if the element
   // type cannot be cloned (which usually means that it is a Mojo handle type or
   // a type containing Mojo handles).
   WTFArray Clone() const {
     WTFArray result;
     result.is_null_ = is_null_;
-    result.vec_.reserveCapacity(vec_.size());
-    for (const auto& element : vec_)
-      result.vec_.append(internal::Clone(element));
+    result.vec_ = internal::Clone(vec_);
     return result;
   }
 
   // Indicates whether the contents of this array are equal to |other|. A null
   // array is only equal to another null array. If the element type defines an
   // Equals() method, it will be used; otherwise == operator will be used.
   bool Equals(const WTFArray& other) const {
     if (is_null() != other.is_null())
       return false;
-    if (size() != other.size())
-      return false;
-    for (size_t i = 0; i < size(); ++i) {
-      if (!internal::Equals(at(i), other.at(i)))
-        return false;
-    }
-    return true;
+    return internal::Equals(vec_, other.vec_);
   }
 
  private:
   // TODO(dcheng): Use an explicit conversion operator.
   typedef WTF::Vector<T> WTFArray::*Testable;
 
  public:
   operator Testable() const {
     // When the array is set to null, the underlying storage |vec_| shouldn't
     // contain any elements.
@@ skipping 16 matching lines @@
 
   WTF::Vector<T> vec_;
   bool is_null_;
 
   DISALLOW_COPY_AND_ASSIGN(WTFArray);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_WTF_ARRAY_H_