Gather trace data by waiting on handles with a fixed timeout

mojo/public/cpp/bindings/binding.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_BINDING_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_BINDING_H_
 
 #include "mojo/public/c/environment/async_waiter.h"
 #include "mojo/public/cpp/bindings/error_handler.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
@@ skipping 129 matching lines @@
   // implementation by removing the message pipe endpoint from |request| and
   // binding it to the previously specified implementation. See class comment
   // for definition of |waiter|.
   void Bind(
       InterfaceRequest<Interface> request,
       const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter()) {
     Bind(request.PassMessagePipe(), waiter);
   }
 
   // Blocks the calling thread until either a call arrives on the previously
-  // bound message pipe, or an error occurs.
-  bool WaitForIncomingMethodCall() {
+  // bound message pipe, the deadline is exceeded, or an error occurs. Returns
+  // true if a method was successfully read and dispatched.
+  bool WaitForIncomingMethodCall(
+      MojoDeadline deadline = MOJO_DEADLINE_INDEFINITE) {
     MOJO_DCHECK(internal_router_);
-    return internal_router_->WaitForIncomingMessage();
+    return internal_router_->WaitForIncomingMessage(deadline);
   }
 
   // Closes the message pipe that was previously bound. Put this object into a
   // state where it can be rebound to a new pipe.
   void Close() {
     MOJO_DCHECK(internal_router_);
     internal_router_->CloseMessagePipe();
     DestroyRouter();
   }
 
@@ skipping 23 matching lines @@
   }
 
   // Returns the interface implementation that was previously specified. Caller
   // does not take ownership.
   Interface* impl() { return impl_; }
 
   // Indicates whether the binding has been completed (i.e., whether a message
   // pipe has been bound to the implementation).
   bool is_bound() const { return !!internal_router_; }
 
+  // Returns the value of the handle currently bound to this Binding which can
+  // be used to make explicit Wait/WaitMany calls. Requires that the Binding be
+  // bound. Ownership of the handle is retained by the Binding, it is not
+  // transferred to the caller.
+  MessagePipeHandle handle() const {
+    MOJO_DCHECK(is_bound());
+    return internal_router_->handle();
+  }
+
   // Exposed for testing, should not generally be used.
   internal::Router* internal_router() { return internal_router_; }
 
  private:
   void DestroyRouter() {
     internal_router_->set_error_handler(nullptr);
     delete internal_router_;
     internal_router_ = nullptr;
   }
 
   internal::Router* internal_router_ = nullptr;
   typename Interface::Stub_ stub_;
   Interface* impl_;
   ErrorHandler* error_handler_ = nullptr;
 
   MOJO_DISALLOW_COPY_AND_ASSIGN(Binding);
 };
 
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_BINDING_H_