Add a Mojo MemoryDumpProvider.

mojo/edk/system/core.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/edk/system/core.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 134 matching lines @@
 }
 
 NodeController* Core::GetNodeController() {
   base::AutoLock lock(node_controller_lock_);
   if (!node_controller_)
     node_controller_.reset(new NodeController(this));
   return node_controller_.get();
 }
 
 scoped_refptr<Dispatcher> Core::GetDispatcher(MojoHandle handle) {
-  base::AutoLock lock(handles_lock_);
+  base::AutoLock lock(handles_.GetLock());
   return handles_.GetDispatcher(handle);
 }
 
 void Core::SetDefaultProcessErrorCallback(
     const ProcessErrorCallback& callback) {
   default_process_error_callback_ = callback;
 }
 
 ScopedMessagePipeHandle Core::CreatePartialMessagePipe(ports::PortRef* peer) {
   RequestContext request_context;
@@ skipping 35 matching lines @@
   GetNodeController()->ClosePeerConnection(peer_connection_id);
 }
 
 void Core::SetMachPortProvider(base::PortProvider* port_provider) {
 #if defined(OS_MACOSX) && !defined(OS_IOS)
   GetNodeController()->CreateMachPortRelay(port_provider);
 #endif
 }
 
 MojoHandle Core::AddDispatcher(scoped_refptr<Dispatcher> dispatcher) {
-  base::AutoLock lock(handles_lock_);
+  base::AutoLock lock(handles_.GetLock());
   return handles_.AddDispatcher(dispatcher);
 }
 
 bool Core::AddDispatchersFromTransit(
     const std::vector<Dispatcher::DispatcherInTransit>& dispatchers,
     MojoHandle* handles) {
   bool failed = false;
   {
-    base::AutoLock lock(handles_lock_);
+    base::AutoLock lock(handles_.GetLock());
     if (!handles_.AddDispatchersFromTransit(dispatchers, handles))
       failed = true;
   }
   if (failed) {
     for (auto d : dispatchers)
       d.dispatcher->Close();
     return false;
   }
   return true;
 }
 
 MojoResult Core::CreatePlatformHandleWrapper(
     ScopedPlatformHandle platform_handle,
     MojoHandle* wrapper_handle) {
   MojoHandle h = AddDispatcher(
       PlatformHandleDispatcher::Create(std::move(platform_handle)));
   if (h == MOJO_HANDLE_INVALID)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
   *wrapper_handle = h;
   return MOJO_RESULT_OK;
 }
 
 MojoResult Core::PassWrappedPlatformHandle(
     MojoHandle wrapper_handle,
     ScopedPlatformHandle* platform_handle) {
-  base::AutoLock lock(handles_lock_);
+  base::AutoLock lock(handles_.GetLock());
   scoped_refptr<Dispatcher> d;
   MojoResult result = handles_.GetAndRemoveDispatcher(wrapper_handle, &d);
   if (result != MOJO_RESULT_OK)
     return result;
   if (d->GetType() == Dispatcher::Type::PLATFORM_HANDLE) {
     PlatformHandleDispatcher* phd =
         static_cast<PlatformHandleDispatcher*>(d.get());
     *platform_handle = phd->PassPlatformHandle();
   } else {
     result = MOJO_RESULT_INVALID_ARGUMENT;
@@ skipping 30 matching lines @@
     MojoHandle mojo_handle,
     base::SharedMemoryHandle* shared_memory_handle,
     size_t* num_bytes,
     bool* read_only) {
   if (!shared_memory_handle)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   scoped_refptr<Dispatcher> dispatcher;
   MojoResult result = MOJO_RESULT_OK;
   {
-    base::AutoLock lock(handles_lock_);
+    base::AutoLock lock(handles_.GetLock());
     // Get the dispatcher and check it before removing it from the handle table
     // to ensure that the dispatcher is of the correct type. This ensures we
     // don't close and remove the wrong type of dispatcher.
     dispatcher = handles_.GetDispatcher(mojo_handle);
     if (!dispatcher || dispatcher->GetType() != Dispatcher::Type::SHARED_BUFFER)
       return MOJO_RESULT_INVALID_ARGUMENT;
 
     result = handles_.GetAndRemoveDispatcher(mojo_handle, &dispatcher);
     if (result != MOJO_RESULT_OK)
       return result;
@@ skipping 45 matching lines @@
 }
 
 MojoTimeTicks Core::GetTimeTicksNow() {
   return base::TimeTicks::Now().ToInternalValue();
 }
 
 MojoResult Core::Close(MojoHandle handle) {
   RequestContext request_context;
   scoped_refptr<Dispatcher> dispatcher;
   {
-    base::AutoLock lock(handles_lock_);
+    base::AutoLock lock(handles_.GetLock());
     MojoResult rv = handles_.GetAndRemoveDispatcher(handle, &dispatcher);
     if (rv != MOJO_RESULT_OK)
       return rv;
   }
   dispatcher->Close();
   return MOJO_RESULT_OK;
 }
 
 MojoResult Core::QueryHandleSignalsState(
     MojoHandle handle,
@@ skipping 71 matching lines @@
   }
 
   if (!handles)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   if (num_handles > kMaxHandlesPerMessage)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
   std::vector<Dispatcher::DispatcherInTransit> dispatchers;
   {
-    base::AutoLock lock(handles_lock_);
+    base::AutoLock lock(handles_.GetLock());
     MojoResult rv = handles_.BeginTransit(handles, num_handles, &dispatchers);
     if (rv != MOJO_RESULT_OK) {
       handles_.CancelTransit(dispatchers);
       return rv;
     }
   }
   DCHECK_EQ(num_handles, dispatchers.size());
 
   std::unique_ptr<MessageForTransit> msg;
   MojoResult rv = MessageForTransit::Create(
       &msg, num_bytes, dispatchers.data(), num_handles);
 
   {
-    base::AutoLock lock(handles_lock_);
+    base::AutoLock lock(handles_.GetLock());
     if (rv == MOJO_RESULT_OK) {
       handles_.CompleteTransitAndClose(dispatchers);
       *message = reinterpret_cast<MojoMessageHandle>(msg.release());
     } else {
       handles_.CancelTransit(dispatchers);
     }
   }
 
   return rv;
 }
@@ skipping 44 matching lines @@
       new MessagePipeDispatcher(GetNodeController(), port0, pipe_id, 0));
   if (*message_pipe_handle0 == MOJO_HANDLE_INVALID)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
   *message_pipe_handle1 = AddDispatcher(
       new MessagePipeDispatcher(GetNodeController(), port1, pipe_id, 1));
   if (*message_pipe_handle1 == MOJO_HANDLE_INVALID) {
     scoped_refptr<Dispatcher> unused;
     unused->Close();
 
-    base::AutoLock lock(handles_lock_);
+    base::AutoLock lock(handles_.GetLock());
     handles_.GetAndRemoveDispatcher(*message_pipe_handle0, &unused);
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
   }
 
   return MOJO_RESULT_OK;
 }
 
 MojoResult Core::WriteMessage(MojoHandle message_pipe_handle,
                               const void* bytes,
                               uint32_t num_bytes,
@@ skipping 79 matching lines @@
   return MOJO_RESULT_OK;
 }
 
 MojoResult Core::FuseMessagePipes(MojoHandle handle0, MojoHandle handle1) {
   RequestContext request_context;
   scoped_refptr<Dispatcher> dispatcher0;
   scoped_refptr<Dispatcher> dispatcher1;
 
   bool valid_handles = true;
   {
-    base::AutoLock lock(handles_lock_);
+    base::AutoLock lock(handles_.GetLock());
     MojoResult result0 = handles_.GetAndRemoveDispatcher(handle0, &dispatcher0);
     MojoResult result1 = handles_.GetAndRemoveDispatcher(handle1, &dispatcher1);
     if (result0 != MOJO_RESULT_OK || result1 != MOJO_RESULT_OK ||
         dispatcher0->GetType() != Dispatcher::Type::MESSAGE_PIPE ||
         dispatcher1->GetType() != Dispatcher::Type::MESSAGE_PIPE)
       valid_handles = false;
   }
 
   if (!valid_handles) {
     if (dispatcher0)
@@ skipping 75 matching lines @@
     producer->Close();
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
   }
 
   *data_pipe_producer_handle = AddDispatcher(producer);
   *data_pipe_consumer_handle = AddDispatcher(consumer);
   if (*data_pipe_producer_handle == MOJO_HANDLE_INVALID ||
       *data_pipe_consumer_handle == MOJO_HANDLE_INVALID) {
     if (*data_pipe_producer_handle != MOJO_HANDLE_INVALID) {
       scoped_refptr<Dispatcher> unused;
-      base::AutoLock lock(handles_lock_);
+      base::AutoLock lock(handles_.GetLock());
       handles_.GetAndRemoveDispatcher(*data_pipe_producer_handle, &unused);
     }
     producer->Close();
     consumer->Close();
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
   }
 
   return MOJO_RESULT_OK;
 }
 
