Mojo: Implement MojoUnmapBuffer().

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"
@@ skipping 41 matching lines @@
 
 // Thread-safety notes
 //
 // Mojo primitives calls are thread-safe. We achieve this with relatively
 // fine-grained locking. There is a global handle table lock. This lock should
 // be held as briefly as possible (TODO(vtl): a future improvement would be to
 // switch it to a reader-writer lock). Each |Dispatcher| object then has a lock
 // (which subclasses can use to protect their data).
 //
 // The lock ordering is as follows:
-//   1. global handle table lock
+//   1. global handle table lock, global mapping table lock
 //   2. |Dispatcher| locks
 //   3. secondary object locks
 //   ...
 //   INF. |Waiter| locks
 //
 // Notes:
 //    - While holding a |Dispatcher| lock, you may not unconditionally attempt
 //      to take another |Dispatcher| lock. (This has consequences on the
 //      concurrency semantics of |MojoWriteMessage()| when passing handles.)
 //      Doing so would lead to deadlock.
@@ skipping 423 matching lines @@
 
   if (!VerifyUserPointer<void*>(buffer, 1))
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   scoped_ptr<RawSharedBufferMapping> mapping;
   MojoResult result = dispatcher->MapBuffer(offset, num_bytes, flags, &mapping);
   if (result != MOJO_RESULT_OK)
     return result;
 
   DCHECK(mapping);
-  *buffer = mapping->base();
+  void* address = mapping->base();
+  {
+    base::AutoLock locker(mapping_table_lock_);
+    result = mapping_table_.AddMapping(mapping.Pass());
+  }
+  if (result != MOJO_RESULT_OK)
+    return result;
 
-  // TODO(vtl): FIXME -- Record the mapping somewhere, so that it can be
-  // unmapped properly. For now, just leak it.
-  ignore_result(mapping.release());
-
+  *buffer = address;
   return MOJO_RESULT_OK;
 }
 
 MojoResult CoreImpl::UnmapBuffer(void* buffer) {
-  // TODO(vtl): FIXME
-  NOTIMPLEMENTED();
-  return MOJO_RESULT_UNIMPLEMENTED;
+  base::AutoLock locker(mapping_table_lock_);
+  return mapping_table_.RemoveMapping(buffer);
 }
 
 scoped_refptr<Dispatcher> CoreImpl::GetDispatcher(MojoHandle handle) {
   if (handle == MOJO_HANDLE_INVALID)
     return NULL;
 
   base::AutoLock locker(handle_table_lock_);
   return handle_table_.GetDispatcher(handle);
 }
 
@@ skipping 40 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