Mojo: Implement local passing of MessagePipes.

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 "mojo/system/dispatcher.h"
@@ skipping 226 matching lines @@
       entries[i]->busy = true;
 
       // Try to take the lock.
       if (!entries[i]->dispatcher->lock().Try()) {
         // Unset the busy flag (since it won't be unset below).
         entries[i]->busy = false;
         error_result = MOJO_RESULT_BUSY;
         break;
       }
 
+      // We shouldn't race with things that close dispatchers, since closing can
+      // only take place either under |handle_table_lock_| or when the handle is
+      // marked as busy.
+      DCHECK(!entries[i]->dispatcher->is_closed_no_lock());
+
       // Hang on to the pointer to the dispatcher (which we'll need to release
       // the lock without going through the handle table).
       dispatchers[i] = entries[i]->dispatcher;
     }
     if (i < num_handles) {
       DCHECK_NE(error_result, MOJO_RESULT_INTERNAL);
 
       // Unset the busy flags and release the locks.
       for (uint32_t j = 0; j < i; j++) {
         DCHECK(entries[j]->busy);
@@ skipping 17 matching lines @@
 
   if (rv == MOJO_RESULT_OK) {
     base::AutoLock locker(handle_table_lock_);
 
     // Succeeded, so the handles should be removed from the handle table. (The
     // transferring to new dispatchers/closing must have already been done.)
     for (uint32_t i = 0; i < num_handles; i++) {
       HandleTableMap::iterator it = handle_table_.find(handles[i]);
       DCHECK(it != handle_table_.end());
       DCHECK(it->second.busy);
+      it->second.busy = false;  // For the sake of a |DCHECK()|.
       handle_table_.erase(it);
     }
   } else {
     base::AutoLock locker(handle_table_lock_);
 
     // Failed, so the handles should go back to their normal state.
     for (uint32_t i = 0; i < num_handles; i++) {
       HandleTableMap::iterator it = handle_table_.find(handles[i]);
       DCHECK(it != handle_table_.end());
       DCHECK(it->second.busy);
       it->second.busy = false;
     }
   }
 
   return rv;
 }
 
 MojoResult CoreImpl::ReadMessage(
     MojoHandle handle,
     void* bytes, uint32_t* num_bytes,
     MojoHandle* handles, uint32_t* num_handles,
     MojoReadMessageFlags flags) {
   scoped_refptr<Dispatcher> dispatcher(GetDispatcher(handle));
   if (!dispatcher.get())
     return MOJO_RESULT_INVALID_ARGUMENT;
 
-  uint32_t max_num_dispatchers = 0;
   if (num_handles) {
     if (!VerifyUserPointer<uint32_t>(num_handles, 1))
       return MOJO_RESULT_INVALID_ARGUMENT;
     if (!VerifyUserPointer<MojoHandle>(handles, *num_handles))
       return MOJO_RESULT_INVALID_ARGUMENT;
-    max_num_dispatchers = *num_handles;
   }
 
   // Easy case: won't receive any handles.
-  if (max_num_dispatchers == 0)
+  if (!num_handles || *num_handles == 0)
     return dispatcher->ReadMessage(bytes, num_bytes, 0, NULL, flags);
 
   std::vector<scoped_refptr<Dispatcher> > dispatchers;
   MojoResult rv = dispatcher->ReadMessage(bytes, num_bytes,
-                                          max_num_dispatchers, &dispatchers,
+                                          &dispatchers, num_handles,
                                           flags);
   if (!dispatchers.empty()) {
     DCHECK_EQ(rv, MOJO_RESULT_OK);
-
-    *num_handles = static_cast<uint32_t>(dispatchers.size());
-    DCHECK_LE(*num_handles, max_num_dispatchers);
+    DCHECK(num_handles);
+    DCHECK_LE(dispatchers.size(), static_cast<size_t>(*num_handles));
 
     base::AutoLock locker(handle_table_lock_);
 
     for (size_t i = 0; i < dispatchers.size(); i++) {
       // 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]);
     }
   }
@@ skipping 92 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