Mojo: Implement support for |Foo&| mojom syntax

mojo/public/cpp/bindings/interface_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_INTERFACE_PTR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_PTR_H_
 
 #include <assert.h>
 
 #include <algorithm>
 
 #include "mojo/public/cpp/bindings/error_handler.h"
 #include "mojo/public/cpp/bindings/lib/interface_ptr_internal.h"
 #include "mojo/public/cpp/system/macros.h"
 
 namespace mojo {
 class ErrorHandler;
 
 // InterfacePtr represents a proxy to a remote instance of an interface.
 template <typename Interface>
 class InterfacePtr {
   MOJO_MOVE_ONLY_TYPE_FOR_CPP_03(InterfacePtr, RValue)
  public:
   InterfacePtr() {}
 
   InterfacePtr(RValue other) {
-    other.object->internal_state_.Swap(&internal_state_);
+    internal_state_.Swap(&other.object->internal_state_);
   }
   InterfacePtr& operator=(RValue other) {
-    other.object->internal_state_.Swap(&internal_state_);
+    reset();
+    internal_state_.Swap(&other.object->internal_state_);
     return *this;
   }
 
   ~InterfacePtr() {}
 
   Interface* get() const {
     return internal_state_.instance();
   }
   Interface* operator->() const { return get(); }
-  Interface* operator*() const { return get(); }
+  Interface& operator*() const { return *get(); }
 
   void reset() {
     State doomed;
     internal_state_.Swap(&doomed);
   }
 
   // This method configures the InterfacePtr<..> to be a proxy to a remote
   // object on the other end of the given pipe.
   //
   // The proxy is bound to the current thread, which means its methods may
@@ skipping 26 matching lines @@
   // connection error on the underlying pipe. The callback runs asynchronously
   // from the current message loop.
   void set_error_handler(ErrorHandler* error_handler) {
     assert(internal_state_.router());
     internal_state_.router()->set_error_handler(error_handler);
   }
 
   // Returns the underlying message pipe handle (if any) and resets the
   // InterfacePtr<..> to its uninitialized state. This method is helpful if you
   // need to move a proxy to another thread. See related notes for Bind.
-  ScopedMessagePipeHandle ResetAndReturnMessagePipe() {
+  ScopedMessagePipeHandle PassMessagePipe() {
     State state;
     internal_state_.Swap(&state);
     return state.router() ?
-        state.router()->ReleaseMessagePipe() : ScopedMessagePipeHandle();
+        state.router()->PassMessagePipe() : ScopedMessagePipeHandle();
   }
 
   // DO NOT USE. Exposed only for internal use and for testing.
   internal::InterfacePtrState<Interface>* internal_state() {
     return &internal_state_;
   }
 
  private:
   typedef internal::InterfacePtrState<Interface> State;
   State internal_state_;
@@ skipping 10 matching lines @@
     MojoAsyncWaiter* waiter = GetDefaultAsyncWaiter()) {
   InterfacePtr<Interface> ptr;
   if (handle.is_valid())
     ptr.Bind(handle.Pass(), waiter);
   return ptr.Pass();
 }
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_INTERFACE_PTR_H_