Mojo C++ bindings: Add a SINGLE_INTERFACE_WITH_SYNC_REQUESTS mode for MultiplexRouter.

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 273 matching lines @@
 MultiplexRouter::MultiplexRouter(
     ScopedMessagePipeHandle message_pipe,
     Config config,
     bool set_interface_id_namesapce_bit,
     scoped_refptr<base::SingleThreadTaskRunner> runner)
     : set_interface_id_namespace_bit_(set_interface_id_namesapce_bit),
       task_runner_(runner),
       header_validator_(nullptr),
       filters_(this),
       connector_(std::move(message_pipe),
-                 config == SINGLE_INTERFACE ? Connector::SINGLE_THREADED_SEND
-                                            : Connector::MULTI_THREADED_SEND,
+                 config == MULTI_INTERFACE ? Connector::MULTI_THREADED_SEND
+                                           : Connector::SINGLE_THREADED_SEND,
                  std::move(runner)),
-      lock_(config == SINGLE_INTERFACE ? nullptr : new base::Lock),
+      lock_(config == MULTI_INTERFACE ? new base::Lock : nullptr),
       control_message_handler_(this),
       control_message_proxy_(&connector_),
       next_interface_id_value_(1),
       posted_to_process_tasks_(false),
       encountered_error_(false),
       paused_(false),
       testing_mode_(false) {
   DCHECK(task_runner_->BelongsToCurrentThread());
-  // Always participate in sync handle watching, because even if it doesn't
-  // expect sync requests during sync handle watching, it may still need to
-  // dispatch messages to associated endpoints on a different thread.
-  connector_.AllowWokenUpBySyncWatchOnSameThread();
+
+  if (config == SINGLE_INTERFACE_WITH_SYNC_METHODS ||
+      config == MULTI_INTERFACE) {
+    // Always participate in sync handle watching in multi-interface mode,
+    // because even if it doesn't expect sync requests during sync handle
+    // watching, it may still need to dispatch messages to associated endpoints
+    // on a different thread.
+    connector_.AllowWokenUpBySyncWatchOnSameThread();
+  }
   connector_.set_incoming_receiver(&filters_);
   connector_.set_connection_error_handler(
       base::Bind(&MultiplexRouter::OnPipeConnectionError,
                  base::Unretained(this)));
 
   std::unique_ptr<MessageHeaderValidator> header_validator =
       base::MakeUnique<MessageHeaderValidator>();
   header_validator_ = header_validator.get();
   filters_.Append(std::move(header_validator));
 }
@@ skipping 574 matching lines @@
 
 void MultiplexRouter::AssertLockAcquired() {
 #if DCHECK_IS_ON()
   if (lock_)
     lock_->AssertAcquired();
 #endif
 }
 
 }  // namespace internal
 }  // namespace mojo