discardable_memory: Using mojo IPC to replace Chrome IPC

components/discardable_memory/service/discardable_shared_memory_manager.cc

Index: components/discardable_memory/service/discardable_shared_memory_manager.cc
diff --git a/components/discardable_memory/service/discardable_shared_memory_manager.cc b/components/discardable_memory/service/discardable_shared_memory_manager.cc
index 1036dc84d697ed5324d2f181a15b7b618cdddf46..6f5bf1cf2ec0088ec54282df7e9c659ea079f167 100644
--- a/components/discardable_memory/service/discardable_shared_memory_manager.cc
+++ b/components/discardable_memory/service/discardable_shared_memory_manager.cc
@@ -29,6 +29,8 @@
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "components/discardable_memory/common/discardable_shared_memory_heap.h"
+#include "mojo/public/cpp/bindings/strong_binding.h"
+#include "mojo/public/cpp/system/platform_handle.h"
 
 #if defined(OS_LINUX)
 #include "base/files/file_path.h"
@@ -57,6 +59,48 @@ uint64_t ClientProcessUniqueIdToTracingProcessId(int client_id) {
          1;
 }
 
+// mojom::DiscardableSharedMemoryManager implementation. It contains the
+// |client_id_| which is not visible to client. We associate allocations with a
+// given mojo instance, so if the instance is closed, we can release the
+// allocations associated with that instance.
+class MojoDiscardableSharedMemoryManagerImpl
+    : public mojom::DiscardableSharedMemoryManager {
+ public:
+  MojoDiscardableSharedMemoryManagerImpl(
+      int32_t client_id,
+      ::discardable_memory::DiscardableSharedMemoryManager* manager)
+      : client_id_(client_id), manager_(manager) {}
+
+  ~MojoDiscardableSharedMemoryManagerImpl() override {
+    // Remove this client from the |manager_|, so all allocated discardable
+    // memory belong to this client will be released.
+    manager_->ClientRemoved(client_id_);
+  }
+
+  // mojom::DiscardableSharedMemoryManager overrides:
+  void AllocateLockedDiscardableSharedMemory(
+      uint32_t size,
+      int32_t id,
+      const AllocateLockedDiscardableSharedMemoryCallback& callback) override {
+    base::SharedMemoryHandle handle;
+    manager_->AllocateLockedDiscardableSharedMemoryForClient(client_id_, size,
+                                                             id, &handle);
+    mojo::ScopedSharedBufferHandle memory =
+        mojo::WrapSharedMemoryHandle(handle, size, false /* read_only */);
+    return callback.Run(std::move(memory));
+  }
+
+  void DeletedDiscardableSharedMemory(int32_t id) override {
+    manager_->ClientDeletedDiscardableSharedMemory(id, client_id_);
+  }
+
+ private:
+  const int32_t client_id_;
+  ::discardable_memory::DiscardableSharedMemoryManager* const manager_;
+
+  DISALLOW_COPY_AND_ASSIGN(MojoDiscardableSharedMemoryManagerImpl);
+};
+
 class DiscardableMemoryImpl : public base::DiscardableMemory {
  public:
   DiscardableMemoryImpl(
@@ -180,7 +224,8 @@ DiscardableSharedMemoryManager::MemorySegment::MemorySegment(
 DiscardableSharedMemoryManager::MemorySegment::~MemorySegment() {}
 
 DiscardableSharedMemoryManager::DiscardableSharedMemoryManager()
-    : default_memory_limit_(GetDefaultMemoryLimit()),
+    : next_client_id_(1),
+      default_memory_limit_(GetDefaultMemoryLimit()),
       memory_limit_(default_memory_limit_),
       bytes_allocated_(0),
       memory_pressure_listener_(new base::MemoryPressureListener(
@@ -205,23 +250,38 @@ DiscardableSharedMemoryManager::~DiscardableSharedMemoryManager() {
       this);
 }
 
-DiscardableSharedMemoryManager* DiscardableSharedMemoryManager::current() {
+// static
+DiscardableSharedMemoryManager*
+DiscardableSharedMemoryManager::CreateInstance() {
+  DCHECK(g_discardable_shared_memory_manager == nullptr);
+  return g_discardable_shared_memory_manager.Pointer();
+}
+
+// static
+DiscardableSharedMemoryManager* DiscardableSharedMemoryManager::GetInstance() {
+  DCHECK(!(g_discardable_shared_memory_manager == nullptr));
   return g_discardable_shared_memory_manager.Pointer();
 }
 
+void DiscardableSharedMemoryManager::Bind(
+    mojom::DiscardableSharedMemoryManagerRequest request) {
+  mojo::MakeStrongBinding(
+      base::MakeUnique<MojoDiscardableSharedMemoryManagerImpl>(
+          next_client_id_++, this),
+      std::move(request));
+}
+
 std::unique_ptr<base::DiscardableMemory>
 DiscardableSharedMemoryManager::AllocateLockedDiscardableMemory(size_t size) {
   DCHECK_NE(size, 0u);
 
-  DiscardableSharedMemoryId new_id =
-      g_next_discardable_shared_memory_id.GetNext();
-  base::ProcessHandle current_process_handle = base::GetCurrentProcessHandle();
+  int32_t new_id = g_next_discardable_shared_memory_id.GetNext();
 
   // Note: Use DiscardableSharedMemoryHeap for in-process allocation
   // of discardable memory if the cost of each allocation is too high.
   base::SharedMemoryHandle handle;
-  AllocateLockedDiscardableSharedMemory(
-      current_process_handle, kInvalidUniqueClientID, size, new_id, &handle);
+  AllocateLockedDiscardableSharedMemory(kInvalidUniqueClientID, size, new_id,
+                                        &handle);
   std::unique_ptr<base::DiscardableSharedMemory> memory(
       new base::DiscardableSharedMemory(handle));
   if (!memory->Map(size))
@@ -308,17 +368,16 @@ bool DiscardableSharedMemoryManager::OnMemoryDump(
 
 void DiscardableSharedMemoryManager::
     AllocateLockedDiscardableSharedMemoryForClient(
-        base::ProcessHandle process_handle,
         int client_id,
         size_t size,
-        DiscardableSharedMemoryId id,
+        int32_t id,
         base::SharedMemoryHandle* shared_memory_handle) {
-  AllocateLockedDiscardableSharedMemory(process_handle, client_id, size, id,
+  AllocateLockedDiscardableSharedMemory(client_id, size, id,
                                         shared_memory_handle);
 }
 
 void DiscardableSharedMemoryManager::ClientDeletedDiscardableSharedMemory(
-    DiscardableSharedMemoryId id,
+    int32_t id,
     int client_id) {
   DeletedDiscardableSharedMemory(id, client_id);
 }
@@ -380,10 +439,9 @@ void DiscardableSharedMemoryManager::OnMemoryStateChange(
 }
 
 void DiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
-    base::ProcessHandle process_handle,
     int client_id,
     size_t size,
-    DiscardableSharedMemoryId id,
+    int32_t id,
     base::SharedMemoryHandle* shared_memory_handle) {
   base::AutoLock lock(lock_);
 
@@ -416,15 +474,6 @@ void DiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
     return;
   }
 
-  if (!memory->ShareToProcess(process_handle, shared_memory_handle)) {
-    LOG(ERROR) << "Cannot share discardable memory segment";
-    *shared_memory_handle = base::SharedMemory::NULLHandle();
-    return;
-  }
-
-  // Close file descriptor to avoid running out.
-  memory->Close();
-
   base::CheckedNumeric<size_t> checked_bytes_allocated = bytes_allocated_;
   checked_bytes_allocated += memory->mapped_size();
   if (!checked_bytes_allocated.IsValid()) {
@@ -435,6 +484,10 @@ void DiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
   bytes_allocated_ = checked_bytes_allocated.ValueOrDie();
   BytesAllocatedChanged(bytes_allocated_);
 
+  *shared_memory_handle = base::SharedMemory::DuplicateHandle(memory->handle());
+  // Close file descriptor to avoid running out.
+  memory->Close();
+
   scoped_refptr<MemorySegment> segment(new MemorySegment(std::move(memory)));
   client_segments[id] = segment.get();
   segments_.push_back(segment.get());
@@ -445,7 +498,7 @@ void DiscardableSharedMemoryManager::AllocateLockedDiscardableSharedMemory(
 }
 
 void DiscardableSharedMemoryManager::DeletedDiscardableSharedMemory(
-    DiscardableSharedMemoryId id,
+    int32_t id,
     int client_id) {
   base::AutoLock lock(lock_);