Allow constructing {Interface,Struct}Ptr from nullptr

mojo/public/cpp/system/handle.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_SYSTEM_HANDLE_H_
 #define MOJO_PUBLIC_CPP_SYSTEM_HANDLE_H_
 
 #include <assert.h>
 #include <limits>
 
@@ skipping 66 matching lines @@
 //
 // Other |...Raw()| functions expose similar rough edges, e.g., dealing with raw
 // pointers (and lengths) instead of taking |std::vector|s or similar.
 
 // ScopedHandleBase ------------------------------------------------------------
 
 // Scoper for the actual handle types defined further below. It's move-only,
 // like the C++11 |unique_ptr|.
 template <class HandleType>
 class ScopedHandleBase {
-  MOJO_MOVE_ONLY_TYPE_FOR_CPP_03(ScopedHandleBase, RValue)
+  MOJO_MOVE_ONLY_TYPE(ScopedHandleBase)
 
  public:
   ScopedHandleBase() {}
   explicit ScopedHandleBase(HandleType handle) : handle_(handle) {}
   ~ScopedHandleBase() { CloseIfNecessary(); }
 
   template <class CompatibleHandleType>
   explicit ScopedHandleBase(ScopedHandleBase<CompatibleHandleType> other)
       : handle_(other.release()) {}
 
   // Move-only constructor and operator=.
-  ScopedHandleBase(RValue other) : handle_(other.object->release()) {}
-  ScopedHandleBase& operator=(RValue other) {
-    if (other.object != this) {
+  ScopedHandleBase(ScopedHandleBase&& other) : handle_(other.release()) {}
+  ScopedHandleBase& operator=(ScopedHandleBase&& other) {
+    if (&other != this) {
       CloseIfNecessary();
-      handle_ = other.object->release();
+      handle_ = other.release();
     }
     return *this;
   }
 
   const HandleType& get() const { return handle_; }
 
   template <typename PassedHandleType>
   static ScopedHandleBase<HandleType> From(
       ScopedHandleBase<PassedHandleType> other) {
     static_assert(
@@ skipping 182 matching lines @@
 }
 
 // Strict weak ordering, so that |Handle|s can be used as keys in |std::map|s,
 inline bool operator<(const Handle a, const Handle b) {
   return a.value() < b.value();
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_SYSTEM_HANDLE_H_