Mojo C++ bindings: introduce MultiplexRouter and related classes.

mojo/public/cpp/bindings/lib/connector.h

 // 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.
 
 #ifndef MOJO_PUBLIC_CPP_BINDINGS_LIB_CONNECTOR_H_
 #define MOJO_PUBLIC_CPP_BINDINGS_LIB_CONNECTOR_H_
 
+#include "base/memory/scoped_ptr.h"
 #include "mojo/public/c/environment/async_waiter.h"
 #include "mojo/public/cpp/bindings/callback.h"
 #include "mojo/public/cpp/bindings/message.h"
 #include "mojo/public/cpp/environment/environment.h"
 #include "mojo/public/cpp/system/core.h"
 
+namespace base {
+class Lock;
+}
+
 namespace mojo {
-class ErrorHandler;
-
 namespace internal {
 
 // The Connector class is responsible for performing read/write operations on a
 // MessagePipe. It writes messages it receives through the MessageReceiver
 // interface that it subclasses, and it forwards messages it reads through the
 // MessageReceiver interface assigned as its incoming receiver.
 //
-// NOTE: MessagePipe I/O is non-blocking.
-//
+// NOTE:
+//   - MessagePipe I/O is non-blocking.
+//   - Sending messages can be configured to be thread safe (please see comments

[sky, 2015/11/19 17:16:26]

Can you use threading asserts to verify this(ThreadChecker)?

[yzshen1, 2015/11/19 22:00:40]

Done.

+//     of the constructor). Other than that, the object should only be accessed
+//     on the creating thread.
 class Connector : public MessageReceiver {
  public:
+  enum SendingThreadSaftyType { SINGLE_THREADED_SEND, MULTI_THREADED_SEND };

[sky, 2015/11/19 17:16:27]

nit: enum class

[yzshen1, 2015/11/19 22:00:40]

Currently I refer to the values at the callsites using
Connector::SINGLE_THREADED_SEND

If I change it to enum class, I will have to refer to the values at the
callsites using
Connector::SendingThreadSafetyType::SINGLE_THREADED_SEND

I think that is a little too verbose.
Do you think it is okay if I keep it the current way? Thanks!

[sky, 2015/11/20 01:00:19]

Would using address that?
Part of this is because you went with such a verbose name (that has send twice).
If you go with:
enum class ThreadType {
  SINGLE_THREADED_SEND,
  MULTI_THREADED_SEND
}
It's shorter overall.

[yzshen1, 2015/11/20 17:01:00]

Using doesn't help in this case unfortunately.
Yeah, it could be made shorter. But it would be nice if I could avoid always
typing two scopes. :)

I think our style guide doesn't ban plain old "enum". The two features of "enum
class": (1) type safety: it doesn't seem to be a concern here; (2) scope: that
is what I would like to avoid.

I wish I could still use plain old "enum". But if you still prefer "enum class",
I think one option is to move this enum out of the Connector class. (And I am
thinking to rename it as "ConnectorConfig".)

enum class ConnectorConfig {
...
};

class Connector {
  Connector(...ConnectorConfig config...);
};

One minor annoyance is the definition is not adjacent to where it is used
anymore. But I can live with that.

Please let me know what you think? Thanks!

+
   // The Connector takes ownership of |message_pipe|.
-  explicit Connector(
+  // If |sending_thread_safty_type| is set to MULTI_THREADED_SEND, Accept() is

[sky, 2015/11/19 17:16:27]

safty->safety

[yzshen1, 2015/11/19 22:00:40]

Ah, sorry. :)

+  // safe to call from multiple threads.
+  Connector(
       ScopedMessagePipeHandle message_pipe,
+      SendingThreadSaftyType sending_thread_safty_type,
       const MojoAsyncWaiter* waiter = Environment::GetDefaultAsyncWaiter());
   ~Connector() override;
 
   // Sets the receiver to handle messages read from the message pipe.  The
   // Connector will read messages from the pipe regardless of whether or not an
   // incoming receiver has been set.
   void set_incoming_receiver(MessageReceiver* receiver) {
     incoming_receiver_ = receiver;
   }
 
@@ skipping 85 matching lines @@
   bool drop_writes_;
   bool enforce_errors_from_incoming_receiver_;
 
   bool paused_;
 
   // If non-null, this will be set to true when the Connector is destroyed.  We
   // use this flag to allow for the Connector to be destroyed as a side-effect
   // of dispatching an incoming message.
   bool* destroyed_flag_;
 
+  // If sending messages is allowed from multiple threads, |lock_| is used to
+  // protect modifications to |message_pipe_| and |drop_writes_|.
+  scoped_ptr<base::Lock> lock_;
+
   MOJO_DISALLOW_COPY_AND_ASSIGN(Connector);
 };
 
 }  // namespace internal
 }  // namespace mojo
 
 #endif  // MOJO_PUBLIC_CPP_BINDINGS_LIB_CONNECTOR_H_