Add shared bitmap managers for browser and renderer processes.

content/common/host_shared_bitmap_manager_unittest.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/common/host_shared_bitmap_manager.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace content {
+namespace {
+
+class HostSharedBitmapManagerTest : public testing::Test {
+ protected:
+  virtual void SetUp() { manager_.reset(new HostSharedBitmapManager()); }
+  scoped_ptr<HostSharedBitmapManager> manager_;
+};
+
+TEST_F(HostSharedBitmapManagerTest, TestCreate) {
+  gfx::Size bitmap_size(1, 1);
+  size_t size_in_bytes = cc::SharedBitmap::GetSizeInBytes(bitmap_size);
+  scoped_ptr<base::SharedMemory> bitmap(new base::SharedMemory());
+  bitmap->CreateAndMapAnonymous(size_in_bytes);
+  memset(bitmap->memory(), 0xff, size_in_bytes);
+  cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
+
+  base::SharedMemoryHandle handle;
+  bitmap->ShareToProcess(base::GetCurrentProcessHandle(), &handle);
+  manager_->ChildAllocatedSharedBitmap(
+      handle, base::GetCurrentProcessHandle(), id);
+
+  scoped_ptr<cc::SharedBitmap> large_bitmap;
+  large_bitmap = manager_->GetSharedBitmapFromId(gfx::Size(1024, 1024), id);

[danakj, 2014/02/14 20:16:48]

Is it not super weird that this size doesn't match the size the bitmap was
created with? Should this really be a valid use of the manager?

[jbauman, 2014/02/18 19:31:35]

It's not valid at all, so I'm testing that mapping this fails in some way (so at
least we're not mapping some unrelated memory in this case).

[danakj, 2014/02/18 19:57:29]

But on posix you do end up mapping something that will later crash. Why don't we
guard this inside the manager to always return NULL?

+#if !defined(OS_POSIX)
+  EXPECT_TRUE(large_bitmap.get() == NULL);

[danakj, 2014/02/14 20:16:48]

This is 4mb of memory, we can't map 4 megabytes on non-posix?

+#endif
+  // On POSIX, the entire bitmap could be mapped, but there could be a SIGBUS
+  // if the address that's accessed is too large.
+
+  cc::SharedBitmapId id2 = cc::SharedBitmap::GenerateId();
+  scoped_ptr<cc::SharedBitmap> invalid_bitmap;
+  invalid_bitmap = manager_->GetSharedBitmapFromId(bitmap_size, id2);
+  EXPECT_TRUE(invalid_bitmap.get() == NULL);
+
+  scoped_ptr<cc::SharedBitmap> shared_bitmap;
+  shared_bitmap = manager_->GetSharedBitmapFromId(bitmap_size, id);
+  ASSERT_TRUE(shared_bitmap.get() != NULL);
+  EXPECT_EQ(memcmp(shared_bitmap->pixels(), bitmap->memory(), 4), 0);
+
+  scoped_ptr<cc::SharedBitmap> large_bitmap2;
+  large_bitmap2 = manager_->GetSharedBitmapFromId(gfx::Size(1024, 1024), id);
+#if !defined(OS_POSIX)
+  EXPECT_TRUE(large_bitmap2.get() == NULL);
+#endif
+
+  scoped_ptr<cc::SharedBitmap> shared_bitmap2;
+  shared_bitmap2 = manager_->GetSharedBitmapFromId(bitmap_size, id);
+  EXPECT_TRUE(shared_bitmap2->pixels() == shared_bitmap->pixels());
+  shared_bitmap2.reset();
+  EXPECT_EQ(memcmp(shared_bitmap->pixels(), bitmap->memory(), size_in_bytes),
+            0);
+
+  manager_->ChildDeletedSharedBitmap(id);
+
+  memset(bitmap->memory(), 0, size_in_bytes);
+
+  EXPECT_EQ(memcmp(shared_bitmap->pixels(), bitmap->memory(), size_in_bytes),
+            0);
+  bitmap.reset();
+  shared_bitmap.reset();
+}
+
+TEST_F(HostSharedBitmapManagerTest, TestCreateForChild) {
+  gfx::Size bitmap_size(1, 1);
+  size_t size_in_bytes = cc::SharedBitmap::GetSizeInBytes(bitmap_size);
+  cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
+  base::SharedMemoryHandle handle;
+  manager_->AllocateSharedBitmapForChild(
+      base::GetCurrentProcessHandle(), size_in_bytes, id, &handle);
+
+  EXPECT_TRUE(base::SharedMemory::IsHandleValid(handle));
+  scoped_ptr<base::SharedMemory> bitmap(new base::SharedMemory(handle, false));
+  EXPECT_TRUE(bitmap->Map(size_in_bytes));
+  memset(bitmap->memory(), 0xff, size_in_bytes);
+
+  scoped_ptr<cc::SharedBitmap> shared_bitmap;
+  shared_bitmap = manager_->GetSharedBitmapFromId(bitmap_size, id);
+  EXPECT_TRUE(shared_bitmap);
+  EXPECT_TRUE(
+      memcmp(bitmap->memory(), shared_bitmap->pixels(), size_in_bytes) == 0);
+}
+
+TEST_F(HostSharedBitmapManagerTest, RemoveProcess) {
+  gfx::Size bitmap_size(1, 1);
+  size_t size_in_bytes = cc::SharedBitmap::GetSizeInBytes(bitmap_size);
+  scoped_ptr<base::SharedMemory> bitmap(new base::SharedMemory());
+  bitmap->CreateAndMapAnonymous(size_in_bytes);
+  memset(bitmap->memory(), 0xff, size_in_bytes);
+  cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
+
+  base::SharedMemoryHandle handle;
+  bitmap->ShareToProcess(base::GetCurrentProcessHandle(), &handle);
+  manager_->ChildAllocatedSharedBitmap(
+      handle, base::GetCurrentProcessHandle(), id);
+
+  manager_->ProcessRemoved(base::kNullProcessHandle);
+
+  scoped_ptr<cc::SharedBitmap> shared_bitmap;
+  shared_bitmap = manager_->GetSharedBitmapFromId(bitmap_size, id);
+  ASSERT_TRUE(shared_bitmap.get() != NULL);
+
+  manager_->ProcessRemoved(base::GetCurrentProcessHandle());
+
+  scoped_ptr<cc::SharedBitmap> shared_bitmap2;
+  shared_bitmap2 = manager_->GetSharedBitmapFromId(bitmap_size, id);
+  EXPECT_TRUE(shared_bitmap2.get() == NULL);
+  EXPECT_EQ(memcmp(shared_bitmap->pixels(), bitmap->memory(), size_in_bytes),
+            0);
+
+  shared_bitmap.reset();
+
+  // Should no-op.
+  manager_->ChildDeletedSharedBitmap(id);
+}
+
+TEST_F(HostSharedBitmapManagerTest, AddDuplicate) {
+  gfx::Size bitmap_size(1, 1);
+  size_t size_in_bytes = cc::SharedBitmap::GetSizeInBytes(bitmap_size);
+  scoped_ptr<base::SharedMemory> bitmap(new base::SharedMemory());
+  bitmap->CreateAndMapAnonymous(size_in_bytes);
+  memset(bitmap->memory(), 0xff, size_in_bytes);
+  cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();
+
+  base::SharedMemoryHandle handle;
+  bitmap->ShareToProcess(base::GetCurrentProcessHandle(), &handle);
+  manager_->ChildAllocatedSharedBitmap(
+      handle, base::GetCurrentProcessHandle(), id);

[danakj, 2014/02/14 20:16:48]

What about two different processes using the same id? Can you add a test for
that case?

[jbauman, 2014/02/18 19:31:35]

I don't think we have two valid process handles here, so I can't figure out a
way to test that. It shouldn't matter in the current implementation, though.

[danakj, 2014/02/18 19:57:29]

I was hoping there's some way to generate fake process handles. Do we have
something like that?

+
+  scoped_ptr<base::SharedMemory> bitmap2(new base::SharedMemory());
+  bitmap2->CreateAndMapAnonymous(size_in_bytes);
+  memset(bitmap2->memory(), 0x00, size_in_bytes);
+
+  manager_->ChildAllocatedSharedBitmap(
+      bitmap2->handle(), base::GetCurrentProcessHandle(), id);
+
+  scoped_ptr<cc::SharedBitmap> shared_bitmap;
+  shared_bitmap = manager_->GetSharedBitmapFromId(bitmap_size, id);
+  ASSERT_TRUE(shared_bitmap.get() != NULL);
+  EXPECT_EQ(memcmp(shared_bitmap->pixels(), bitmap->memory(), size_in_bytes),
+            0);
+}
+
+}  // namespace
+}  // namespace content