Make nesting/running states a RunLoop rather than a MessageLoop concept.

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/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_local.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 {
 
 namespace {
 
 // The NestingObserver for each thread. Note that this is always a
-// Connector::MessageLoopNestingObserver; we use the base type here because that
+// Connector::RunLoopNestingObserver; we use the base type here because that
 // subclass is private to Connector.
-base::LazyInstance<
-    base::ThreadLocalPointer<base::MessageLoop::NestingObserver>>::Leaky
-    g_tls_nesting_observer = LAZY_INSTANCE_INITIALIZER;
+base::LazyInstance<base::ThreadLocalPointer<base::RunLoop::NestingObserver>>::
+    Leaky g_tls_nesting_observer = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 // Used to efficiently maintain a doubly-linked list of all Connectors
 // currently dispatching on any given thread.
 class Connector::ActiveDispatchTracker {
  public:
   explicit ActiveDispatchTracker(const base::WeakPtr<Connector>& connector);
   ~ActiveDispatchTracker();
 
   void NotifyBeginNesting();
 
  private:
   const base::WeakPtr<Connector> connector_;
-  MessageLoopNestingObserver* const nesting_observer_;
+  RunLoopNestingObserver* const nesting_observer_;
   ActiveDispatchTracker* outer_tracker_ = nullptr;
   ActiveDispatchTracker* inner_tracker_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(ActiveDispatchTracker);
 };
 
 // Watches the MessageLoop on the current thread. Notifies the current chain of
 // ActiveDispatchTrackers when a nested message loop is started.
-class Connector::MessageLoopNestingObserver
-    : public base::MessageLoop::NestingObserver,
+class Connector::RunLoopNestingObserver
+    : public base::RunLoop::NestingObserver,
       public base::MessageLoop::DestructionObserver {
  public:
-  MessageLoopNestingObserver() {
-    base::MessageLoop::current()->AddNestingObserver(this);
+  RunLoopNestingObserver() {
+    base::RunLoop::AddNestingObserverOnCurrentThread(this);
     base::MessageLoop::current()->AddDestructionObserver(this);
   }
 
-  ~MessageLoopNestingObserver() override {}
+  ~RunLoopNestingObserver() override {}
 
-  // base::MessageLoop::NestingObserver:
-  void OnBeginNestedMessageLoop() override {
+  // base::RunLoop::NestingObserver:
+  void OnBeginNestedRunLoop() override {
     if (top_tracker_)
       top_tracker_->NotifyBeginNesting();
   }
 
   // base::MessageLoop::DestructionObserver:
   void WillDestroyCurrentMessageLoop() override {
-    base::MessageLoop::current()->RemoveNestingObserver(this);
+    base::RunLoop::RemoveNestingObserverOnCurrentThread(this);
     base::MessageLoop::current()->RemoveDestructionObserver(this);
     DCHECK_EQ(this, g_tls_nesting_observer.Get().Get());
     g_tls_nesting_observer.Get().Set(nullptr);
     delete this;
   }
 
-  static MessageLoopNestingObserver* GetForThread() {
+  static RunLoopNestingObserver* GetForThread() {
     if (!base::MessageLoop::current() ||
-        !base::MessageLoop::current()->nesting_allowed())
+        !base::RunLoop::IsNestingAllowedOnCurrentThread()) {
       return nullptr;
-    auto* observer = static_cast<MessageLoopNestingObserver*>(
+    }
+    auto* observer = static_cast<RunLoopNestingObserver*>(
         g_tls_nesting_observer.Get().Get());
     if (!observer) {
-      observer = new MessageLoopNestingObserver;
+      observer = new RunLoopNestingObserver;
       g_tls_nesting_observer.Get().Set(observer);
     }
     return observer;
   }
 
  private:
   friend class ActiveDispatchTracker;
 
   ActiveDispatchTracker* top_tracker_ = nullptr;
 
-  DISALLOW_COPY_AND_ASSIGN(MessageLoopNestingObserver);
+  DISALLOW_COPY_AND_ASSIGN(RunLoopNestingObserver);
 };
 
 Connector::ActiveDispatchTracker::ActiveDispatchTracker(
     const base::WeakPtr<Connector>& connector)
     : connector_(connector), nesting_observer_(connector_->nesting_observer_) {
   DCHECK(nesting_observer_);
   if (nesting_observer_->top_tracker_) {
     outer_tracker_ = nesting_observer_->top_tracker_;
     outer_tracker_->inner_tracker_ = this;
   }
@@ skipping 14 matching lines @@
     connector_->handle_watcher_->ArmOrNotify();
   if (outer_tracker_)
     outer_tracker_->NotifyBeginNesting();
 }
 
 Connector::Connector(ScopedMessagePipeHandle message_pipe,
                      ConnectorConfig config,
                      scoped_refptr<base::SingleThreadTaskRunner> runner)
     : message_pipe_(std::move(message_pipe)),
       task_runner_(std::move(runner)),
-      nesting_observer_(MessageLoopNestingObserver::GetForThread()),
+      nesting_observer_(RunLoopNestingObserver::GetForThread()),
       weak_factory_(this) {
   if (config == MULTI_THREADED_SEND)
     lock_.emplace();
 
   weak_self_ = weak_factory_.GetWeakPtr();
   // Even though we don't have an incoming receiver, we still want to monitor
   // the message pipe to know if is closed or encounters an error.
   WaitToReadMore();
 }
 
@@ skipping 338 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