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 3 // found in the LICENSE file. 4 5 #include "ash/wm/video_detector.h" 6 7 #include "ash/shell.h" 8 #include "ash/test/ash_test_base.h" 9 #include "ash/wm/window_state.h" 10 #include "ash/wm/wm_event.h" 11 #include "base/compiler_specific.h" 12 #include "base/memory/scoped_ptr.h" 13 #include "base/time/time.h" 14 #include "third_party/skia/include/core/SkColor.h" 15 #include "ui/aura/client/aura_constants.h" 16 #include "ui/aura/test/test_windows.h" 17 #include "ui/aura/window.h" 18 #include "ui/aura/window_event_dispatcher.h" 19 #include "ui/gfx/rect.h" 20 #include "ui/wm/public/window_types.h" 21 22 namespace ash { 23 namespace test { 24 25 // Implementation that just counts the number of times we've been told that a 26 // video is playing. 27 class TestVideoDetectorObserver : public VideoDetectorObserver { 28 public: 29 TestVideoDetectorObserver() : num_invocations_(0), 30 num_fullscreens_(0), 31 num_not_fullscreens_(0) {} 32 33 int num_invocations() const { return num_invocations_; } 34 int num_fullscreens() const { return num_fullscreens_; } 35 int num_not_fullscreens() const { return num_not_fullscreens_; } 36 void reset_stats() { 37 num_invocations_ = 0; 38 num_fullscreens_ = 0; 39 num_not_fullscreens_ = 0; 40 } 41 42 // VideoDetectorObserver implementation. 43 virtual void OnVideoDetected(bool is_fullscreen) OVERRIDE { 44 num_invocations_++; 45 if (is_fullscreen) 46 num_fullscreens_++; 47 else 48 num_not_fullscreens_++; 49 } 50 51 private: 52 // Number of times that OnVideoDetected() has been called. 53 int num_invocations_; 54 // Number of times that OnVideoDetected() has been called with is_fullscreen 55 // == true. 56 int num_fullscreens_; 57 // Number of times that OnVideoDetected() has been called with is_fullscreen 58 // == false. 59 int num_not_fullscreens_; 60 61 DISALLOW_COPY_AND_ASSIGN(TestVideoDetectorObserver); 62 }; 63 64 class VideoDetectorTest : public AshTestBase { 65 public: 66 VideoDetectorTest() {} 67 virtual ~VideoDetectorTest() {} 68 69 virtual void SetUp() OVERRIDE { 70 AshTestBase::SetUp(); 71 observer_.reset(new TestVideoDetectorObserver); 72 detector_ = Shell::GetInstance()->video_detector(); 73 detector_->AddObserver(observer_.get()); 74 75 now_ = base::TimeTicks::Now(); 76 detector_->set_now_for_test(now_); 77 } 78 79 virtual void TearDown() OVERRIDE { 80 detector_->RemoveObserver(observer_.get()); 81 AshTestBase::TearDown(); 82 } 83 84 protected: 85 // Move |detector_|'s idea of the current time forward by |delta|. 86 void AdvanceTime(base::TimeDelta delta) { 87 now_ += delta; 88 detector_->set_now_for_test(now_); 89 } 90 91 VideoDetector* detector_; // not owned 92 93 scoped_ptr<TestVideoDetectorObserver> observer_; 94 95 base::TimeTicks now_; 96 97 private: 98 DISALLOW_COPY_AND_ASSIGN(VideoDetectorTest); 99 }; 100 101 TEST_F(VideoDetectorTest, Basic) { 102 gfx::Rect window_bounds(gfx::Point(), gfx::Size(1024, 768)); 103 scoped_ptr<aura::Window> window( 104 CreateTestWindowInShell(SK_ColorRED, 12345, window_bounds)); 105 106 // Send enough updates, but make them be too small to trigger detection. 107 gfx::Rect update_region( 108 gfx::Point(), 109 gfx::Size(VideoDetector::kMinUpdateWidth - 1, 110 VideoDetector::kMinUpdateHeight)); 111 for (int i = 0; i < VideoDetector::kMinFramesPerSecond; ++i) 112 detector_->OnDelegatedFrameDamage(window.get(), update_region); 113 EXPECT_EQ(0, observer_->num_invocations()); 114 115 // Send not-quite-enough adaquately-sized updates. 116 observer_->reset_stats(); 117 AdvanceTime(base::TimeDelta::FromSeconds(2)); 118 update_region.set_size( 119 gfx::Size(VideoDetector::kMinUpdateWidth, 120 VideoDetector::kMinUpdateHeight)); 121 for (int i = 0; i < VideoDetector::kMinFramesPerSecond - 1; ++i) 122 detector_->OnDelegatedFrameDamage(window.get(), update_region); 123 EXPECT_EQ(0, observer_->num_invocations()); 124 125 // We should get notified after the next update, but not in response to 126 // additional updates. 127 detector_->OnDelegatedFrameDamage(window.get(), update_region); 128 EXPECT_EQ(1, observer_->num_invocations()); 129 EXPECT_EQ(0, observer_->num_fullscreens()); 130 EXPECT_EQ(1, observer_->num_not_fullscreens()); 131 detector_->OnDelegatedFrameDamage(window.get(), update_region); 132 EXPECT_EQ(1, observer_->num_invocations()); 133 EXPECT_EQ(0, observer_->num_fullscreens()); 134 EXPECT_EQ(1, observer_->num_not_fullscreens()); 135 136 // Spread out the frames over a longer period of time, but send enough 137 // over a one-second window that the observer should be notified. 138 observer_->reset_stats(); 139 AdvanceTime(base::TimeDelta::FromSeconds(2)); 140 detector_->OnDelegatedFrameDamage(window.get(), update_region); 141 EXPECT_EQ(0, observer_->num_invocations()); 142 143 AdvanceTime(base::TimeDelta::FromMilliseconds(500)); 144 const int kNumFrames = VideoDetector::kMinFramesPerSecond + 1; 145 base::TimeDelta kInterval = 146 base::TimeDelta::FromMilliseconds(1000 / kNumFrames); 147 for (int i = 0; i < kNumFrames; ++i) { 148 AdvanceTime(kInterval); 149 detector_->OnDelegatedFrameDamage(window.get(), update_region); 150 } 151 EXPECT_EQ(1, observer_->num_invocations()); 152 153 // Keep going and check that the observer is notified again. 154 for (int i = 0; i < kNumFrames; ++i) { 155 AdvanceTime(kInterval); 156 detector_->OnDelegatedFrameDamage(window.get(), update_region); 157 } 158 EXPECT_EQ(2, observer_->num_invocations()); 159 160 // Send updates at a slower rate and check that the observer isn't notified. 161 base::TimeDelta kSlowInterval = base::TimeDelta::FromMilliseconds( 162 1000 / (VideoDetector::kMinFramesPerSecond - 2)); 163 for (int i = 0; i < kNumFrames; ++i) { 164 AdvanceTime(kSlowInterval); 165 detector_->OnDelegatedFrameDamage(window.get(), update_region); 166 } 167 EXPECT_EQ(2, observer_->num_invocations()); 168 } 169 170 TEST_F(VideoDetectorTest, Shutdown) { 171 gfx::Rect window_bounds(gfx::Point(), gfx::Size(1024, 768)); 172 scoped_ptr<aura::Window> window( 173 CreateTestWindowInShell(SK_ColorRED, 12345, window_bounds)); 174 gfx::Rect update_region( 175 gfx::Point(), 176 gfx::Size(VideoDetector::kMinUpdateWidth, 177 VideoDetector::kMinUpdateHeight)); 178 179 // It should not detect video during the shutdown. 180 Shell::GetInstance()->OnAppTerminating(); 181 for (int i = 0; i < VideoDetector::kMinFramesPerSecond; ++i) 182 detector_->OnDelegatedFrameDamage(window.get(), update_region); 183 EXPECT_EQ(0, observer_->num_invocations()); 184 } 185 186 TEST_F(VideoDetectorTest, WindowNotVisible) { 187 gfx::Rect window_bounds(gfx::Point(), gfx::Size(1024, 768)); 188 scoped_ptr<aura::Window> window( 189 CreateTestWindowInShell(SK_ColorRED, 12345, window_bounds)); 190 191 // Reparent the window to the root to make sure that visibility changes aren't 192 // animated. 193 Shell::GetPrimaryRootWindow()->AddChild(window.get()); 194 195 // We shouldn't report video that's played in a hidden window. 196 window->Hide(); 197 gfx::Rect update_region( 198 gfx::Point(), 199 gfx::Size(VideoDetector::kMinUpdateWidth, 200 VideoDetector::kMinUpdateHeight)); 201 for (int i = 0; i < VideoDetector::kMinFramesPerSecond; ++i) 202 detector_->OnDelegatedFrameDamage(window.get(), update_region); 203 EXPECT_EQ(0, observer_->num_invocations()); 204 205 // Make the window visible and send more updates. 206 observer_->reset_stats(); 207 AdvanceTime(base::TimeDelta::FromSeconds(2)); 208 window->Show(); 209 for (int i = 0; i < VideoDetector::kMinFramesPerSecond; ++i) 210 detector_->OnDelegatedFrameDamage(window.get(), update_region); 211 EXPECT_EQ(1, observer_->num_invocations()); 212 EXPECT_EQ(0, observer_->num_fullscreens()); 213 EXPECT_EQ(1, observer_->num_not_fullscreens()); 214 215 // We also shouldn't report video in a window that's fully offscreen. 216 observer_->reset_stats(); 217 AdvanceTime(base::TimeDelta::FromSeconds(2)); 218 gfx::Rect offscreen_bounds( 219 gfx::Point(Shell::GetPrimaryRootWindow()->bounds().width(), 0), 220 window_bounds.size()); 221 window->SetBounds(offscreen_bounds); 222 ASSERT_EQ(offscreen_bounds, window->bounds()); 223 for (int i = 0; i < VideoDetector::kMinFramesPerSecond; ++i) 224 detector_->OnDelegatedFrameDamage(window.get(), update_region); 225 EXPECT_EQ(0, observer_->num_invocations()); 226 } 227 228 TEST_F(VideoDetectorTest, MultipleWindows) { 229 // Create two windows. 230 gfx::Rect window_bounds(gfx::Point(), gfx::Size(1024, 768)); 231 scoped_ptr<aura::Window> window1( 232 CreateTestWindowInShell(SK_ColorRED, 12345, window_bounds)); 233 scoped_ptr<aura::Window> window2( 234 CreateTestWindowInShell(SK_ColorBLUE, 23456, window_bounds)); 235 236 // Even if there's video playing in both, the observer should only receive a 237 // single notification. 238 gfx::Rect update_region( 239 gfx::Point(), 240 gfx::Size(VideoDetector::kMinUpdateWidth, 241 VideoDetector::kMinUpdateHeight)); 242 for (int i = 0; i < VideoDetector::kMinFramesPerSecond; ++i) 243 detector_->OnDelegatedFrameDamage(window1.get(), update_region); 244 for (int i = 0; i < VideoDetector::kMinFramesPerSecond; ++i) 245 detector_->OnDelegatedFrameDamage(window2.get(), update_region); 246 EXPECT_EQ(1, observer_->num_invocations()); 247 EXPECT_EQ(0, observer_->num_fullscreens()); 248 EXPECT_EQ(1, observer_->num_not_fullscreens()); 249 } 250 251 // Test that the observer receives repeated notifications. 252 TEST_F(VideoDetectorTest, RepeatedNotifications) { 253 gfx::Rect window_bounds(gfx::Point(), gfx::Size(1024, 768)); 254 scoped_ptr<aura::Window> window( 255 CreateTestWindowInShell(SK_ColorRED, 12345, window_bounds)); 256 257 gfx::Rect update_region( 258 gfx::Point(), 259 gfx::Size(VideoDetector::kMinUpdateWidth, 260 VideoDetector::kMinUpdateHeight)); 261 for (int i = 0; i < VideoDetector::kMinFramesPerSecond; ++i) 262 detector_->OnDelegatedFrameDamage(window.get(), update_region); 263 EXPECT_EQ(1, observer_->num_invocations()); 264 EXPECT_EQ(0, observer_->num_fullscreens()); 265 EXPECT_EQ(1, observer_->num_not_fullscreens()); 266 // Let enough time pass that a second notification should be sent. 267 observer_->reset_stats(); 268 AdvanceTime(base::TimeDelta::FromSeconds( 269 static_cast<int64>(VideoDetector::kNotifyIntervalSec + 1))); 270 for (int i = 0; i < VideoDetector::kMinFramesPerSecond; ++i) 271 detector_->OnDelegatedFrameDamage(window.get(), update_region); 272 EXPECT_EQ(1, observer_->num_invocations()); 273 EXPECT_EQ(0, observer_->num_fullscreens()); 274 EXPECT_EQ(1, observer_->num_not_fullscreens()); 275 } 276 277 // Test that the observer receives a true value when the window is fullscreen. 278 TEST_F(VideoDetectorTest, FullscreenWindow) { 279 if (!SupportsMultipleDisplays()) 280 return; 281 282 UpdateDisplay("1024x768,1024x768"); 283 284 const gfx::Rect kLeftBounds(gfx::Point(), gfx::Size(1024, 768)); 285 scoped_ptr<aura::Window> window( 286 CreateTestWindowInShell(SK_ColorRED, 12345, kLeftBounds)); 287 wm::WindowState* window_state = wm::GetWindowState(window.get()); 288 const wm::WMEvent toggle_fullscreen_event(wm::WM_EVENT_TOGGLE_FULLSCREEN); 289 window_state->OnWMEvent(&toggle_fullscreen_event); 290 ASSERT_TRUE(window_state->IsFullscreen()); 291 window->Focus(); 292 const gfx::Rect kUpdateRegion( 293 gfx::Point(), 294 gfx::Size(VideoDetector::kMinUpdateWidth, 295 VideoDetector::kMinUpdateHeight)); 296 for (int i = 0; i < VideoDetector::kMinFramesPerSecond; ++i) 297 detector_->OnDelegatedFrameDamage(window.get(), kUpdateRegion); 298 EXPECT_EQ(1, observer_->num_invocations()); 299 EXPECT_EQ(1, observer_->num_fullscreens()); 300 EXPECT_EQ(0, observer_->num_not_fullscreens()); 301 302 // Make the first window non-fullscreen and open a second fullscreen window on 303 // a different desktop. 304 window_state->OnWMEvent(&toggle_fullscreen_event); 305 ASSERT_FALSE(window_state->IsFullscreen()); 306 const gfx::Rect kRightBounds(gfx::Point(1024, 0), gfx::Size(1024, 768)); 307 scoped_ptr<aura::Window> other_window( 308 CreateTestWindowInShell(SK_ColorBLUE, 6789, kRightBounds)); 309 wm::WindowState* other_window_state = wm::GetWindowState(other_window.get()); 310 other_window_state->OnWMEvent(&toggle_fullscreen_event); 311 ASSERT_TRUE(other_window_state->IsFullscreen()); 312 313 // When video is detected in the first (now non-fullscreen) window, fullscreen 314 // video should still be reported due to the second window being fullscreen. 315 // This avoids situations where non-fullscreen video could be reported when 316 // multiple videos are playing in fullscreen and non-fullscreen windows. 317 observer_->reset_stats(); 318 AdvanceTime(base::TimeDelta::FromSeconds(2)); 319 for (int i = 0; i < VideoDetector::kMinFramesPerSecond; ++i) 320 detector_->OnDelegatedFrameDamage(window.get(), kUpdateRegion); 321 EXPECT_EQ(1, observer_->num_invocations()); 322 EXPECT_EQ(1, observer_->num_fullscreens()); 323 EXPECT_EQ(0, observer_->num_not_fullscreens()); 324 325 // Make the second window non-fullscreen and check that the next video report 326 // is non-fullscreen. 327 other_window_state->OnWMEvent(&toggle_fullscreen_event); 328 ASSERT_FALSE(other_window_state->IsFullscreen()); 329 observer_->reset_stats(); 330 AdvanceTime(base::TimeDelta::FromSeconds(2)); 331 for (int i = 0; i < VideoDetector::kMinFramesPerSecond; ++i) 332 detector_->OnDelegatedFrameDamage(window.get(), kUpdateRegion); 333 EXPECT_EQ(1, observer_->num_invocations()); 334 EXPECT_EQ(0, observer_->num_fullscreens()); 335 EXPECT_EQ(1, observer_->num_not_fullscreens()); 336 } 337 338 } // namespace test 339 } // namespace ash 340
