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

mojo/public/cpp/bindings/array.h

 // Copyright 2013 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_ARRAY_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_ARRAY_H_
 
 #include <stddef.h>
 #include <string.h>
 #include <algorithm>
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
 
 #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/clone_equals_util.h"
 #include "mojo/public/cpp/bindings/lib/template_util.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 
 namespace mojo {
 
 // Represents a moveable array with contents of type |T|. The array can be null,
 // meaning that no value has been assigned to it. Null is distinct from empty.
 template <typename T>
 class Array {
  public:
@@ skipping 101 matching lines @@
   }
 
   // Sets the array to empty (even if previously it was null.)
   void SetToEmpty() { resize(0); }
 
   // Returns a const reference to the |std::vector| managed by this class. If
   // the array is null, this will be an empty vector.
   const std::vector<T>& storage() const { return vec_; }
 
   // Passes the underlying storage and resets this array to null.
-  //
-  // TODO(yzshen): Consider changing this to a rvalue-ref-qualified conversion
-  // to std::vector<T> after we move to MSVC 2015.
   std::vector<T> PassStorage() {
     is_null_ = true;
     return std::move(vec_);
   }
 
+  operator const std::vector<T>&() const { return vec_; }
+
   void Swap(Array* other) {
     std::swap(is_null_, other->is_null_);
     vec_.swap(other->vec_);
   }
 
   // Swaps the contents of this array with the specified vector, making this
   // array non-null. Since the vector cannot represent null, it will just be
   // made empty if this array is null.
   void Swap(std::vector<T>* other) {
     is_null_ = false;
     vec_.swap(*other);
   }
 
   // Returns a copy of the array where each value of the new array has been
   // "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).
   Array Clone() const {
     Array result;
     result.is_null_ = is_null_;
-    result.vec_.reserve(vec_.size());
-    for (const auto& element : vec_)
-      result.vec_.push_back(internal::Clone(element));
-    return std::move(result);
+    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 Array& 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:
   typedef std::vector<T> Array::*Testable;
 
  public:
   operator Testable() const { return is_null_ ? 0 : &Array::vec_; }
 
  private:
   // Forbid the == and != operators explicitly, otherwise Array will be
@@ skipping 77 matching lines @@
   if (a.is_null())
     return !b.is_null();
   if (b.is_null())
     return false;
   return a.storage() < b.storage();
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_ARRAY_H_