Mojo C++ bindings: MultiplexRouter more aggressively dispatch queued messages.

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

 // Copyright 2015 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/lib/multiplex_router.h"
 
 #include <stdint.h>
 
 #include <utility>
 
@@ skipping 385 matching lines @@
 }
 
 void MultiplexRouter::ProcessTasks(bool force_async) {
   lock_.AssertAcquired();
 
   while (!tasks_.empty()) {
     scoped_ptr<Task> task(std::move(tasks_.front()));
     tasks_.pop_front();
 
     bool processed = task->IsNotifyErrorTask()
-                         ? ProcessNotifyErrorTask(task.get(), &force_async)
-                         : ProcessIncomingMessageTask(task.get(), &force_async);
+                         ? ProcessNotifyErrorTask(task.get(), force_async)
+                         : ProcessIncomingMessageTask(task.get(), force_async);
 
     if (!processed) {
       tasks_.push_front(std::move(task));
       break;
     }
   }
 }
 
-bool MultiplexRouter::ProcessNotifyErrorTask(Task* task, bool* force_async) {
+bool MultiplexRouter::ProcessNotifyErrorTask(Task* task, bool force_async) {
   lock_.AssertAcquired();
   InterfaceEndpoint* endpoint = task->endpoint_to_notify.get();
   if (!endpoint->client())
     return true;
 
-  if (!endpoint->task_runner()->BelongsToCurrentThread() || *force_async) {
+  if (!endpoint->task_runner()->BelongsToCurrentThread() || force_async) {
     endpoint->task_runner()->PostTask(
         FROM_HERE, base::Bind(&MultiplexRouter::LockAndCallProcessTasks, this));
     return false;
   }
 
-  *force_async = true;
   InterfaceEndpointClient* client = endpoint->client();
   {
     // We must unlock before calling into |client| because it may call this
     // object within NotifyError(). Holding the lock will lead to deadlock.
     //
     // It is safe to call into |client| without the lock. Because |client| is
     // always accessed on the same thread, including DetachEndpointClient().
     base::AutoUnlock unlocker(lock_);
     client->NotifyError();
   }
   return true;
 }
 
-bool MultiplexRouter::ProcessIncomingMessageTask(Task* task,
-                                                 bool* force_async) {
+bool MultiplexRouter::ProcessIncomingMessageTask(Task* task, bool force_async) {
   lock_.AssertAcquired();
   Message* message = task->message.get();
 
   if (PipeControlMessageHandler::IsPipeControlMessage(message)) {
     if (!control_message_handler_.Accept(message))
       RaiseErrorInNonTestingMode();
     return true;
   }
 
   InterfaceId id = message->interface_id();
@@ skipping 18 matching lines @@
   InterfaceEndpoint* endpoint = endpoints_[id].get();
   if (endpoint->closed())
     return true;
 
   if (!endpoint->client()) {
     // We need to wait until a client is attached in order to dispatch further
     // messages.
     return false;
   }
 
-  if (!endpoint->task_runner()->BelongsToCurrentThread() || *force_async) {
+  if (!endpoint->task_runner()->BelongsToCurrentThread() || force_async) {
     endpoint->task_runner()->PostTask(
         FROM_HERE, base::Bind(&MultiplexRouter::LockAndCallProcessTasks, this));
     return false;
   }
 
-  *force_async = true;
   InterfaceEndpointClient* client = endpoint->client();
   scoped_ptr<Message> owned_message = std::move(task->message);
   bool result = false;
   {
     // We must unlock before calling into |client| because it may call this
     // object within HandleIncomingMessage(). Holding the lock will lead to
     // deadlock.
     //
     // It is safe to call into |client| without the lock. Because |client| is
     // always accessed on the same thread, including DetachEndpointClient().
@@ skipping 29 matching lines @@
 }
 
 void MultiplexRouter::RaiseErrorInNonTestingMode() {
   lock_.AssertAcquired();
   if (!testing_mode_)
     RaiseError();
 }
 
 }  // namespace internal
 }  // namespace mojo