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 <memory>
 #include <new>
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/optional.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 Struct>
 class StructPtrWTFHelper;
 
 template <typename Struct>
 class InlinedStructPtrWTFHelper;
 
 }  // namespace internal
 
 // Smart pointer wrapping a mojom structure with move-only semantics.
 template <typename S>
 class StructPtr {
  public:
   using Struct = S;
 
-  StructPtr() : ptr_(nullptr) {}
-  StructPtr(decltype(nullptr)) : ptr_(nullptr) {}
+  StructPtr() = default;
+  StructPtr(decltype(nullptr)) {}
 
-  ~StructPtr() { delete ptr_; }
+  ~StructPtr() = default;
 
   StructPtr& operator=(decltype(nullptr)) {
     reset();
     return *this;
   }
 
-  StructPtr(StructPtr&& other) : ptr_(nullptr) { Take(&other); }
+  StructPtr(StructPtr&& other) { Take(&other); }
   StructPtr& operator=(StructPtr&& other) {
     Take(&other);
     return *this;
   }
 
+  template <typename... Args>
+  StructPtr(base::in_place_t, Args&&... args)
+      : ptr_(new Struct(std::forward<Args>(args)...)) {}
+
   template <typename U>
   U To() const {
     return TypeConverter<U, StructPtr>::Convert(*this);
   }
 
-  void reset() {
-    if (ptr_) {
-      delete ptr_;
-      ptr_ = nullptr;
-    }
-  }
+  void reset() { ptr_.reset(); }
 
-  bool is_null() const { return ptr_ == nullptr; }
+  bool is_null() const { return !ptr_; }
 
   Struct& operator*() const {
     DCHECK(ptr_);
     return *ptr_;
   }
   Struct* operator->() const {
     DCHECK(ptr_);
-    return ptr_;
+    return ptr_.get();
   }
-  Struct* get() const { return ptr_; }
+  Struct* get() const { return ptr_.get(); }
 
   void Swap(StructPtr* other) { std::swap(ptr_, other->ptr_); }
 
   // Please note that calling this method will fail compilation if the value
   // type |Struct| doesn't have a Clone() method defined (which usually means
   // that it contains Mojo handles).
   StructPtr Clone() const { return is_null() ? StructPtr() : ptr_->Clone(); }
 
   // Compares the pointees (which might both be null).
   // TODO(tibell): Get rid of Equals in favor of the operator. Same for Hash.
   bool Equals(const StructPtr& other) const {
     if (is_null() || other.is_null())
       return is_null() && other.is_null();
     return ptr_->Equals(*other.ptr_);
   }
 
   // Hashes based on the pointee (which might be null).
   size_t Hash(size_t seed) const {
     if (is_null())
       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() {
-    DCHECK(!ptr_);
-    ptr_ = new Struct();
-  }
-
   void Take(StructPtr* other) {
     reset();
     Swap(other);
   }
 
-  Struct* ptr_;
+  std::unique_ptr<Struct> ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(StructPtr);
 };
 
 template <typename T>
 bool operator==(const StructPtr<T>& lhs, const StructPtr<T>& rhs) {
   return lhs.Equals(rhs);
 }
 template <typename T>
 bool operator!=(const StructPtr<T>& lhs, const StructPtr<T>& rhs) {
@@ skipping 15 matching lines @@
     reset();
     return *this;
   }
 
   InlinedStructPtr(InlinedStructPtr&& other) : state_(NIL) { Take(&other); }
   InlinedStructPtr& operator=(InlinedStructPtr&& other) {
     Take(&other);
     return *this;
   }
 
+  template <typename... Args>
+  InlinedStructPtr(base::in_place_t, Args&&... args)
+      : value_(std::forward<Args>(args)...), state_(VALID) {}
+
   template <typename U>
   U To() const {
     return TypeConverter<U, InlinedStructPtr>::Convert(*this);
   }
 
   void reset() {
     state_ = NIL;
     value_. ~Struct();
     new (&value_) Struct();
   }
@@ skipping 29 matching lines @@
   // Hashes based on the pointee (which might be null).
   size_t Hash(size_t seed) const {
     if (is_null())
       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; }
-
   void Take(InlinedStructPtr* other) {
     reset();
     Swap(other);
   }
 
   enum State {
     VALID,
     NIL,
     DELETED,  // For use in WTF::HashMap only
   };
@@ skipping 67 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_