Mojo: Implement plumbing to support passing handles over MessagePipes.

mojo/system/core_test_base.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_test_base.h"
 
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "mojo/system/core_impl.h"
 #include "mojo/system/dispatcher.h"
+#include "mojo/system/limits.h"
 #include "mojo/system/memory.h"
 
 namespace mojo {
 namespace system {
 namespace test {
 
 namespace {
 
 // MockDispatcher --------------------------------------------------------------
 
@@ skipping 14 matching lines @@
   // |Dispatcher| implementation/overrides:
   virtual MojoResult CloseImplNoLock() OVERRIDE {
     info_->IncrementCloseCallCount();
     lock().AssertAcquired();
     return MOJO_RESULT_OK;
   }
 
   virtual MojoResult WriteMessageImplNoLock(
       const void* bytes,
       uint32_t num_bytes,
-      const MojoHandle* handles,
-      uint32_t num_handles,
+      const std::vector<Dispatcher*>* dispatchers,
       MojoWriteMessageFlags /*flags*/) OVERRIDE {
     info_->IncrementWriteMessageCallCount();
     lock().AssertAcquired();
 
     if (!VerifyUserPointer<void>(bytes, num_bytes))
       return MOJO_RESULT_INVALID_ARGUMENT;
-    if (!VerifyUserPointer<MojoHandle>(handles, num_handles))
-      return MOJO_RESULT_INVALID_ARGUMENT;
+    if (num_bytes > kMaxMessageNumBytes)
+      return MOJO_RESULT_RESOURCE_EXHAUSTED;
+
+    if (dispatchers)
+      return MOJO_RESULT_UNIMPLEMENTED;
 
     return MOJO_RESULT_OK;
   }
 
   virtual MojoResult ReadMessageImplNoLock(
-      void* bytes,
-      uint32_t* num_bytes,
-      MojoHandle* handles,
-      uint32_t* num_handles,
+      void* bytes, uint32_t* num_bytes,
+      uint32_t /*max_num_dispatchers*/,
+      std::vector<scoped_refptr<Dispatcher> >* /*dispatchers*/,
       MojoReadMessageFlags /*flags*/) OVERRIDE {
     info_->IncrementReadMessageCallCount();
     lock().AssertAcquired();
 
     if (num_bytes && !VerifyUserPointer<void>(bytes, *num_bytes))
       return MOJO_RESULT_INVALID_ARGUMENT;
-    if (num_handles &&
-        !VerifyUserPointer<MojoHandle>(handles, *num_handles))
-      return MOJO_RESULT_INVALID_ARGUMENT;
 
     return MOJO_RESULT_OK;
   }
 
   virtual MojoResult AddWaiterImplNoLock(Waiter* /*waiter*/,
                                          MojoWaitFlags /*flags*/,
                                          MojoResult /*wake_result*/) OVERRIDE {
     info_->IncrementAddWaiterCallCount();
     lock().AssertAcquired();
     return MOJO_RESULT_FAILED_PRECONDITION;
@@ skipping 132 matching lines @@
 }
 
 void CoreTestBase_MockHandleInfo::IncrementCancelAllWaitersCallCount() {
   base::AutoLock locker(lock_);
   cancel_all_waiters_call_count_++;
 }
 
 }  // namespace test
 }  // namespace system
 }  // namespace mojo