content/common/host_shared_bitmap_manager_unittest.cc - Issue 2717213004: Move SharedBitmapManager implementation out of content/

Side by Side Diff: content/common/host_shared_bitmap_manager_unittest.cc

Issue 2717213004: Move SharedBitmapManager implementation out of content/ (Closed)

Patch Set: rebase Created 3 years, 8 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

OLD	NEW
	(Empty)
1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.

2 // Use of this source code is governed by a BSD-style license that can be

3 // found in the LICENSE file.

4

5 #include <stddef.h>

6 #include <string.h>

7

8 #include "content/common/host_shared_bitmap_manager.h"

9 #include "testing/gtest/include/gtest/gtest.h"

10

11 namespace content {

12 namespace {

13

14 class HostSharedBitmapManagerTest : public testing::Test {

15 protected:

16 void SetUp() override { manager_.reset(new HostSharedBitmapManager()); }

17 std::unique_ptr<HostSharedBitmapManager> manager_;

18 };

19

20 TEST_F(HostSharedBitmapManagerTest, TestCreate) {

21 gfx::Size bitmap_size(1, 1);

22 size_t size_in_bytes;

23 EXPECT_TRUE(cc::SharedBitmap::SizeInBytes(bitmap_size, &size_in_bytes));

24 std::unique_ptr<base::SharedMemory> bitmap(new base::SharedMemory());

25 bitmap->CreateAndMapAnonymous(size_in_bytes);

26 memset(bitmap->memory(), 0xff, size_in_bytes);

27 cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();

28

29 HostSharedBitmapManagerClient client(manager_.get());

30 base::SharedMemoryHandle handle;

31 bitmap->ShareToProcess(base::GetCurrentProcessHandle(), &handle);

32 client.ChildAllocatedSharedBitmap(size_in_bytes, handle, id);

33

34 std::unique_ptr<cc::SharedBitmap> large_bitmap;

35 large_bitmap = manager_->GetSharedBitmapFromId(gfx::Size(1024, 1024), id);

36 EXPECT_TRUE(large_bitmap.get() == NULL);

37

38 std::unique_ptr<cc::SharedBitmap> very_large_bitmap;

39 very_large_bitmap =

40 manager_->GetSharedBitmapFromId(gfx::Size(1, (1 << 30) \| 1), id);

41 EXPECT_TRUE(very_large_bitmap.get() == NULL);

42

43 std::unique_ptr<cc::SharedBitmap> negative_size_bitmap;

44 negative_size_bitmap =

45 manager_->GetSharedBitmapFromId(gfx::Size(-1, 1024), id);

46 EXPECT_TRUE(negative_size_bitmap.get() == NULL);

47

48 cc::SharedBitmapId id2 = cc::SharedBitmap::GenerateId();

49 std::unique_ptr<cc::SharedBitmap> invalid_bitmap;

50 invalid_bitmap = manager_->GetSharedBitmapFromId(bitmap_size, id2);

51 EXPECT_TRUE(invalid_bitmap.get() == NULL);

52

53 std::unique_ptr<cc::SharedBitmap> shared_bitmap;

54 shared_bitmap = manager_->GetSharedBitmapFromId(bitmap_size, id);

55 ASSERT_TRUE(shared_bitmap.get() != NULL);

56 EXPECT_EQ(memcmp(shared_bitmap->pixels(), bitmap->memory(), 4), 0);

57

58 std::unique_ptr<cc::SharedBitmap> large_bitmap2;

59 large_bitmap2 = manager_->GetSharedBitmapFromId(gfx::Size(1024, 1024), id);

60 EXPECT_TRUE(large_bitmap2.get() == NULL);

61

62 std::unique_ptr<cc::SharedBitmap> shared_bitmap2;

63 shared_bitmap2 = manager_->GetSharedBitmapFromId(bitmap_size, id);

64 EXPECT_TRUE(shared_bitmap2->pixels() == shared_bitmap->pixels());

65 shared_bitmap2.reset();

66 EXPECT_EQ(memcmp(shared_bitmap->pixels(), bitmap->memory(), size_in_bytes),

67 0);

68

69 client.ChildDeletedSharedBitmap(id);

70

71 memset(bitmap->memory(), 0, size_in_bytes);

72

73 EXPECT_EQ(memcmp(shared_bitmap->pixels(), bitmap->memory(), size_in_bytes),

74 0);

75 bitmap.reset();

76 shared_bitmap.reset();

77 }

78

79 TEST_F(HostSharedBitmapManagerTest, TestCreateForChild) {

80 gfx::Size bitmap_size(1, 1);

81 size_t size_in_bytes;

82 EXPECT_TRUE(cc::SharedBitmap::SizeInBytes(bitmap_size, &size_in_bytes));

83 cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();

84 HostSharedBitmapManagerClient client(manager_.get());

85 base::SharedMemoryHandle handle;

86 client.AllocateSharedBitmapForChild(base::GetCurrentProcessHandle(),

87 size_in_bytes, id, &handle);

88

89 EXPECT_TRUE(base::SharedMemory::IsHandleValid(handle));

90 std::unique_ptr<base::SharedMemory> bitmap(

91 new base::SharedMemory(handle, false));

92 EXPECT_TRUE(bitmap->Map(size_in_bytes));

93 memset(bitmap->memory(), 0xff, size_in_bytes);

94

95 std::unique_ptr<cc::SharedBitmap> shared_bitmap;

96 shared_bitmap = manager_->GetSharedBitmapFromId(bitmap_size, id);

97 EXPECT_TRUE(shared_bitmap);

98 EXPECT_TRUE(

99 memcmp(bitmap->memory(), shared_bitmap->pixels(), size_in_bytes) == 0);

100

101 client.ChildDeletedSharedBitmap(id);

102 }

103

104 TEST_F(HostSharedBitmapManagerTest, RemoveProcess) {

105 gfx::Size bitmap_size(1, 1);

106 size_t size_in_bytes;

107 EXPECT_TRUE(cc::SharedBitmap::SizeInBytes(bitmap_size, &size_in_bytes));

108 std::unique_ptr<base::SharedMemory> bitmap(new base::SharedMemory());

109 bitmap->CreateAndMapAnonymous(size_in_bytes);

110 memset(bitmap->memory(), 0xff, size_in_bytes);

111 cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();

112

113 base::SharedMemoryHandle handle;

114 std::unique_ptr<HostSharedBitmapManagerClient> client(

115 new HostSharedBitmapManagerClient(manager_.get()));

116 bitmap->ShareToProcess(base::GetCurrentProcessHandle(), &handle);

117 client->ChildAllocatedSharedBitmap(size_in_bytes, handle, id);

118

119 std::unique_ptr<cc::SharedBitmap> shared_bitmap;

120 shared_bitmap = manager_->GetSharedBitmapFromId(bitmap_size, id);

121 ASSERT_TRUE(shared_bitmap.get() != NULL);

122

123 EXPECT_EQ(1u, manager_->AllocatedBitmapCount());

124 client.reset();

125 EXPECT_EQ(0u, manager_->AllocatedBitmapCount());

126

127 std::unique_ptr<cc::SharedBitmap> shared_bitmap2;

128 shared_bitmap2 = manager_->GetSharedBitmapFromId(bitmap_size, id);

129 EXPECT_TRUE(shared_bitmap2.get() == NULL);

130 EXPECT_EQ(memcmp(shared_bitmap->pixels(), bitmap->memory(), size_in_bytes),

131 0);

132

133 shared_bitmap.reset();

134 }

135

136 TEST_F(HostSharedBitmapManagerTest, AddDuplicate) {

137 gfx::Size bitmap_size(1, 1);

138 size_t size_in_bytes;

139 EXPECT_TRUE(cc::SharedBitmap::SizeInBytes(bitmap_size, &size_in_bytes));

140 std::unique_ptr<base::SharedMemory> bitmap(new base::SharedMemory());

141 bitmap->CreateAndMapAnonymous(size_in_bytes);

142 memset(bitmap->memory(), 0xff, size_in_bytes);

143 cc::SharedBitmapId id = cc::SharedBitmap::GenerateId();

144 HostSharedBitmapManagerClient client(manager_.get());

145

146 base::SharedMemoryHandle handle;

147 bitmap->ShareToProcess(base::GetCurrentProcessHandle(), &handle);

148 client.ChildAllocatedSharedBitmap(size_in_bytes, handle, id);

149

150 std::unique_ptr<base::SharedMemory> bitmap2(new base::SharedMemory());

151 bitmap2->CreateAndMapAnonymous(size_in_bytes);

152 memset(bitmap2->memory(), 0x00, size_in_bytes);

153

154 client.ChildAllocatedSharedBitmap(size_in_bytes, bitmap2->handle(), id);

155

156 std::unique_ptr<cc::SharedBitmap> shared_bitmap;

157 shared_bitmap = manager_->GetSharedBitmapFromId(bitmap_size, id);

158 ASSERT_TRUE(shared_bitmap.get() != NULL);

159 EXPECT_EQ(memcmp(shared_bitmap->pixels(), bitmap->memory(), size_in_bytes),

160 0);

161 client.ChildDeletedSharedBitmap(id);

162 }

163

164 } // namespace

165 } // namespace content

OLD	NEW

« no previous file with comments | « content/common/host_shared_bitmap_manager.cc ('k') | content/common/render_message_filter.mojom » ('j') | no next file with comments »