Allow constructing {Interface,Struct}Ptr from nullptr

mojo/public/cpp/bindings/map.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_MAP_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_MAP_H_
 
 #include <map>
 
 #include "mojo/public/cpp/bindings/lib/map_internal.h"
 
 namespace mojo {
 
 template <typename Key, typename Value>
 class Map {
-  MOJO_MOVE_ONLY_TYPE_FOR_CPP_03(Map, RValue)
+  MOJO_MOVE_ONLY_TYPE(Map)
+
  public:
   // Map keys can not be move only classes.
   static_assert(!internal::IsMoveOnlyType<Key>::value,
                 "Map keys can not be move only types.");
 
   typedef internal::MapTraits<Key,
                               Value,
                               internal::IsMoveOnlyType<Value>::value> Traits;
   typedef typename Traits::KeyStorageType KeyStorageType;
   typedef typename Traits::KeyRefType KeyRefType;
@@ skipping 11 matching lines @@
 
   Map() : is_null_(true) {}
 
   Map(mojo::Array<Key> keys, mojo::Array<Value> values) : is_null_(false) {
     MOJO_DCHECK(keys.size() == values.size());
     Traits::InitializeFrom(&map_, keys.Pass(), values.Pass());
   }
 
   ~Map() { Traits::Finalize(&map_); }
 
-  Map(RValue other) : is_null_(true) { Take(other.object); }
-  Map& operator=(RValue other) {
-    Take(other.object);
+  Map(Map&& other) : is_null_(true) { Take(&other); }
+  Map& operator=(Map&& other) {
+    Take(&other);
     return *this;
   }
 
   template <typename U>
   static Map From(const U& other) {
     return TypeConverter<Map, U>::Convert(other);
   }
 
   template <typename U>
   U To() const {
@@ skipping 160 matching lines @@
             TypeConverter<STLValue, MojoValue>::Convert(it.GetValue())));
       }
     }
     return result;
   }
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_MAP_H_