Replacing allocate bitmap IPC messages with a new Mojo interface.

content/child/child_shared_bitmap_manager.cc

 // Copyright (c) 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 "content/child/child_shared_bitmap_manager.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/debug/alias.h"
 #include "base/memory/ptr_util.h"
 #include "base/process/memory.h"
 #include "base/process/process_metrics.h"
 #include "build/build_config.h"
 #include "content/child/child_thread_impl.h"
 #include "content/common/child_process_messages.h"
+#include "mojo/public/cpp/system/platform_handle.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace content {
 
 namespace {
 
 class ChildSharedBitmap : public SharedMemoryBitmap {
  public:
-  ChildSharedBitmap(scoped_refptr<ThreadSafeSender> sender,
-                    base::SharedMemory* shared_memory,
-                    const cc::SharedBitmapId& id)
+  ChildSharedBitmap(
+      const scoped_refptr<mojom::ThreadSafeRenderMessageFilterAssociatedPtr>&
+          render_message_filter_ptr,
+      base::SharedMemory* shared_memory,
+      const cc::SharedBitmapId& id)
       : SharedMemoryBitmap(static_cast<uint8_t*>(shared_memory->memory()),
                            id,
                            shared_memory),
-        sender_(sender) {}
+        render_message_filter_ptr_(render_message_filter_ptr) {}
 
-  ChildSharedBitmap(scoped_refptr<ThreadSafeSender> sender,
-                    std::unique_ptr<base::SharedMemory> shared_memory_holder,
-                    const cc::SharedBitmapId& id)
-      : ChildSharedBitmap(sender, shared_memory_holder.get(), id) {
+  ChildSharedBitmap(
+      const scoped_refptr<mojom::ThreadSafeRenderMessageFilterAssociatedPtr>&
+          render_message_filter_ptr,
+      std::unique_ptr<base::SharedMemory> shared_memory_holder,
+      const cc::SharedBitmapId& id)
+      : ChildSharedBitmap(render_message_filter_ptr,
+                          shared_memory_holder.get(),
+                          id) {
     shared_memory_holder_ = std::move(shared_memory_holder);
   }
 
   ~ChildSharedBitmap() override {
-    sender_->Send(new ChildProcessHostMsg_DeletedSharedBitmap(id()));
+    (*render_message_filter_ptr_)->DeletedSharedBitmap(id());
   }
 
  private:
-  scoped_refptr<ThreadSafeSender> sender_;
+  scoped_refptr<mojom::ThreadSafeRenderMessageFilterAssociatedPtr>
+      render_message_filter_ptr_;
   std::unique_ptr<base::SharedMemory> shared_memory_holder_;
 };
 
 // Collect extra information for debugging bitmap creation failures.
 void CollectMemoryUsageAndDie(const gfx::Size& size, size_t alloc_size) {
 #if defined(OS_WIN)
   int width = size.width();
   int height = size.height();
   DWORD last_error = GetLastError();
 
@@ skipping 15 matching lines @@
 }
 
 }  // namespace
 
 SharedMemoryBitmap::SharedMemoryBitmap(uint8_t* pixels,
                                        const cc::SharedBitmapId& id,
                                        base::SharedMemory* shared_memory)
     : SharedBitmap(pixels, id), shared_memory_(shared_memory) {}
 
 ChildSharedBitmapManager::ChildSharedBitmapManager(
-    scoped_refptr<ThreadSafeSender> sender)
-    : sender_(sender) {
+    const scoped_refptr<mojom::ThreadSafeRenderMessageFilterAssociatedPtr>&
+        render_message_filter_ptr)
+    : render_message_filter_ptr_(render_message_filter_ptr) {
 }
 
 ChildSharedBitmapManager::~ChildSharedBitmapManager() {}
 
 std::unique_ptr<cc::SharedBitmap>
 ChildSharedBitmapManager::AllocateSharedBitmap(const gfx::Size& size) {
-  std::unique_ptr<SharedMemoryBitmap> bitmap = AllocateSharedMemoryBitmap(size);
-#if defined(OS_POSIX)
-  // Close file descriptor to avoid running out.
-  if (bitmap)
-    bitmap->shared_memory()->Close();
-#endif
-  return std::move(bitmap);
-}
-
-std::unique_ptr<SharedMemoryBitmap>
-ChildSharedBitmapManager::AllocateSharedMemoryBitmap(const gfx::Size& size) {
   TRACE_EVENT2("renderer",
                "ChildSharedBitmapManager::AllocateSharedMemoryBitmap", "width",
                size.width(), "height", size.height());
   size_t memory_size;
   if (!cc::SharedBitmap::SizeInBytes(size, &memory_size))
     return std::unique_ptr<SharedMemoryBitmap>();
   cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
-  std::unique_ptr<base::SharedMemory> memory;
-#if defined(OS_POSIX)
-  base::SharedMemoryHandle handle;
-  bool send_success =
-      sender_->Send(new ChildProcessHostMsg_SyncAllocateSharedBitmap(
-          memory_size, id, &handle));
-  if (!send_success) {
-    // Callers of this method are not prepared to handle failures during
-    // shutdown. Exit immediately. This is expected behavior during the Fast
-    // Shutdown path, so use EXIT_SUCCESS. https://crbug.com/615121.
-    exit(EXIT_SUCCESS);
-  }
-  memory = base::MakeUnique<base::SharedMemory>(handle, false);
-  if (!memory->Map(memory_size))
-    CollectMemoryUsageAndDie(size, memory_size);
-#else
-  bool out_of_memory;
-  memory = ChildThreadImpl::AllocateSharedMemory(memory_size, sender_.get(),
-                                                 &out_of_memory);
+  bool out_of_memory = false;
+  std::unique_ptr<base::SharedMemory> memory =
+      ChildThreadImpl::AllocateSharedMemory(memory_size, nullptr,
+                                            &out_of_memory);
   if (!memory) {
     if (out_of_memory) {
       CollectMemoryUsageAndDie(size, memory_size);
     } else {
       // Callers of this method are not prepared to handle failures during
       // shutdown. Exit immediately. This is expected behavior during the Fast
       // Shutdown path, so use EXIT_SUCCESS. https://crbug.com/615121.
       exit(EXIT_SUCCESS);
     }
   }
 
-  if (!memory->Map(memory_size))
+ if (!memory->Map(memory_size))
     CollectMemoryUsageAndDie(size, memory_size);
 
-  base::SharedMemoryHandle handle_to_send = memory->handle();
-  sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
-      memory_size, handle_to_send, id));
-#endif
-  return base::MakeUnique<ChildSharedBitmap>(sender_, std::move(memory), id);
+  NotifyAllocatedSharedBitmap(memory.get(), id);
+
+  return base::MakeUnique<ChildSharedBitmap>(render_message_filter_ptr_,
+      std::move(memory), id);
 }
 
 std::unique_ptr<cc::SharedBitmap>
 ChildSharedBitmapManager::GetSharedBitmapFromId(const gfx::Size&,
                                                 const cc::SharedBitmapId&) {
   NOTREACHED();
   return std::unique_ptr<cc::SharedBitmap>();
 }
 
 std::unique_ptr<cc::SharedBitmap>
 ChildSharedBitmapManager::GetBitmapForSharedMemory(base::SharedMemory* mem) {
   cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
-  base::SharedMemoryHandle handle_to_send = mem->handle();
+  NotifyAllocatedSharedBitmap(mem, cc::SharedBitmap::GenerateId());
+  return base::MakeUnique<ChildSharedBitmap>(render_message_filter_ptr_,
+      std::move(mem), id);
+}
+
+// Notifies the browser process that a shared bitmap with the given ID was
+// allocated. Caller keeps ownership of |memory|.
+void ChildSharedBitmapManager::NotifyAllocatedSharedBitmap(
+    base::SharedMemory* memory,
+    const cc::SharedBitmapId& id) {
+  base::SharedMemoryHandle handle_to_send = memory->handle();

[Ken Rockot(use gerrit already), 2016/11/29 17:43:11]

This seems to correctly mirror the old behavior, but the old behavior seems
inconsistent across platforms. On POSIX we dup then send the handle, but on
Windows we just send the handle, leaving |memory| with an invalid handle. It's
probably fine because nobody tries using that handle after the fact.

In order to be consistent, I think we should just scrap the ShareToProcess
below, and instead call DuplicateHandle on memory->handle() directly, still
wrapping the result with WrapSharedMemoryHandle.

Sending a mojo shared buffer to another process always does the right thing with
respect to process handle ownership, so ShareToProcess usage should essentially
be phased out as IPCs transition to mojo.

[Jay Civelli, 2016/11/29 18:01:48]

Good point, done.

 #if defined(OS_POSIX)
-  if (!mem->ShareToProcess(base::GetCurrentProcessHandle(), &handle_to_send))
-    return std::unique_ptr<cc::SharedBitmap>();
+  if (!memory->ShareToProcess(base::GetCurrentProcessHandle(), &handle_to_send))
+    return;
 #endif
-  sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
-      mem->mapped_size(), handle_to_send, id));
 
-  return base::MakeUnique<ChildSharedBitmap>(sender_, mem, id);
+  mojo::ScopedSharedBufferHandle buffer_handle =
+      mojo::WrapSharedMemoryHandle(
+          base::SharedMemory::DuplicateHandle(handle_to_send),
+          memory->mapped_size(),
+          true /* read_only */);
+
+  (*render_message_filter_ptr_)->
+      AllocatedSharedBitmap(std::move(buffer_handle), id);
 }
 
 }  // namespace content