Add field-initializing constructors to generated mojo structs.

mojo/public/cpp/bindings/struct_ptr.h

 // Copyright 2014 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_STRUCT_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_STRUCT_PTR_H_
 
 #include <functional>
 #include <new>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "mojo/public/cpp/bindings/lib/hash_util.h"
 #include "mojo/public/cpp/bindings/type_converter.h"
 
 namespace mojo {
 namespace internal {
 
 constexpr size_t kHashSeed = 31;
 
 template <typename Struct>
 class StructHelper {
  public:
-  template <typename Ptr>
-  static void Initialize(Ptr* ptr) {
-    ptr->Initialize();
+  template <typename Ptr, typename... Args>
+  static void Initialize(Ptr* ptr, Args&&... args) {
+    ptr->Initialize(std::forward<Args>(args)...);
   }
 };
 
 template <typename Struct>
 class StructPtrWTFHelper;
 
 template <typename Struct>
 class InlinedStructPtrWTFHelper;
 
 }  // namespace internal
@@ skipping 65 matching lines @@
       return internal::HashCombine(seed, 0);
     return ptr_->Hash(seed);
   }
 
   explicit operator bool() const { return !is_null(); }
 
  private:
   friend class internal::StructHelper<Struct>;
   friend class internal::StructPtrWTFHelper<Struct>;
 
-  void Initialize() {
+  template <typename... Args>
+  void Initialize(Args&&... args) {
     DCHECK(!ptr_);
-    ptr_ = new Struct();
+    ptr_ = new Struct(std::forward<Args>(args)...);
   }
 
   void Take(StructPtr* other) {
     reset();
     Swap(other);
   }
 
   Struct* ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(StructPtr);
@@ skipping 75 matching lines @@
       return internal::HashCombine(seed, 0);
     return value_.Hash(seed);
   }
 
   explicit operator bool() const { return !is_null(); }
 
  private:
   friend class internal::StructHelper<Struct>;
   friend class internal::InlinedStructPtrWTFHelper<Struct>;
 
-  void Initialize() { state_ = VALID; }
+  template <typename... Args>
+  void Initialize(Args&&... args) {
+    state_ = VALID;
+    value_.~Struct();

[yzshen1, 2017/02/13 17:45:53]

It seems we always default construct value_, destruct it and re-construct it
(with/without) arguments. Could we optimize it?

[Sam McNally, 2017/02/14 02:32:24]

Done.

+    new (&value_) Struct(std::forward<Args>(args)...);
+  }
 
   void Take(InlinedStructPtr* other) {
     reset();
     Swap(other);
   }
 
   enum State {
     VALID,
     NIL,
     DELETED,  // For use in WTF::HashMap only
@@ skipping 68 matching lines @@
 template <typename T>
 struct hash<mojo::InlinedStructPtr<T>> {
   size_t operator()(const mojo::InlinedStructPtr<T>& value) const {
     return value.Hash(mojo::internal::kHashSeed);
   }
 };
 
 }  // namespace std
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_STRUCT_PTR_H_