Use WaitableEvents to wake up sync IPC waiting

ipc/ipc_mojo_bootstrap.cc

 // 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.
 
 #include "ipc/ipc_mojo_bootstrap.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
 #include <queue>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_task_runner_handle.h"
-#include "ipc/mojo_event.h"
 #include "mojo/public/cpp/bindings/associated_group.h"
 #include "mojo/public/cpp/bindings/associated_group_controller.h"
 #include "mojo/public/cpp/bindings/connector.h"
 #include "mojo/public/cpp/bindings/interface_endpoint_client.h"
 #include "mojo/public/cpp/bindings/interface_endpoint_controller.h"
 #include "mojo/public/cpp/bindings/interface_id.h"
 #include "mojo/public/cpp/bindings/message.h"
 #include "mojo/public/cpp/bindings/message_header_validator.h"
 #include "mojo/public/cpp/bindings/pipe_control_message_handler.h"
 #include "mojo/public/cpp/bindings/pipe_control_message_handler_delegate.h"
 #include "mojo/public/cpp/bindings/pipe_control_message_proxy.h"
-#include "mojo/public/cpp/bindings/sync_handle_watcher.h"
+#include "mojo/public/cpp/bindings/sync_event_watcher.h"
 
 namespace IPC {
 
 namespace {
 
 class ChannelAssociatedGroupController
     : public mojo::AssociatedGroupController,
       public mojo::MessageReceiver,
       public mojo::PipeControlMessageHandlerDelegate {
  public:
@@ skipping 384 matching lines @@
     friend class base::RefCountedThreadSafe<Endpoint>;
 
     ~Endpoint() override {
       controller_->lock_.AssertAcquired();
       DCHECK(!client_);
       DCHECK(closed_);
       DCHECK(peer_closed_);
       DCHECK(!sync_watcher_);
     }
 
-    void OnSyncMessageEventHandleReady(MojoResult result) {
+    void OnSyncMessageEventReady() {
       DCHECK(task_runner_->BelongsToCurrentThread());
 
       scoped_refptr<Endpoint> keepalive(this);
       scoped_refptr<AssociatedGroupController> controller_keepalive(
           controller_);
 
       bool reset_sync_watcher = false;
       {
         base::AutoLock locker(controller_->lock_);
         bool more_to_process = false;
@@ skipping 34 matching lines @@
     }
 
     void EnsureSyncWatcherExists() {
       DCHECK(task_runner_->BelongsToCurrentThread());
       if (sync_watcher_)
         return;
 
       {
         base::AutoLock locker(controller_->lock_);
         if (!sync_message_event_) {
-          sync_message_event_.reset(new MojoEvent);
+          sync_message_event_ = base::MakeUnique<base::WaitableEvent>(
+              base::WaitableEvent::ResetPolicy::MANUAL,
+              base::WaitableEvent::InitialState::NOT_SIGNALED);
           if (peer_closed_ || !sync_messages_.empty())
             SignalSyncMessageEvent();
         }
       }
 
-      sync_watcher_.reset(new mojo::SyncHandleWatcher(
-          sync_message_event_->GetHandle(), MOJO_HANDLE_SIGNAL_READABLE,
-          base::Bind(&Endpoint::OnSyncMessageEventHandleReady,
-                     base::Unretained(this))));
-    }
-
-    void EnsureSyncMessageEventExists() {
-      controller_->lock_.AssertAcquired();
-      if (!sync_message_event_)
-        sync_message_event_.reset(new MojoEvent);
+      sync_watcher_ = base::MakeUnique<mojo::SyncEventWatcher>(
+          sync_message_event_.get(),
+          base::Bind(&Endpoint::OnSyncMessageEventReady,
+                     base::Unretained(this)));
     }
 
     uint32_t GenerateSyncMessageId() {
       // Overflow is fine.
       uint32_t id = next_sync_message_id_++;
       DCHECK(sync_messages_.empty() || sync_messages_.front().first != id);
       return id;
     }
 
     ChannelAssociatedGroupController* const controller_;
     const mojo::InterfaceId id_;
 
     bool closed_ = false;
     bool peer_closed_ = false;
     bool handle_created_ = false;
     base::Optional<mojo::DisconnectReason> disconnect_reason_;
     mojo::InterfaceEndpointClient* client_ = nullptr;
     scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
-    std::unique_ptr<mojo::SyncHandleWatcher> sync_watcher_;
-    std::unique_ptr<MojoEvent> sync_message_event_;
+    std::unique_ptr<mojo::SyncEventWatcher> sync_watcher_;
+    std::unique_ptr<base::WaitableEvent> sync_message_event_;
     std::queue<std::pair<uint32_t, MessageWrapper>> sync_messages_;
     uint32_t next_sync_message_id_ = 0;
 
     DISALLOW_COPY_AND_ASSIGN(Endpoint);
   };
 
   class ControlMessageProxyThunk : public MessageReceiver {
    public:
     explicit ControlMessageProxyThunk(
         ChannelAssociatedGroupController* controller)
@@ skipping 380 matching lines @@
 std::unique_ptr<MojoBootstrap> MojoBootstrap::Create(
     mojo::ScopedMessagePipeHandle handle,
     Channel::Mode mode,
     const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner) {
   return base::MakeUnique<MojoBootstrapImpl>(
       std::move(handle), new ChannelAssociatedGroupController(
                              mode == Channel::MODE_SERVER, ipc_task_runner));
 }
 
 }  // namespace IPC