chromecast/media/cma/ipc/media_message_unittest.cc - Issue 2300993003: CmaRenderer is dead. Long live MojoRenderer.

Side by Side Diff: chromecast/media/cma/ipc/media_message_unittest.cc

Issue 2300993003: CmaRenderer is dead. Long live MojoRenderer. (Closed)

Patch Set: Created 4 years, 3 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 2014 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 "chromecast/media/cma/ipc/media_message.h"

6

7 #include <stddef.h>

8 #include <stdint.h>

9

10 #include <memory>

11

12 #include "base/bind.h"

13 #include "chromecast/media/cma/ipc/media_memory_chunk.h"

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

15

16 namespace chromecast {

17 namespace media {

18

19 namespace {

20

21 class ExternalMemoryBlock

22 : public MediaMemoryChunk {

23 public:

24 ExternalMemoryBlock(void* data, size_t size)

25 : data_(data), size_(size) {}

26 ~ExternalMemoryBlock() override {}

27

28 // MediaMemoryChunk implementation.

29 void* data() const override { return data_; }

30 size_t size() const override { return size_; }

31 bool valid() const override { return true; }

32

33 private:

34 void* const data_;

35 const size_t size_;

36 };

37

38 std::unique_ptr<MediaMemoryChunk> DummyAllocator(void* data,

39 size_t size,

40 size_t alloc_size) {

41 CHECK_LE(alloc_size, size);

42 return std::unique_ptr<MediaMemoryChunk>(

43 new ExternalMemoryBlock(data, alloc_size));

44 }

45

46 }

47

48 TEST(MediaMessageTest, WriteRead) {

49 int buffer_size = 1024;

50 std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);

51 MediaMessage::MemoryAllocatorCB mem_alloc_cb(

52 base::Bind(&DummyAllocator, buffer.get(), buffer_size));

53 uint32_t type = 0x1;

54 int msg_content_capacity = 512;

55

56 // Write a message.

57 int count = 64;

58 std::unique_ptr<MediaMessage> msg1(

59 MediaMessage::CreateMessage(type, mem_alloc_cb, msg_content_capacity));

60 for (int k = 0; k < count; k++) {

61 int v1 = 2 * k + 1;

62 EXPECT_TRUE(msg1->WritePod(v1));

63 uint8_t v2 = k;

64 EXPECT_TRUE(msg1->WritePod(v2));

65 }

66 EXPECT_EQ(msg1->content_size(), count * (sizeof(int) + sizeof(uint8_t)));

67

68 // Verify the integrity of the message.

69 std::unique_ptr<MediaMessage> msg2(

70 MediaMessage::MapMessage(std::unique_ptr<MediaMemoryChunk>(

71 new ExternalMemoryBlock(&buffer[0], buffer_size))));

72 for (int k = 0; k < count; k++) {

73 int v1;

74 int expected_v1 = 2 * k + 1;

75 EXPECT_TRUE(msg2->ReadPod(&v1));

76 EXPECT_EQ(v1, expected_v1);

77 uint8_t v2;

78 uint8_t expected_v2 = k;

79 EXPECT_TRUE(msg2->ReadPod(&v2));

80 EXPECT_EQ(v2, expected_v2);

81 }

82 }

83

84 TEST(MediaMessageTest, WriteOverflow) {

85 int buffer_size = 1024;

86 std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);

87 MediaMessage::MemoryAllocatorCB mem_alloc_cb(

88 base::Bind(&DummyAllocator, buffer.get(), buffer_size));

89 uint32_t type = 0x1;

90 int msg_content_capacity = 8;

91

92 std::unique_ptr<MediaMessage> msg1(

93 MediaMessage::CreateMessage(type, mem_alloc_cb, msg_content_capacity));

94 uint32_t v1 = 0;

95 uint8_t v2 = 0;

96 EXPECT_TRUE(msg1->WritePod(v1));

97 EXPECT_TRUE(msg1->WritePod(v1));

98

99 EXPECT_FALSE(msg1->WritePod(v1));

100 EXPECT_FALSE(msg1->WritePod(v2));

101 }

102

103 TEST(MediaMessageTest, ReadOverflow) {

104 int buffer_size = 1024;

105 std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);

106 MediaMessage::MemoryAllocatorCB mem_alloc_cb(

107 base::Bind(&DummyAllocator, buffer.get(), buffer_size));

108 uint32_t type = 0x1;

109 int msg_content_capacity = 8;

110

111 std::unique_ptr<MediaMessage> msg1(

112 MediaMessage::CreateMessage(type, mem_alloc_cb, msg_content_capacity));

113 uint32_t v1 = 0xcd;

114 EXPECT_TRUE(msg1->WritePod(v1));

115 EXPECT_TRUE(msg1->WritePod(v1));

116

117 std::unique_ptr<MediaMessage> msg2(

118 MediaMessage::MapMessage(std::unique_ptr<MediaMemoryChunk>(

119 new ExternalMemoryBlock(&buffer[0], buffer_size))));

120 uint32_t v2;

121 EXPECT_TRUE(msg2->ReadPod(&v2));

122 EXPECT_EQ(v2, v1);

123 EXPECT_TRUE(msg2->ReadPod(&v2));

124 EXPECT_EQ(v2, v1);

125 EXPECT_FALSE(msg2->ReadPod(&v2));

126 }

127

128 TEST(MediaMessageTest, DummyMessage) {

129 int buffer_size = 1024;

130 std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]);

131 MediaMessage::MemoryAllocatorCB mem_alloc_cb(

132 base::Bind(&DummyAllocator, buffer.get(), buffer_size));

133 uint32_t type = 0x1;

134

135 // Create first a dummy message to estimate the content size.

136 std::unique_ptr<MediaMessage> msg1(MediaMessage::CreateDummyMessage(type));

137 uint32_t v1 = 0xcd;

138 EXPECT_TRUE(msg1->WritePod(v1));

139 EXPECT_TRUE(msg1->WritePod(v1));

140

141 // Create the real message and write the actual content.

142 std::unique_ptr<MediaMessage> msg2(

143 MediaMessage::CreateMessage(type, mem_alloc_cb, msg1->content_size()));

144 EXPECT_TRUE(msg2->WritePod(v1));

145 EXPECT_TRUE(msg2->WritePod(v1));

146 EXPECT_FALSE(msg2->WritePod(v1));

147 }

148

149 } // namespace media

150 } // namespace chromecast

OLD	NEW

« chromecast/browser/cast_browser_main_parts.cc ('K') | « chromecast/media/cma/ipc/media_message_type.h ('k') | chromecast/media/cma/ipc_streamer/BUILD.gn » ('j') | no next file with comments »