OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 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 "remoting/host/resizing_host_observer.h" |
| 6 |
5 #include <list> | 7 #include <list> |
| 8 #include <utility> |
6 | 9 |
7 #include "base/compiler_specific.h" | 10 #include "base/compiler_specific.h" |
8 #include "base/logging.h" | 11 #include "base/logging.h" |
9 #include "base/macros.h" | 12 #include "base/macros.h" |
10 #include "base/memory/ref_counted.h" | 13 #include "base/memory/ref_counted.h" |
11 #include "base/message_loop/message_loop.h" | 14 #include "base/message_loop/message_loop.h" |
12 #include "base/run_loop.h" | 15 #include "base/run_loop.h" |
13 #include "remoting/host/desktop_resizer.h" | 16 #include "remoting/host/desktop_resizer.h" |
14 #include "remoting/host/resizing_host_observer.h" | |
15 #include "remoting/host/screen_resolution.h" | 17 #include "remoting/host/screen_resolution.h" |
16 #include "testing/gtest/include/gtest/gtest.h" | 18 #include "testing/gtest/include/gtest/gtest.h" |
17 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h" | 19 #include "third_party/webrtc/modules/desktop_capture/desktop_geometry.h" |
18 | 20 |
19 namespace remoting { | 21 namespace remoting { |
20 | 22 |
21 std::ostream& operator<<(std::ostream& os, const ScreenResolution& resolution) { | 23 std::ostream& operator<<(std::ostream& os, const ScreenResolution& resolution) { |
22 return os << resolution.dimensions().width() << "x" | 24 return os << resolution.dimensions().width() << "x" |
23 << resolution.dimensions().height() << " @ " | 25 << resolution.dimensions().height() << " @ " |
24 << resolution.dpi().x() << "x" << resolution.dpi().y(); | 26 << resolution.dpi().x() << "x" << resolution.dpi().y(); |
(...skipping 77 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
102 base::Time GetTime() { | 104 base::Time GetTime() { |
103 return now_; | 105 return now_; |
104 } | 106 } |
105 | 107 |
106 protected: | 108 protected: |
107 void SetDesktopResizer(scoped_ptr<FakeDesktopResizer> desktop_resizer) { | 109 void SetDesktopResizer(scoped_ptr<FakeDesktopResizer> desktop_resizer) { |
108 CHECK(!desktop_resizer_) << "Call SetDeskopResizer once per test"; | 110 CHECK(!desktop_resizer_) << "Call SetDeskopResizer once per test"; |
109 desktop_resizer_ = desktop_resizer.get(); | 111 desktop_resizer_ = desktop_resizer.get(); |
110 | 112 |
111 resizing_host_observer_.reset( | 113 resizing_host_observer_.reset( |
112 new ResizingHostObserver(desktop_resizer.Pass())); | 114 new ResizingHostObserver(std::move(desktop_resizer))); |
113 resizing_host_observer_->SetNowFunctionForTesting( | 115 resizing_host_observer_->SetNowFunctionForTesting( |
114 base::Bind(&ResizingHostObserverTest::GetTimeAndIncrement, | 116 base::Bind(&ResizingHostObserverTest::GetTimeAndIncrement, |
115 base::Unretained(this))); | 117 base::Unretained(this))); |
116 } | 118 } |
117 | 119 |
118 ScreenResolution GetBestResolution(const ScreenResolution& client_size) { | 120 ScreenResolution GetBestResolution(const ScreenResolution& client_size) { |
119 resizing_host_observer_->SetScreenResolution(client_size); | 121 resizing_host_observer_->SetScreenResolution(client_size); |
120 return desktop_resizer_->GetCurrentResolution(); | 122 return desktop_resizer_->GetCurrentResolution(); |
121 } | 123 } |
122 | 124 |
(...skipping 18 matching lines...) Expand all Loading... |
141 base::Time now_; | 143 base::Time now_; |
142 }; | 144 }; |
143 | 145 |
144 // Check that the resolution isn't restored if it wasn't changed by this class. | 146 // Check that the resolution isn't restored if it wasn't changed by this class. |
145 TEST_F(ResizingHostObserverTest, NoRestoreResolution) { | 147 TEST_F(ResizingHostObserverTest, NoRestoreResolution) { |
146 int restore_resolution_call_count = 0; | 148 int restore_resolution_call_count = 0; |
147 ScreenResolution initial = MakeResolution(640, 480); | 149 ScreenResolution initial = MakeResolution(640, 480); |
148 scoped_ptr<FakeDesktopResizer> desktop_resizer( | 150 scoped_ptr<FakeDesktopResizer> desktop_resizer( |
149 new FakeDesktopResizer(initial, false, nullptr, 0, | 151 new FakeDesktopResizer(initial, false, nullptr, 0, |
150 &restore_resolution_call_count)); | 152 &restore_resolution_call_count)); |
151 SetDesktopResizer(desktop_resizer.Pass()); | 153 SetDesktopResizer(std::move(desktop_resizer)); |
152 VerifySizes(nullptr, nullptr, 0); | 154 VerifySizes(nullptr, nullptr, 0); |
153 resizing_host_observer_.reset(); | 155 resizing_host_observer_.reset(); |
154 EXPECT_EQ(0, restore_resolution_call_count); | 156 EXPECT_EQ(0, restore_resolution_call_count); |
155 } | 157 } |
156 | 158 |
157 // Check that the host is not resized if GetSupportedSizes returns an empty | 159 // Check that the host is not resized if GetSupportedSizes returns an empty |
158 // list (even if GetCurrentSize is supported). | 160 // list (even if GetCurrentSize is supported). |
159 TEST_F(ResizingHostObserverTest, EmptyGetSupportedSizes) { | 161 TEST_F(ResizingHostObserverTest, EmptyGetSupportedSizes) { |
160 int restore_resolution_call_count = 0; | 162 int restore_resolution_call_count = 0; |
161 ScreenResolution initial = MakeResolution(640, 480); | 163 ScreenResolution initial = MakeResolution(640, 480); |
162 scoped_ptr<FakeDesktopResizer> desktop_resizer( | 164 scoped_ptr<FakeDesktopResizer> desktop_resizer( |
163 new FakeDesktopResizer(initial, false, nullptr, 0, | 165 new FakeDesktopResizer(initial, false, nullptr, 0, |
164 &restore_resolution_call_count)); | 166 &restore_resolution_call_count)); |
165 SetDesktopResizer(desktop_resizer.Pass()); | 167 SetDesktopResizer(std::move(desktop_resizer)); |
166 | 168 |
167 ScreenResolution client_sizes[] = { MakeResolution(200, 100), | 169 ScreenResolution client_sizes[] = { MakeResolution(200, 100), |
168 MakeResolution(100, 200) }; | 170 MakeResolution(100, 200) }; |
169 ScreenResolution expected_sizes[] = { initial, initial }; | 171 ScreenResolution expected_sizes[] = { initial, initial }; |
170 VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes)); | 172 VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes)); |
171 | 173 |
172 resizing_host_observer_.reset(); | 174 resizing_host_observer_.reset(); |
173 EXPECT_EQ(0, restore_resolution_call_count); | 175 EXPECT_EQ(0, restore_resolution_call_count); |
174 } | 176 } |
175 | 177 |
176 // Check that if the implementation supports exact size matching, it is used. | 178 // Check that if the implementation supports exact size matching, it is used. |
177 TEST_F(ResizingHostObserverTest, SelectExactSize) { | 179 TEST_F(ResizingHostObserverTest, SelectExactSize) { |
178 int restore_resolution_call_count = 0; | 180 int restore_resolution_call_count = 0; |
179 scoped_ptr<FakeDesktopResizer> desktop_resizer( | 181 scoped_ptr<FakeDesktopResizer> desktop_resizer( |
180 new FakeDesktopResizer(MakeResolution(640, 480), true, nullptr, 0, | 182 new FakeDesktopResizer(MakeResolution(640, 480), true, nullptr, 0, |
181 &restore_resolution_call_count)); | 183 &restore_resolution_call_count)); |
182 SetDesktopResizer(desktop_resizer.Pass()); | 184 SetDesktopResizer(std::move(desktop_resizer)); |
183 | 185 |
184 ScreenResolution client_sizes[] = { MakeResolution(200, 100), | 186 ScreenResolution client_sizes[] = { MakeResolution(200, 100), |
185 MakeResolution(100, 200), | 187 MakeResolution(100, 200), |
186 MakeResolution(640, 480), | 188 MakeResolution(640, 480), |
187 MakeResolution(480, 640), | 189 MakeResolution(480, 640), |
188 MakeResolution(1280, 1024) }; | 190 MakeResolution(1280, 1024) }; |
189 VerifySizes(client_sizes, client_sizes, arraysize(client_sizes)); | 191 VerifySizes(client_sizes, client_sizes, arraysize(client_sizes)); |
190 resizing_host_observer_.reset(); | 192 resizing_host_observer_.reset(); |
191 EXPECT_EQ(1, restore_resolution_call_count); | 193 EXPECT_EQ(1, restore_resolution_call_count); |
192 } | 194 } |
193 | 195 |
194 // Check that if the implementation supports a size that is no larger than | 196 // Check that if the implementation supports a size that is no larger than |
195 // the requested size, then the largest such size is used. | 197 // the requested size, then the largest such size is used. |
196 TEST_F(ResizingHostObserverTest, SelectBestSmallerSize) { | 198 TEST_F(ResizingHostObserverTest, SelectBestSmallerSize) { |
197 ScreenResolution supported_sizes[] = { MakeResolution(639, 479), | 199 ScreenResolution supported_sizes[] = { MakeResolution(639, 479), |
198 MakeResolution(640, 480) }; | 200 MakeResolution(640, 480) }; |
199 scoped_ptr<FakeDesktopResizer> desktop_resizer( | 201 scoped_ptr<FakeDesktopResizer> desktop_resizer( |
200 new FakeDesktopResizer(MakeResolution(640, 480), false, | 202 new FakeDesktopResizer(MakeResolution(640, 480), false, |
201 supported_sizes, arraysize(supported_sizes), | 203 supported_sizes, arraysize(supported_sizes), |
202 nullptr)); | 204 nullptr)); |
203 SetDesktopResizer(desktop_resizer.Pass()); | 205 SetDesktopResizer(std::move(desktop_resizer)); |
204 | 206 |
205 ScreenResolution client_sizes[] = { MakeResolution(639, 479), | 207 ScreenResolution client_sizes[] = { MakeResolution(639, 479), |
206 MakeResolution(640, 480), | 208 MakeResolution(640, 480), |
207 MakeResolution(641, 481), | 209 MakeResolution(641, 481), |
208 MakeResolution(999, 999) }; | 210 MakeResolution(999, 999) }; |
209 ScreenResolution expected_sizes[] = { supported_sizes[0], supported_sizes[1], | 211 ScreenResolution expected_sizes[] = { supported_sizes[0], supported_sizes[1], |
210 supported_sizes[1], supported_sizes[1] }; | 212 supported_sizes[1], supported_sizes[1] }; |
211 VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes)); | 213 VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes)); |
212 } | 214 } |
213 | 215 |
214 // Check that if the implementation supports only sizes that are larger than | 216 // Check that if the implementation supports only sizes that are larger than |
215 // the requested size, then the one that requires the least down-scaling. | 217 // the requested size, then the one that requires the least down-scaling. |
216 TEST_F(ResizingHostObserverTest, SelectBestScaleFactor) { | 218 TEST_F(ResizingHostObserverTest, SelectBestScaleFactor) { |
217 ScreenResolution supported_sizes[] = { MakeResolution(100, 100), | 219 ScreenResolution supported_sizes[] = { MakeResolution(100, 100), |
218 MakeResolution(200, 100) }; | 220 MakeResolution(200, 100) }; |
219 scoped_ptr<FakeDesktopResizer> desktop_resizer( | 221 scoped_ptr<FakeDesktopResizer> desktop_resizer( |
220 new FakeDesktopResizer(MakeResolution(200, 100), false, | 222 new FakeDesktopResizer(MakeResolution(200, 100), false, |
221 supported_sizes, arraysize(supported_sizes), | 223 supported_sizes, arraysize(supported_sizes), |
222 nullptr)); | 224 nullptr)); |
223 SetDesktopResizer(desktop_resizer.Pass()); | 225 SetDesktopResizer(std::move(desktop_resizer)); |
224 | 226 |
225 ScreenResolution client_sizes[] = { MakeResolution(1, 1), | 227 ScreenResolution client_sizes[] = { MakeResolution(1, 1), |
226 MakeResolution(99, 99), | 228 MakeResolution(99, 99), |
227 MakeResolution(199, 99) }; | 229 MakeResolution(199, 99) }; |
228 ScreenResolution expected_sizes[] = { supported_sizes[0], supported_sizes[0], | 230 ScreenResolution expected_sizes[] = { supported_sizes[0], supported_sizes[0], |
229 supported_sizes[1] }; | 231 supported_sizes[1] }; |
230 VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes)); | 232 VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes)); |
231 } | 233 } |
232 | 234 |
233 // Check that if the implementation supports two sizes that have the same | 235 // Check that if the implementation supports two sizes that have the same |
234 // resultant scale factor, then the widest one is selected. | 236 // resultant scale factor, then the widest one is selected. |
235 TEST_F(ResizingHostObserverTest, SelectWidest) { | 237 TEST_F(ResizingHostObserverTest, SelectWidest) { |
236 ScreenResolution supported_sizes[] = { MakeResolution(640, 480), | 238 ScreenResolution supported_sizes[] = { MakeResolution(640, 480), |
237 MakeResolution(480, 640) }; | 239 MakeResolution(480, 640) }; |
238 scoped_ptr<FakeDesktopResizer> desktop_resizer( | 240 scoped_ptr<FakeDesktopResizer> desktop_resizer( |
239 new FakeDesktopResizer(MakeResolution(480, 640), false, | 241 new FakeDesktopResizer(MakeResolution(480, 640), false, |
240 supported_sizes, arraysize(supported_sizes), | 242 supported_sizes, arraysize(supported_sizes), |
241 nullptr)); | 243 nullptr)); |
242 SetDesktopResizer(desktop_resizer.Pass()); | 244 SetDesktopResizer(std::move(desktop_resizer)); |
243 | 245 |
244 ScreenResolution client_sizes[] = { MakeResolution(100, 100), | 246 ScreenResolution client_sizes[] = { MakeResolution(100, 100), |
245 MakeResolution(480, 480), | 247 MakeResolution(480, 480), |
246 MakeResolution(500, 500), | 248 MakeResolution(500, 500), |
247 MakeResolution(640, 640), | 249 MakeResolution(640, 640), |
248 MakeResolution(1000, 1000) }; | 250 MakeResolution(1000, 1000) }; |
249 ScreenResolution expected_sizes[] = { supported_sizes[0], supported_sizes[0], | 251 ScreenResolution expected_sizes[] = { supported_sizes[0], supported_sizes[0], |
250 supported_sizes[0], supported_sizes[0], | 252 supported_sizes[0], supported_sizes[0], |
251 supported_sizes[0] }; | 253 supported_sizes[0] }; |
252 VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes)); | 254 VerifySizes(client_sizes, expected_sizes, arraysize(client_sizes)); |
(...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
301 FROM_HERE, | 303 FROM_HERE, |
302 run_loop.QuitClosure(), | 304 run_loop.QuitClosure(), |
303 base::TimeDelta::FromMilliseconds(2)); | 305 base::TimeDelta::FromMilliseconds(2)); |
304 run_loop.Run(); | 306 run_loop.Run(); |
305 | 307 |
306 // If the QuitClosure fired before the final resize, it's a test failure. | 308 // If the QuitClosure fired before the final resize, it's a test failure. |
307 EXPECT_EQ(desktop_resizer_->GetCurrentResolution(), MakeResolution(300, 300)); | 309 EXPECT_EQ(desktop_resizer_->GetCurrentResolution(), MakeResolution(300, 300)); |
308 } | 310 } |
309 | 311 |
310 } // namespace remoting | 312 } // namespace remoting |
OLD | NEW |