Simplify SyncChannel message pumping event

ipc/ipc_sync_channel.cc

 // Copyright (c) 2012 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_sync_channel.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 31 matching lines @@
 
 // A ReadyCallback for use with mojo::Watcher. Ignores the result (DCHECKs, but
 // is only used in cases where failure should be impossible) and runs
 // |callback|.
 void RunOnHandleReady(const base::Closure& callback, MojoResult result) {
   DCHECK(result == MOJO_RESULT_OK || result == MOJO_RESULT_ABORTED);
   if (result == MOJO_RESULT_OK)
     callback.Run();
 }
 
-}  // namespace
-
-// A lazy thread-local Mojo Event which is always signaled. Used to wake up the
-// sync waiter when a SyncMessage requires the MessageLoop to be pumped while
-// waiting for a reply. This object is created lazily and ref-counted so it can
-// be cleaned up when no longer in use.
-class SyncChannel::PumpMessagesEvent
-    : public base::RefCountedThreadSafe<PumpMessagesEvent> {
+class PumpMessagesEvent {
  public:
-  static scoped_refptr<PumpMessagesEvent> current() {
-    scoped_refptr<PumpMessagesEvent> current = current_event_.Pointer()->Get();
-    if (!current) {
-      current = new PumpMessagesEvent;
-      current_event_.Pointer()->Set(current.get());
-    }
-    return current;
-  }
+  PumpMessagesEvent() { event_.Signal(); }
+  ~PumpMessagesEvent() {}
 
   const MojoEvent* event() const { return &event_; }
 
  private:
-  friend class base::RefCountedThreadSafe<PumpMessagesEvent>;
-
-  PumpMessagesEvent() { event_.Signal(); }
-
-  ~PumpMessagesEvent() {
-    DCHECK_EQ(current_event_.Pointer()->Get(), this);
-    current_event_.Pointer()->Set(nullptr);
-  }
-
   MojoEvent event_;
 
-  static base::LazyInstance<base::ThreadLocalPointer<
-      SyncChannel::PumpMessagesEvent>> current_event_;
-
   DISALLOW_COPY_AND_ASSIGN(PumpMessagesEvent);
 };
 
-base::LazyInstance<base::ThreadLocalPointer<SyncChannel::PumpMessagesEvent>>
-    SyncChannel::PumpMessagesEvent::current_event_ =
-        LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<PumpMessagesEvent>::Leaky g_pump_messages_event =
+    LAZY_INSTANCE_INITIALIZER;
 
+}  // namespace
 
 // When we're blocked in a Send(), we need to process incoming synchronous
 // messages right away because it could be blocking our reply (either
 // directly from the same object we're calling, or indirectly through one or
 // more other channels).  That means that in SyncContext's OnMessageReceived,
 // we need to process sync message right away if we're blocked.  However a
 // simple check isn't sufficient, because the listener thread can be in the
 // process of calling Send.
 // To work around this, when SyncChannel filters a sync message, it sets
 // an event that the listener thread waits on during its Send() call.  This
@@ skipping 392 matching lines @@
     WaitableEvent* shutdown_event) {
   return base::WrapUnique(
       new SyncChannel(listener, ipc_task_runner, shutdown_event));
 }
 
 SyncChannel::SyncChannel(
     Listener* listener,
     const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner,
     WaitableEvent* shutdown_event)
     : ChannelProxy(new SyncContext(listener, ipc_task_runner, shutdown_event)),
-      pump_messages_event_(PumpMessagesEvent::current()),
       sync_handle_registry_(mojo::SyncHandleRegistry::current()) {
   // The current (listener) thread must be distinct from the IPC thread, or else
   // sending synchronous messages will deadlock.
   DCHECK_NE(ipc_task_runner.get(), base::ThreadTaskRunnerHandle::Get().get());
   StartWatching();
 }
 
 SyncChannel::~SyncChannel() {
 }
 
@@ skipping 35 matching lines @@
     DVLOG(1) << "Channel is shutting down. Dropping sync message.";
     delete message;
     return false;
   }
 
   ChannelProxy::Send(message);
 
   // Wait for reply, or for any other incoming synchronous messages.
   // *this* might get deleted, so only call static functions at this point.
   scoped_refptr<mojo::SyncHandleRegistry> registry = sync_handle_registry_;
-  scoped_refptr<PumpMessagesEvent> pump_messages_event = pump_messages_event_;
-  WaitForReply(registry.get(), context.get(),
-               pump_messages ? pump_messages_event->event() : nullptr);
+  WaitForReply(registry.get(), context.get(), pump_messages);
 
   TRACE_EVENT_FLOW_END0(TRACE_DISABLED_BY_DEFAULT("ipc.flow"),
                         "SyncChannel::Send", context->GetSendDoneEvent());
 
   return context->Pop();
 }
 
 void SyncChannel::WaitForReply(mojo::SyncHandleRegistry* registry,
                                SyncContext* context,
-                               const MojoEvent* pump_messages_event) {
+                               bool pump_messages) {
   context->DispatchMessages();
 
+  const MojoEvent* pump_messages_event = nullptr;
+  if (pump_messages)
+    pump_messages_event = g_pump_messages_event.Get().event();
+
   while (true) {
     bool dispatch = false;
     bool send_done = false;
     bool should_pump_messages = false;
     bool error = false;
     registry->RegisterHandle(context->GetDispatchEvent()->GetHandle(),
                              MOJO_HANDLE_SIGNAL_READABLE,
                              base::Bind(&OnSyncHandleReady, &dispatch, &error));
     registry->RegisterHandle(
         context->GetSendDoneEvent()->GetHandle(),
@@ skipping 87 matching lines @@
 
 void SyncChannel::OnChannelInit() {
   for (const auto& filter : pre_init_sync_message_filters_) {
     filter->set_is_channel_send_thread_safe(
         context()->IsChannelSendThreadSafe());
   }
   pre_init_sync_message_filters_.clear();
 }
 
 }  // namespace IPC