Add shared bitmap managers for browser and renderer processes.

content/child/child_shared_bitmap_manager.cc

Index: content/child/child_shared_bitmap_manager.cc
diff --git a/content/child/child_shared_bitmap_manager.cc b/content/child/child_shared_bitmap_manager.cc
new file mode 100644
index 0000000000000000000000000000000000000000..2ea79163c680159854cf78b3967ad7805223708a
--- /dev/null
+++ b/content/child/child_shared_bitmap_manager.cc
@@ -0,0 +1,87 @@
+// 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 "content/child/child_thread.h"
+#include "content/common/child_process_messages.h"
+#include "ui/gfx/size.h"
+
+namespace content {
+
+ChildSharedBitmapManager::ChildSharedBitmapManager(
+    scoped_refptr<ThreadSafeSender> sender)
+    : sender_(sender) {}
+
+ChildSharedBitmapManager::~ChildSharedBitmapManager() {}
+
+scoped_ptr<cc::SharedBitmap> ChildSharedBitmapManager::AllocateSharedBitmap(
+    const gfx::Size& size) {
+  TRACE_EVENT2("renderer",
+               "ChildSharedBitmapManager::AllocateSharedMemory",
+               "width",
+               size.width(),
+               "height",
+               size.height());
+  size_t memory_size = cc::SharedBitmap::GetSizeInBytes(size);

[piman, 2014/02/18 21:38:20]

Do we need to protect against overflow here? Can content try to create
layers/quads that are 33kx32k?

+  cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
+  scoped_ptr<base::SharedMemory> memory;
+#if defined(OS_POSIX)
+  base::SharedMemoryHandle handle;
+  sender_->Send(new ChildProcessHostMsg_SyncAllocateSharedBitmap(
+      memory_size, id, &handle));
+  memory = make_scoped_ptr(new base::SharedMemory(handle, false));
+  memory->Map(memory_size);
+#else
+  memory =
+      make_scoped_ptr(ChildThread::AllocateSharedMemory(memory_size, sender_));

[piman, 2014/02/18 21:38:20]

nit: or memory.reset(ChildThread::AllocateSharedMemory(memory_size, sender_)) to
fit on one line.

+  CHECK(memory);
+  memory->Map(memory_size);
+  base::SharedMemoryHandle handle_to_send = memory->handle();

[piman, 2014/02/18 21:38:20]

Is that safe?

Assume the child (renderer) does like:

scoped_ptr<cc::SharedBitmap> bitmap = AllocateSharedBitmap(...);
SendFrameThatUsesBitmap(bitmap);
bitmap.reset();


Then by the time the browser receives the
ChildProcessHostMsg_AllocatedSharedBitmap, the handle may have been deleted in
the child, and the browser will try to map an invalid handle (are handle values
recycled on Windows? That'd be even scarier).

+  sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
+      memory_size, handle_to_send, id));
+#endif
+  return scoped_ptr<cc::SharedBitmap>(new cc::SharedBitmap(
+      memory.release(),
+      id,
+      base::Bind(&ChildSharedBitmapManager::FreeSharedMemory,
+                 base::Unretained(this))));

[piman, 2014/02/18 21:38:20]

What makes Unretained safe?

+}
+
+scoped_ptr<cc::SharedBitmap> ChildSharedBitmapManager::GetSharedBitmapFromId(
+    const gfx::Size&,
+    const cc::SharedBitmapId&) {
+  NOTREACHED();
+  return scoped_ptr<cc::SharedBitmap>();
+}
+
+scoped_ptr<cc::SharedBitmap> ChildSharedBitmapManager::GetBitmapForSharedMemory(
+    base::SharedMemory* mem) {
+  cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
+  base::SharedMemoryHandle handle_to_send = mem->handle();
+#if defined(OS_POSIX)
+  if (!mem->ShareToProcess(base::GetCurrentProcessHandle(), &handle_to_send))
+    return scoped_ptr<cc::SharedBitmap>();
+#endif
+  sender_->Send(new ChildProcessHostMsg_AllocatedSharedBitmap(
+      mem->mapped_size(), handle_to_send, id));
+  return scoped_ptr<cc::SharedBitmap>(new cc::SharedBitmap(
+      mem,
+      id,
+      base::Bind(&ChildSharedBitmapManager::ReleaseSharedBitmap,
+                 base::Unretained(this))));

[piman, 2014/02/18 21:38:20]

What makes Unretained safe?

+}
+
+void ChildSharedBitmapManager::FreeSharedMemory(cc::SharedBitmap* bitmap) {
+  TRACE_EVENT0("renderer", "ChildSharedBitmapManager::FreeSharedMemory");
+  sender_->Send(new ChildProcessHostMsg_DeletedSharedBitmap(bitmap->id()));
+  delete bitmap->memory();
+}
+
+void ChildSharedBitmapManager::ReleaseSharedBitmap(cc::SharedBitmap* handle) {
+  TRACE_EVENT0("renderer", "ChildSharedBitmapManager::ReleaseSharedBitmap");
+  sender_->Send(new ChildProcessHostMsg_DeletedSharedBitmap(handle->id()));
+}
+
+}  // namespace content