mojo: Make InterfacePtr<> testable in if() statements without .get().

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>
@@ skipping 86 matching lines @@
     State state;
     internal_state_.Swap(&state);
     return state.PassMessagePipe();
   }
 
   // DO NOT USE. Exposed only for internal use and for testing.
   internal::InterfacePtrState<Interface>* internal_state() {
     return &internal_state_;
   }
 
+  // Allow InterfacePtr<> to be used in boolean expressions, but not

[yzshen1, 2014/07/18 19:17:43]

One thing that may worth considering:
I just landed a CL to make InterfacePtr<> do the setup work lazily: Bind() only
records the pipe and waiter; the internal ProxyWithStub/Rounter are constructed
only when the pointer is actually used. (Please see
https://code.google.com/p/chromium/issues/detail?id=394883 for why this is
needed.)

Calling get() is one way of "actually using" the InterfacePtr<> and doing all
the setup.

Therefore, it seems nice if we can avoid get() in Testable(), instead we test
whether it has been bound. What do you think?

[Elliot Glaysher, 2014/07/18 19:32:15]

What do you propose replacing get() with?

[yzshen1, 2014/07/18 19:38:45]

Maybe an IsBound() method on the internal state, which checks
(handle_.is_valid() || router).

+  // implicitly convertible to a real bool (which is dangerous).
+ private:
+  typedef internal::InterfacePtrState<Interface> InterfacePtr::*Testable;
+
+ public:
+  operator Testable() const {
+    return get() ? &InterfacePtr::internal_state_ : NULL;
+  }
+
  private:
   typedef internal::InterfacePtrState<Interface> State;
   mutable State internal_state_;
 };
 
 // Takes a handle to the proxy end-point of a pipe. On the other end is
 // presumed to be an interface implementation of type |Interface|. Returns a
 // generated proxy to that interface, which may be used on the current thread.
 // It is valid to call set_client on the returned InterfacePtr<..> to set an
 // instance of Interface::Client.
 template <typename Interface>
 InterfacePtr<Interface> MakeProxy(
     ScopedMessagePipeHandle handle,
     const MojoAsyncWaiter* waiter = Environment::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_