Mojo: Add a MojoCreateMessagePipeOptions struct parameter to MojoCreateMessagePipe.

mojo/system/message_pipe_dispatcher.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/system/message_pipe_dispatcher.h"
 
 #include "base/logging.h"
 #include "mojo/system/channel.h"
 #include "mojo/system/constants.h"
 #include "mojo/system/local_message_pipe_endpoint.h"
 #include "mojo/system/memory.h"
 #include "mojo/system/message_in_transit.h"
 #include "mojo/system/message_pipe.h"
+#include "mojo/system/options_validation.h"
 #include "mojo/system/proxy_message_pipe_endpoint.h"
 
 namespace mojo {
 namespace system {
 
 namespace {
 
 const unsigned kInvalidPort = static_cast<unsigned>(-1);
 
 struct SerializedMessagePipeDispatcher {
   MessageInTransit::EndpointId endpoint_id;
 };
 
 }  // namespace
 
 // MessagePipeDispatcher -------------------------------------------------------
 
-MessagePipeDispatcher::MessagePipeDispatcher()
+// static
+const MojoCreateMessagePipeOptions
+    MessagePipeDispatcher::kDefaultCreateOptions = {
+  static_cast<uint32_t>(sizeof(MojoCreateMessagePipeOptions)),
+  MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE
+};
+
+MessagePipeDispatcher::MessagePipeDispatcher(
+    const MojoCreateMessagePipeOptions& /*validated_options*/)
     : port_(kInvalidPort) {
 }
 
+// static
+MojoResult MessagePipeDispatcher::ValidateCreateOptions(
+    const MojoCreateMessagePipeOptions* in_options,
+    MojoCreateMessagePipeOptions* out_options) {
+  const MojoCreateMessagePipeOptionsFlags kKnownFlags =
+      MOJO_CREATE_MESSAGE_PIPE_OPTIONS_FLAG_NONE;
+
+  *out_options = kDefaultCreateOptions;
+  if (!in_options)
+    return MOJO_RESULT_OK;
+
+  MojoResult result =
+      ValidateOptionsStructPointerSizeAndFlags<MojoCreateMessagePipeOptions>(
+          in_options, kKnownFlags, out_options);
+  if (result != MOJO_RESULT_OK)
+    return result;
+
+  // Checks for fields beyond |flags|:
+
+  // (Nothing here yet.)
+
+  return MOJO_RESULT_OK;
+}
+
 void MessagePipeDispatcher::Init(scoped_refptr<MessagePipe> message_pipe,
                                  unsigned port) {
   DCHECK(message_pipe);
   DCHECK(port == 0 || port == 1);
 
   message_pipe_ = message_pipe;
   port_ = port;
 }
 
 Dispatcher::Type MessagePipeDispatcher::GetType() const {
   return kTypeMessagePipe;
 }
 
 // static
 std::pair<scoped_refptr<MessagePipeDispatcher>, scoped_refptr<MessagePipe> >
 MessagePipeDispatcher::CreateRemoteMessagePipe() {
   scoped_refptr<MessagePipe> message_pipe(
       new MessagePipe(
           scoped_ptr<MessagePipeEndpoint>(new LocalMessagePipeEndpoint()),
           scoped_ptr<MessagePipeEndpoint>(new ProxyMessagePipeEndpoint())));
-  scoped_refptr<MessagePipeDispatcher> dispatcher(new MessagePipeDispatcher());
+  scoped_refptr<MessagePipeDispatcher> dispatcher(new MessagePipeDispatcher(
+      MessagePipeDispatcher::kDefaultCreateOptions));
   dispatcher->Init(message_pipe, 0);
 
   return std::make_pair(dispatcher, message_pipe);
 }
 
 // static
 scoped_refptr<MessagePipeDispatcher> MessagePipeDispatcher::Deserialize(
     Channel* channel,
     const void* source,
     size_t size) {
@@ skipping 60 matching lines @@
   lock().AssertAcquired();
   message_pipe_->Close(port_);
   message_pipe_ = NULL;
   port_ = kInvalidPort;
 }
 
 scoped_refptr<Dispatcher>
 MessagePipeDispatcher::CreateEquivalentDispatcherAndCloseImplNoLock() {
   lock().AssertAcquired();
 
-  scoped_refptr<MessagePipeDispatcher> rv = new MessagePipeDispatcher();
+  // TODO(vtl): Currently, there are no options, so we just use
+  // |kDefaultCreateOptions|. Eventually, we'll have to duplicate the options
+  // too.
+  scoped_refptr<MessagePipeDispatcher> rv =
+      new MessagePipeDispatcher(kDefaultCreateOptions);
   rv->Init(message_pipe_, port_);
   message_pipe_ = NULL;
   port_ = kInvalidPort;
   return scoped_refptr<Dispatcher>(rv.get());
 }
 
 MojoResult MessagePipeDispatcher::WriteMessageImplNoLock(
     const void* bytes,
     uint32_t num_bytes,
     std::vector<DispatcherTransport>* transports,
@@ skipping 87 matching lines @@
 
 // MessagePipeDispatcherTransport ----------------------------------------------
 
 MessagePipeDispatcherTransport::MessagePipeDispatcherTransport(
     DispatcherTransport transport) : DispatcherTransport(transport) {
   DCHECK_EQ(message_pipe_dispatcher()->GetType(), Dispatcher::kTypeMessagePipe);
 }
 
 }  // namespace system
 }  // namespace mojo