OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "base/message_loop.h" | 5 #include "base/message_loop.h" |
6 #include "gpu/command_buffer/common/command_buffer_mock.h" | 6 #include "gpu/command_buffer/common/command_buffer_mock.h" |
7 #include "gpu/command_buffer/service/gpu_scheduler.h" | 7 #include "gpu/command_buffer/service/gpu_scheduler.h" |
8 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" | 8 #include "gpu/command_buffer/service/gles2_cmd_decoder.h" |
9 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h" | 9 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h" |
10 #include "gpu/command_buffer/service/mocks.h" | 10 #include "gpu/command_buffer/service/mocks.h" |
(...skipping 12 matching lines...) Expand all Loading... |
23 using testing::SetArgumentPointee; | 23 using testing::SetArgumentPointee; |
24 using testing::StrictMock; | 24 using testing::StrictMock; |
25 | 25 |
26 namespace gpu { | 26 namespace gpu { |
27 | 27 |
28 const size_t kRingBufferSize = 1024; | 28 const size_t kRingBufferSize = 1024; |
29 const size_t kRingBufferEntries = kRingBufferSize / sizeof(CommandBufferEntry); | 29 const size_t kRingBufferEntries = kRingBufferSize / sizeof(CommandBufferEntry); |
30 | 30 |
31 class GpuSchedulerTest : public testing::Test { | 31 class GpuSchedulerTest : public testing::Test { |
32 protected: | 32 protected: |
| 33 static const int32 kTransferBufferId = 123; |
| 34 |
33 virtual void SetUp() { | 35 virtual void SetUp() { |
34 shared_memory_.reset(new ::base::SharedMemory); | 36 shared_memory_.reset(new ::base::SharedMemory); |
35 shared_memory_->CreateAndMapAnonymous(kRingBufferSize); | 37 shared_memory_->CreateAndMapAnonymous(kRingBufferSize); |
36 buffer_ = static_cast<int32*>(shared_memory_->memory()); | 38 buffer_ = static_cast<int32*>(shared_memory_->memory()); |
37 shared_memory_buffer_.ptr = buffer_; | 39 shared_memory_buffer_.ptr = buffer_; |
38 shared_memory_buffer_.size = kRingBufferSize; | 40 shared_memory_buffer_.size = kRingBufferSize; |
39 memset(buffer_, 0, kRingBufferSize); | 41 memset(buffer_, 0, kRingBufferSize); |
40 | 42 |
41 command_buffer_.reset(new MockCommandBuffer); | 43 command_buffer_.reset(new MockCommandBuffer); |
42 ON_CALL(*command_buffer_.get(), GetRingBuffer()) | |
43 .WillByDefault(Return(shared_memory_buffer_)); | |
44 | 44 |
45 CommandBuffer::State default_state; | 45 CommandBuffer::State default_state; |
46 default_state.num_entries = kRingBufferEntries; | 46 default_state.num_entries = kRingBufferEntries; |
47 ON_CALL(*command_buffer_.get(), GetState()) | 47 ON_CALL(*command_buffer_.get(), GetState()) |
48 .WillByDefault(Return(default_state)); | 48 .WillByDefault(Return(default_state)); |
49 | 49 |
50 async_api_.reset(new StrictMock<AsyncAPIMock>); | |
51 | |
52 decoder_.reset(new gles2::MockGLES2Decoder()); | 50 decoder_.reset(new gles2::MockGLES2Decoder()); |
53 | |
54 parser_ = new CommandParser(buffer_, | |
55 kRingBufferEntries, | |
56 0, | |
57 kRingBufferEntries, | |
58 0, | |
59 async_api_.get()); | |
60 | |
61 scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(), | 51 scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(), |
62 decoder_.get(), | 52 decoder_.get(), |
63 parser_)); | 53 NULL)); |
| 54 EXPECT_CALL(*command_buffer_, GetTransferBuffer(kTransferBufferId)) |
| 55 .WillOnce(Return(shared_memory_buffer_)); |
| 56 EXPECT_CALL(*command_buffer_, SetGetOffset(0)); |
| 57 EXPECT_TRUE(scheduler_->SetGetBuffer(kTransferBufferId)); |
64 } | 58 } |
65 | 59 |
66 virtual void TearDown() { | 60 virtual void TearDown() { |
67 // Ensure that any unexpected tasks posted by the GPU scheduler are executed | 61 // Ensure that any unexpected tasks posted by the GPU scheduler are executed |
68 // in order to fail the test. | 62 // in order to fail the test. |
69 MessageLoop::current()->RunAllPending(); | 63 MessageLoop::current()->RunAllPending(); |
70 } | 64 } |
71 | 65 |
72 error::Error GetError() { | 66 error::Error GetError() { |
73 return command_buffer_->GetState().error; | 67 return command_buffer_->GetState().error; |
74 } | 68 } |
75 | 69 |
76 #if defined(OS_MACOSX) | 70 #if defined(OS_MACOSX) |
77 base::mac::ScopedNSAutoreleasePool autorelease_pool_; | 71 base::mac::ScopedNSAutoreleasePool autorelease_pool_; |
78 #endif | 72 #endif |
79 MessageLoop message_loop; | 73 MessageLoop message_loop; |
80 scoped_ptr<MockCommandBuffer> command_buffer_; | 74 scoped_ptr<MockCommandBuffer> command_buffer_; |
81 scoped_ptr<base::SharedMemory> shared_memory_; | 75 scoped_ptr<base::SharedMemory> shared_memory_; |
82 Buffer shared_memory_buffer_; | 76 Buffer shared_memory_buffer_; |
83 int32* buffer_; | 77 int32* buffer_; |
84 scoped_ptr<gles2::MockGLES2Decoder> decoder_; | 78 scoped_ptr<gles2::MockGLES2Decoder> decoder_; |
85 CommandParser* parser_; | |
86 scoped_ptr<AsyncAPIMock> async_api_; | |
87 scoped_ptr<GpuScheduler> scheduler_; | 79 scoped_ptr<GpuScheduler> scheduler_; |
88 }; | 80 }; |
89 | 81 |
90 TEST_F(GpuSchedulerTest, SchedulerDoesNothingIfRingBufferIsEmpty) { | 82 TEST_F(GpuSchedulerTest, SchedulerDoesNothingIfRingBufferIsEmpty) { |
91 CommandBuffer::State state; | 83 CommandBuffer::State state; |
92 | 84 |
93 state.put_offset = 0; | 85 state.put_offset = 0; |
94 EXPECT_CALL(*command_buffer_, GetState()) | 86 EXPECT_CALL(*command_buffer_, GetState()) |
95 .WillRepeatedly(Return(state)); | 87 .WillRepeatedly(Return(state)); |
96 | 88 |
97 EXPECT_CALL(*command_buffer_, SetParseError(_)) | 89 EXPECT_CALL(*command_buffer_, SetParseError(_)) |
98 .Times(0); | 90 .Times(0); |
99 | 91 |
100 scheduler_->PutChanged(); | 92 scheduler_->PutChanged(); |
101 } | 93 } |
102 | 94 |
| 95 TEST_F(GpuSchedulerTest, GetSetBuffer) { |
| 96 CommandBuffer::State state; |
| 97 |
| 98 // Set the get offset to something not 0. |
| 99 EXPECT_CALL(*command_buffer_, SetGetOffset(2)); |
| 100 scheduler_->SetGetOffset(2); |
| 101 EXPECT_EQ(2, scheduler_->GetGetOffset()); |
| 102 |
| 103 // Set the buffer. |
| 104 EXPECT_CALL(*command_buffer_, GetTransferBuffer(kTransferBufferId)) |
| 105 .WillOnce(Return(shared_memory_buffer_)); |
| 106 EXPECT_CALL(*command_buffer_, SetGetOffset(0)); |
| 107 EXPECT_TRUE(scheduler_->SetGetBuffer(kTransferBufferId)); |
| 108 |
| 109 // Check the get offset was reset. |
| 110 EXPECT_EQ(0, scheduler_->GetGetOffset()); |
| 111 } |
| 112 |
103 TEST_F(GpuSchedulerTest, ProcessesOneCommand) { | 113 TEST_F(GpuSchedulerTest, ProcessesOneCommand) { |
104 CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]); | 114 CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]); |
105 header[0].command = 7; | 115 header[0].command = 7; |
106 header[0].size = 2; | 116 header[0].size = 2; |
107 buffer_[1] = 123; | 117 buffer_[1] = 123; |
108 | 118 |
109 CommandBuffer::State state; | 119 CommandBuffer::State state; |
110 | 120 |
111 state.put_offset = 2; | 121 state.put_offset = 2; |
112 EXPECT_CALL(*command_buffer_, GetState()) | 122 EXPECT_CALL(*command_buffer_, GetState()) |
113 .WillRepeatedly(Return(state)); | 123 .WillRepeatedly(Return(state)); |
114 EXPECT_CALL(*command_buffer_, SetGetOffset(2)); | 124 EXPECT_CALL(*command_buffer_, SetGetOffset(2)); |
115 | 125 |
116 EXPECT_CALL(*async_api_, DoCommand(7, 1, &buffer_[0])) | 126 EXPECT_CALL(*decoder_, DoCommand(7, 1, &buffer_[0])) |
117 .WillOnce(Return(error::kNoError)); | 127 .WillOnce(Return(error::kNoError)); |
118 | 128 |
119 EXPECT_CALL(*command_buffer_, SetParseError(_)) | 129 EXPECT_CALL(*command_buffer_, SetParseError(_)) |
120 .Times(0); | 130 .Times(0); |
121 | 131 |
122 scheduler_->PutChanged(); | 132 scheduler_->PutChanged(); |
123 } | 133 } |
124 | 134 |
125 TEST_F(GpuSchedulerTest, ProcessesTwoCommands) { | 135 TEST_F(GpuSchedulerTest, ProcessesTwoCommands) { |
126 CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]); | 136 CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]); |
127 header[0].command = 7; | 137 header[0].command = 7; |
128 header[0].size = 2; | 138 header[0].size = 2; |
129 buffer_[1] = 123; | 139 buffer_[1] = 123; |
130 header[2].command = 8; | 140 header[2].command = 8; |
131 header[2].size = 1; | 141 header[2].size = 1; |
132 | 142 |
133 CommandBuffer::State state; | 143 CommandBuffer::State state; |
134 | 144 |
135 state.put_offset = 3; | 145 state.put_offset = 3; |
136 EXPECT_CALL(*command_buffer_, GetState()) | 146 EXPECT_CALL(*command_buffer_, GetState()) |
137 .WillRepeatedly(Return(state)); | 147 .WillRepeatedly(Return(state)); |
138 | 148 |
139 EXPECT_CALL(*async_api_, DoCommand(7, 1, &buffer_[0])) | 149 EXPECT_CALL(*decoder_, DoCommand(7, 1, &buffer_[0])) |
140 .WillOnce(Return(error::kNoError)); | 150 .WillOnce(Return(error::kNoError)); |
141 EXPECT_CALL(*command_buffer_, SetGetOffset(2)); | 151 EXPECT_CALL(*command_buffer_, SetGetOffset(2)); |
142 | 152 |
143 EXPECT_CALL(*async_api_, DoCommand(8, 0, &buffer_[2])) | 153 EXPECT_CALL(*decoder_, DoCommand(8, 0, &buffer_[2])) |
144 .WillOnce(Return(error::kNoError)); | 154 .WillOnce(Return(error::kNoError)); |
145 EXPECT_CALL(*command_buffer_, SetGetOffset(3)); | 155 EXPECT_CALL(*command_buffer_, SetGetOffset(3)); |
146 | 156 |
147 scheduler_->PutChanged(); | 157 scheduler_->PutChanged(); |
148 } | 158 } |
149 | 159 |
150 TEST_F(GpuSchedulerTest, SetsErrorCodeOnCommandBuffer) { | 160 TEST_F(GpuSchedulerTest, SetsErrorCodeOnCommandBuffer) { |
151 CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]); | 161 CommandHeader* header = reinterpret_cast<CommandHeader*>(&buffer_[0]); |
152 header[0].command = 7; | 162 header[0].command = 7; |
153 header[0].size = 1; | 163 header[0].size = 1; |
154 | 164 |
155 CommandBuffer::State state; | 165 CommandBuffer::State state; |
156 | 166 |
157 state.put_offset = 1; | 167 state.put_offset = 1; |
158 EXPECT_CALL(*command_buffer_, GetState()) | 168 EXPECT_CALL(*command_buffer_, GetState()) |
159 .WillRepeatedly(Return(state)); | 169 .WillRepeatedly(Return(state)); |
160 | 170 |
161 EXPECT_CALL(*async_api_, DoCommand(7, 0, &buffer_[0])) | 171 EXPECT_CALL(*decoder_, DoCommand(7, 0, &buffer_[0])) |
162 .WillOnce(Return( | 172 .WillOnce(Return( |
163 error::kUnknownCommand)); | 173 error::kUnknownCommand)); |
164 EXPECT_CALL(*command_buffer_, SetGetOffset(1)); | 174 EXPECT_CALL(*command_buffer_, SetGetOffset(1)); |
165 | 175 |
| 176 EXPECT_CALL(*command_buffer_, SetContextLostReason(_)); |
166 EXPECT_CALL(*decoder_, GetContextLostReason()) | 177 EXPECT_CALL(*decoder_, GetContextLostReason()) |
167 .WillOnce(Return(error::kUnknown)); | 178 .WillOnce(Return(error::kUnknown)); |
168 EXPECT_CALL(*command_buffer_, | 179 EXPECT_CALL(*command_buffer_, |
169 SetParseError(error::kUnknownCommand)); | 180 SetParseError(error::kUnknownCommand)); |
170 | 181 |
171 scheduler_->PutChanged(); | 182 scheduler_->PutChanged(); |
172 } | 183 } |
173 | 184 |
174 TEST_F(GpuSchedulerTest, ProcessCommandsDoesNothingAfterError) { | 185 TEST_F(GpuSchedulerTest, ProcessCommandsDoesNothingAfterError) { |
175 CommandBuffer::State state; | 186 CommandBuffer::State state; |
(...skipping 22 matching lines...) Expand all Loading... |
198 | 209 |
199 EXPECT_EQ(kRingBufferSize, scheduler_->GetSharedMemoryBuffer(7).size); | 210 EXPECT_EQ(kRingBufferSize, scheduler_->GetSharedMemoryBuffer(7).size); |
200 } | 211 } |
201 | 212 |
202 TEST_F(GpuSchedulerTest, SetTokenForwardsToCommandBuffer) { | 213 TEST_F(GpuSchedulerTest, SetTokenForwardsToCommandBuffer) { |
203 EXPECT_CALL(*command_buffer_, SetToken(7)); | 214 EXPECT_CALL(*command_buffer_, SetToken(7)); |
204 scheduler_->set_token(7); | 215 scheduler_->set_token(7); |
205 } | 216 } |
206 | 217 |
207 } // namespace gpu | 218 } // namespace gpu |
OLD | NEW |