Allow constructing {Interface,Struct}Ptr from nullptr

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 <new>
 
 #include "mojo/public/cpp/bindings/type_converter.h"
 #include "mojo/public/cpp/environment/logging.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 namespace internal {
 
 template <typename Struct>
 class StructHelper {
  public:
   template <typename Ptr>
   static void Initialize(Ptr* ptr) {
     ptr->Initialize();
   }
 };
 
 }  // namespace internal
 
 template <typename Struct>
 class StructPtr {
-  MOJO_MOVE_ONLY_TYPE_FOR_CPP_03(StructPtr, RValue);
+  MOJO_MOVE_ONLY_TYPE(StructPtr)
 
  public:
 
   StructPtr() : ptr_(nullptr) {}
+  StructPtr(decltype(nullptr)) : ptr_(nullptr) {}
+
   ~StructPtr() { delete ptr_; }
 
-  StructPtr(RValue other) : ptr_(nullptr) { Take(other.object); }
-  StructPtr& operator=(RValue other) {
-    Take(other.object);
+  StructPtr& operator=(decltype(nullptr)) {
+    reset();
     return *this;
   }
 
+  StructPtr(StructPtr&& other) : ptr_(nullptr) { Take(&other); }
+  StructPtr& operator=(StructPtr&& other) {
+    Take(&other);
+    return *this;
+  }
+
   template <typename U>
   U To() const {
     return TypeConverter<U, StructPtr>::Convert(*this);
   }
 
   void reset() {
     if (ptr_) {
       delete ptr_;
       ptr_ = nullptr;
     }
@@ skipping 41 matching lines @@
     reset();
     Swap(other);
   }
 
   Struct* ptr_;
 };
 
 // Designed to be used when Struct is small and copyable.
 template <typename Struct>
 class InlinedStructPtr {
-  MOJO_MOVE_ONLY_TYPE_FOR_CPP_03(InlinedStructPtr, RValue);
+  MOJO_MOVE_ONLY_TYPE(InlinedStructPtr);
 
  public:
 
   InlinedStructPtr() : is_null_(true) {}
   ~InlinedStructPtr() {}
 

[darin (slow to review), 2015/01/14 18:38:07]

don't you need the nullptr ctor and assignment operator here too?

[jamesr, 2015/01/14 18:39:30]

Hmm yes - I didn't find a user of this but it'd be nice to use here as well. 
Will add and find somewhere to use it.

-  InlinedStructPtr(RValue other) : is_null_(true) { Take(other.object); }
-  InlinedStructPtr& operator=(RValue other) {
-    Take(other.object);
+  InlinedStructPtr(InlinedStructPtr&& other) : is_null_(true) { Take(&other); }
+  InlinedStructPtr& operator=(InlinedStructPtr&& other) {
+    Take(&other);
     return *this;
   }
 
   template <typename U>
   U To() const {
     return TypeConverter<U, InlinedStructPtr>::Convert(*this);
   }
 
   void reset() {
     is_null_ = true;
@@ skipping 42 matching lines @@
     Swap(other);
   }
 
   mutable Struct value_;
   bool is_null_;
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_STRUCT_PTR_H_