Mojo: More data pipe implementation.

mojo/system/core_impl.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/core_impl.h"
 
 #include <vector>
 
 #include "base/logging.h"
 #include "base/time/time.h"
+#include "mojo/system/data_pipe_producer_dispatcher.h"
 #include "mojo/system/dispatcher.h"
 #include "mojo/system/limits.h"
 #include "mojo/system/memory.h"
 #include "mojo/system/message_pipe.h"
 #include "mojo/system/message_pipe_dispatcher.h"
 #include "mojo/system/waiter.h"
 
 namespace mojo {
 namespace system {
 
@@ skipping 321 matching lines @@
       // TODO(vtl): What should we do if we hit the maximum handle table size
       // here? Currently, we'll just fill in those handles with
       // |MOJO_HANDLE_INVALID| (and return success anyway).
       handles[i] = AddDispatcherNoLock(dispatchers[i]);
     }
   }
 
   return rv;
 }
 
-MojoResult CoreImpl::CreateDataPipe(
-    const struct MojoCreateDataPipeOptions* options,
-    MojoHandle* producer_handle,
-    MojoHandle* consumer_handle) {
-  // TODO(vtl)
+MojoResult CoreImpl::CreateDataPipe(const MojoCreateDataPipeOptions* options,
+                                    MojoHandle* data_pipe_producer_handle,
+                                    MojoHandle* data_pipe_consumer_handle) {
+  if (options && !VerifyUserPointer<void>(options, sizeof(*options)))
+    return MOJO_RESULT_INVALID_ARGUMENT;
+  if (!VerifyUserPointer<MojoHandle>(data_pipe_producer_handle, 1))
+    return MOJO_RESULT_INVALID_ARGUMENT;
+  if (!VerifyUserPointer<MojoHandle>(data_pipe_consumer_handle, 1))
+    return MOJO_RESULT_INVALID_ARGUMENT;
+
+/* TODO(vtl): The rest of the code will look something like this:
+  scoped_refptr<LocalDataPipe> data_pipe(new LocalDataPipe());
+  MojoResult result = data_pipe->Init(options);
+  if (result != MOJO_RESULT_OK)
+    return result;
+
+  scoped_refptr<DataPipeProducerDispatcher> producer_dispatcher(
+      new DataPipeProducerDispatcher());
+  scoped_refptr<DataPipeConsumerDispatcher> consumer_dispatcher(
+      new DataPipeConsumerDispatcher());
+
+  MojoHandle producer_handle, consumer_handle;
+  {
+    base::AutoLock locker(handle_table_lock_);
+
+    producer_handle = AddDispatcherNoLock(producer_dispatcher);
+    if (producer_handle == MOJO_HANDLE_INVALID)
+      return MOJO_RESULT_RESOURCE_EXHAUSTED;
+
+    consumer_handle = AddDispatcherNoLock(consumer_dispatcher);
+    if (consumer_handle == MOJO_HANDLE_INVALID) {
+      handle_table_.erase(producer_handle);
+      return MOJO_RESULT_RESOURCE_EXHAUSTED;
+    }
+  }
+
+  producer_dispatcher->Init(data_pipe);
+  consumer_dispatcher->Init(data_pipe);
+
+  *data_pipe_producer_handle = producer_handle;
+  *data_pipe_consumer_handle = consumer_handle;
+  return MOJO_RESULT_OK;
+*/
   NOTIMPLEMENTED();
   return MOJO_RESULT_UNIMPLEMENTED;
 }
 
 MojoResult CoreImpl::WriteData(MojoHandle data_pipe_producer_handle,
                                const void* elements,
                                uint32_t* num_elements,
                                MojoWriteDataFlags flags) {
   scoped_refptr<Dispatcher> dispatcher(
       GetDispatcher(data_pipe_producer_handle));
@@ skipping 57 matching lines @@
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   return dispatcher->EndReadData(num_elements_read);
 }
 
 CoreImpl::CoreImpl()
     : next_handle_(MOJO_HANDLE_INVALID + 1) {
 }
 
 CoreImpl::~CoreImpl() {
-  // This should usually not be reached (the singleton lives forever), except
-  // in tests.
+  // This should usually not be reached (the singleton lives forever), except in
+  // tests.
 }
 
 scoped_refptr<Dispatcher> CoreImpl::GetDispatcher(MojoHandle handle) {
   if (handle == MOJO_HANDLE_INVALID)
     return NULL;
 
   base::AutoLock locker(handle_table_lock_);
   HandleTableMap::iterator it = handle_table_.find(handle);
   if (it == handle_table_.end())
     return NULL;
@@ skipping 71 matching lines @@
   // |Wait()|/|WaitMany()| call. (Only after doing this can |waiter| be
   // destroyed, but this would still be required if the waiter were in TLS.)
   for (i = 0; i < num_added; i++)
     dispatchers[i]->RemoveWaiter(&waiter);
 
   return rv;
 }
 
 }  // namespace system
 }  // namespace mojo