Mojo C++ bindings: switch the generated code of clipboard.mojom to use STL 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 "base/optional.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/hash_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,
@@ skipping 15 matching lines @@
   Array(std::nullptr_t null_pointer) : is_null_(true) {}
 
   // Constructs a new non-null array of the specified size. The elements will
   // be value-initialized (meaning that they will be initialized by their
   // default constructor, if any, or else zero-initialized).
   explicit Array(size_t size) : vec_(size), is_null_(false) {}
   ~Array() {}
 
   // Copies the contents of |other| into this array.
   Array(const std::vector<T>& other) : vec_(other), is_null_(false) {}
+  Array(const base::Optional<std::vector<T>>& other)

[sky, 2016/11/18 00:41:55]

Is it typical not to use explicit for this and 58?

[yzshen1, 2016/11/18 00:48:09]

Non-explicit makes the transition easier. Because the long-term goal is to
remove mojo::Array entirely, I think this is okay.

WDYT? Thanks!

+      : vec_(other.value_or(std::vector<T>())), is_null_(!other) {}
 
   // Moves the contents of |other| into this array.
   Array(std::vector<T>&& other) : vec_(std::move(other)), is_null_(false) {}
+  Array(base::Optional<std::vector<T>>&& other) : is_null_(!other) {
+    if (!is_null_)
+      vec_ = std::move(other.value());
+  }
   Array(Array&& other) : is_null_(true) { Take(&other); }
 
   Array& operator=(std::vector<T>&& other) {
     vec_ = std::move(other);
     is_null_ = false;
     return *this;
   }
+  Array& operator=(base::Optional<std::vector<T>>&& other) {
+    is_null_ = !other;
+    vec_ = std::move(other).value_or(std::vector<T>());
+    return *this;
+  }
   Array& operator=(Array&& other) {
     Take(&other);
     return *this;
   }
 
   Array& operator=(std::nullptr_t null_pointer) {
     is_null_ = true;
     vec_.clear();
     return *this;
   }
@@ skipping 70 matching lines @@
   // 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.
   std::vector<T> PassStorage() {
     is_null_ = true;
     return std::move(vec_);
   }
 
+  base::Optional<std::vector<T>> PassStorageAsOptional() {
+    base::Optional<std::vector<T>> result;
+    if (!is_null_)
+      result.emplace(std::move(vec_));
+    is_null_ = true;
+    return result;
+  }
+
   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.
@@ skipping 118 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_