Mojo: Move waiting APIs to public library

mojo/public/cpp/bindings/lib/connector.cc

 // Copyright 2013 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.
 
 #include "mojo/public/cpp/bindings/connector.h"
 
 #include <stdint.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/synchronization/lock.h"
 #include "mojo/public/cpp/bindings/lib/may_auto_lock.h"
 #include "mojo/public/cpp/bindings/sync_handle_watcher.h"
+#include "mojo/public/cpp/system/wait.h"
 
 namespace mojo {
 
 Connector::Connector(ScopedMessagePipeHandle message_pipe,
                      ConnectorConfig config,
                      scoped_refptr<base::SingleThreadTaskRunner> runner)
     : message_pipe_(std::move(message_pipe)),
       task_runner_(std::move(runner)),
       weak_factory_(this) {
   if (config == MULTI_THREADED_SEND)
@@ skipping 43 matching lines @@
 }
 
 bool Connector::WaitForIncomingMessage(MojoDeadline deadline) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (error_)
     return false;
 
   ResumeIncomingMethodCallProcessing();
 
-  MojoResult rv =
-      Wait(message_pipe_.get(), MOJO_HANDLE_SIGNAL_READABLE, deadline, nullptr);
-  if (rv == MOJO_RESULT_SHOULD_WAIT || rv == MOJO_RESULT_DEADLINE_EXCEEDED)
+  // TODO(rockot): Use a timed Wait here. Nobody uses anything but 0 or
+  // INDEFINITE deadlines at present, so we only support those.
+  DCHECK(deadline == 0 || deadline == MOJO_DEADLINE_INDEFINITE);
+
+  MojoResult rv = MOJO_RESULT_UNKNOWN;
+  if (deadline == 0 && !message_pipe_->QuerySignalsState().readable())
     return false;
-  if (rv != MOJO_RESULT_OK) {
-    // Users that call WaitForIncomingMessage() should expect their code to be
-    // re-entered, so we call the error handler synchronously.
-    HandleError(rv != MOJO_RESULT_FAILED_PRECONDITION, false);
-    return false;
+
+  if (deadline == MOJO_DEADLINE_INDEFINITE) {
+    rv = Wait(message_pipe_.get(), MOJO_HANDLE_SIGNAL_READABLE);
+    if (rv != MOJO_RESULT_OK) {
+      // Users that call WaitForIncomingMessage() should expect their code to be
+      // re-entered, so we call the error handler synchronously.
+      HandleError(rv != MOJO_RESULT_FAILED_PRECONDITION, false);
+      return false;
+    }
   }
+
   ignore_result(ReadSingleMessage(&rv));
   return (rv == MOJO_RESULT_OK);
 }
 
 void Connector::PauseIncomingMethodCallProcessing() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (paused_)
     return;
 
@@ skipping 270 matching lines @@
 void Connector::EnsureSyncWatcherExists() {
   if (sync_watcher_)
     return;
   sync_watcher_.reset(new SyncHandleWatcher(
       message_pipe_.get(), MOJO_HANDLE_SIGNAL_READABLE,
       base::Bind(&Connector::OnSyncHandleWatcherHandleReady,
                  base::Unretained(this))));
 }
 
 }  // namespace mojo