@@ skipping 218 matching lines @@
 }
 
 MojoResult Core::UnwrapPlatformSharedBufferHandle(
     MojoHandle mojo_handle,
     MojoPlatformHandle* platform_handle,
     size_t* size,
     MojoPlatformSharedBufferHandleFlags* flags) {
   scoped_refptr<Dispatcher> dispatcher;
   MojoResult result = MOJO_RESULT_OK;
   {
-    base::AutoLock lock(handles_lock_);
+    base::AutoLock lock(handles_.GetLock());
     result = handles_.GetAndRemoveDispatcher(mojo_handle, &dispatcher);
     if (result != MOJO_RESULT_OK)
       return result;
   }
 
   if (dispatcher->GetType() != Dispatcher::Type::SHARED_BUFFER) {
     dispatcher->Close();
     return MOJO_RESULT_INVALID_ARGUMENT;
   }
 
@@ skipping 10 matching lines @@
   *flags = MOJO_PLATFORM_SHARED_BUFFER_HANDLE_FLAG_NONE;
   if (platform_shared_buffer->IsReadOnly())
     *flags |= MOJO_PLATFORM_SHARED_BUFFER_HANDLE_FLAG_READ_ONLY;
 
   ScopedPlatformHandle handle = platform_shared_buffer->PassPlatformHandle();
   return ScopedPlatformHandleToMojoPlatformHandle(std::move(handle),
                                                   platform_handle);
 }
 
 void Core::GetActiveHandlesForTest(std::vector<MojoHandle>* handles) {
-  base::AutoLock lock(handles_lock_);
+  base::AutoLock lock(handles_.GetLock());
   handles_.GetActiveHandlesForTest(handles);
 }
 
 // static
 void Core::PassNodeControllerToIOThread(
     std::unique_ptr<NodeController> node_controller) {
   // It's OK to leak this reference. At this point we know the IO loop is still
   // running, and we know the NodeController will observe its eventual
   // destruction. This tells the NodeController to delete itself when that
   // happens.
   node_controller.release()->DestroyOnIOThreadShutdown();
 }
 
 }  // namespace edk
 }  // namespace mojo