| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2015 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 "base/command_line.h" | |
| 6 #include "base/test/histogram_tester.h" | |
| 7 #include "base/timer/mock_timer.h" | |
| 8 #include "base/values.h" | |
| 9 #include "chrome/browser/engagement/site_engagement_helper.h" | |
| 10 #include "chrome/browser/engagement/site_engagement_service.h" | |
| 11 #include "chrome/browser/engagement/site_engagement_service_factory.h" | |
| 12 #include "chrome/browser/ui/browser.h" | |
| 13 #include "chrome/browser/ui/tabs/tab_strip_model.h" | |
| 14 #include "chrome/common/chrome_switches.h" | |
| 15 #include "chrome/test/base/in_process_browser_test.h" | |
| 16 #include "chrome/test/base/ui_test_utils.h" | |
| 17 #include "content/public/test/browser_test_utils.h" | |
| 18 #include "testing/gtest/include/gtest/gtest.h" | |
| 19 #include "ui/events/keycodes/keyboard_codes.h" | |
| 20 | |
| 21 class SiteEngagementServiceBrowserTest : public InProcessBrowserTest { | |
| 22 public: | |
| 23 // Create a SiteEngagementHelper. Called here as friend class methods cannot | |
| 24 // be called in tests. | |
| 25 scoped_ptr<SiteEngagementHelper> CreateHelper( | |
| 26 content::WebContents* web_contents) { | |
| 27 scoped_ptr<SiteEngagementHelper> helper( | |
| 28 new SiteEngagementHelper(web_contents)); | |
| 29 DCHECK(helper.get()); | |
| 30 | |
| 31 return helper.Pass(); | |
| 32 } | |
| 33 | |
| 34 // Simulate a key press event and handle it. | |
| 35 void HandleKeyPress(SiteEngagementHelper* helper, ui::KeyboardCode key) { | |
| 36 content::NativeWebKeyboardEvent event; | |
| 37 event.windowsKeyCode = key; | |
| 38 event.type = blink::WebKeyboardEvent::RawKeyDown; | |
| 39 helper->input_tracker_.HandleKeyPressEvent(event); | |
| 40 } | |
| 41 | |
| 42 // Simulate a mouse event and handle it. | |
| 43 void HandleMouseEvent(SiteEngagementHelper* helper, | |
| 44 blink::WebMouseEvent::Button button, | |
| 45 blink::WebInputEvent::Type type) { | |
| 46 blink::WebMouseEvent event; | |
| 47 event.button = button; | |
| 48 event.type = type; | |
| 49 helper->input_tracker_.HandleMouseEvent(event); | |
| 50 } | |
| 51 | |
| 52 // Set a pause timer on the input tracker for test purposes. | |
| 53 void SetInputTrackerPauseTimer(SiteEngagementHelper* helper, | |
| 54 scoped_ptr<base::Timer> timer) { | |
| 55 helper->input_tracker_.SetPauseTimerForTesting(timer.Pass()); | |
| 56 } | |
| 57 | |
| 58 bool IsTracking(SiteEngagementHelper* helper) { | |
| 59 return helper->input_tracker_.is_tracking(); | |
| 60 } | |
| 61 | |
| 62 bool IsActive(SiteEngagementHelper* helper) { | |
| 63 return helper->input_tracker_.IsActive(); | |
| 64 } | |
| 65 | |
| 66 content::RenderViewHost* InputTrackerHost(SiteEngagementHelper* helper) { | |
| 67 return helper->input_tracker_.host(); | |
| 68 } | |
| 69 }; | |
| 70 | |
| 71 IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest, | |
| 72 KeyPressEngagementAccumulation) { | |
| 73 GURL url1("https://www.google.com/"); | |
| 74 GURL url2("http://www.google.com/"); | |
| 75 content::WebContents* web_contents = | |
| 76 browser()->tab_strip_model()->GetActiveWebContents(); | |
| 77 | |
| 78 scoped_ptr<SiteEngagementHelper> helper(CreateHelper(web_contents)); | |
| 79 SiteEngagementService* service = | |
| 80 SiteEngagementServiceFactory::GetForProfile(browser()->profile()); | |
| 81 DCHECK(service); | |
| 82 | |
| 83 // Check that navigation triggers engagement. | |
| 84 ui_test_utils::NavigateToURL(browser(), url1); | |
| 85 EXPECT_DOUBLE_EQ(0.5, service->GetScore(url1)); | |
| 86 EXPECT_EQ(0, service->GetScore(url2)); | |
| 87 | |
| 88 // Simulate a key press trigger and ensure it is treated correctly. | |
| 89 HandleKeyPress(helper.get(), ui::VKEY_DOWN); | |
| 90 | |
| 91 EXPECT_DOUBLE_EQ(0.55, service->GetScore(url1)); | |
| 92 EXPECT_EQ(0, service->GetScore(url2)); | |
| 93 | |
| 94 // Simulate three key presses, and ensure they are treated correctly. | |
| 95 HandleKeyPress(helper.get(), ui::VKEY_UP); | |
| 96 HandleKeyPress(helper.get(), ui::VKEY_RETURN); | |
| 97 HandleKeyPress(helper.get(), ui::VKEY_J); | |
| 98 | |
| 99 EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1)); | |
| 100 EXPECT_EQ(0, service->GetScore(url2)); | |
| 101 | |
| 102 // Simulate key presses for a different link. | |
| 103 ui_test_utils::NavigateToURL(browser(), url2); | |
| 104 | |
| 105 EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1)); | |
| 106 EXPECT_DOUBLE_EQ(0.5, service->GetScore(url2)); | |
| 107 EXPECT_DOUBLE_EQ(1.2, service->GetTotalEngagementPoints()); | |
| 108 | |
| 109 HandleKeyPress(helper.get(), ui::VKEY_K); | |
| 110 EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1)); | |
| 111 EXPECT_DOUBLE_EQ(0.55, service->GetScore(url2)); | |
| 112 EXPECT_DOUBLE_EQ(1.25, service->GetTotalEngagementPoints()); | |
| 113 } | |
| 114 | |
| 115 IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest, | |
| 116 MouseEventEngagementAccumulation) { | |
| 117 GURL url1("https://www.google.com/"); | |
| 118 GURL url2("http://www.google.com/"); | |
| 119 content::WebContents* web_contents = | |
| 120 browser()->tab_strip_model()->GetActiveWebContents(); | |
| 121 | |
| 122 scoped_ptr<SiteEngagementHelper> helper(CreateHelper(web_contents)); | |
| 123 SiteEngagementService* service = | |
| 124 SiteEngagementServiceFactory::GetForProfile(browser()->profile()); | |
| 125 DCHECK(service); | |
| 126 | |
| 127 ui_test_utils::NavigateToURL(browser(), url1); | |
| 128 EXPECT_DOUBLE_EQ(0.5, service->GetScore(url1)); | |
| 129 EXPECT_EQ(0, service->GetScore(url2)); | |
| 130 | |
| 131 HandleMouseEvent(helper.get(), blink::WebMouseEvent::ButtonLeft, | |
| 132 blink::WebInputEvent::MouseDown); | |
| 133 | |
| 134 EXPECT_DOUBLE_EQ(0.55, service->GetScore(url1)); | |
| 135 EXPECT_EQ(0, service->GetScore(url2)); | |
| 136 | |
| 137 HandleMouseEvent(helper.get(), blink::WebMouseEvent::ButtonRight, | |
| 138 blink::WebInputEvent::MouseWheel); | |
| 139 HandleMouseEvent(helper.get(), blink::WebMouseEvent::ButtonMiddle, | |
| 140 blink::WebInputEvent::MouseDown); | |
| 141 HandleMouseEvent(helper.get(), blink::WebMouseEvent::ButtonLeft, | |
| 142 blink::WebInputEvent::MouseDown); | |
| 143 | |
| 144 EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1)); | |
| 145 EXPECT_EQ(0, service->GetScore(url2)); | |
| 146 | |
| 147 ui_test_utils::NavigateToURL(browser(), url2); | |
| 148 | |
| 149 EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1)); | |
| 150 EXPECT_DOUBLE_EQ(0.5, service->GetScore(url2)); | |
| 151 EXPECT_DOUBLE_EQ(1.2, service->GetTotalEngagementPoints()); | |
| 152 | |
| 153 HandleMouseEvent(helper.get(), blink::WebMouseEvent::ButtonLeft, | |
| 154 blink::WebInputEvent::MouseDown); | |
| 155 EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1)); | |
| 156 EXPECT_DOUBLE_EQ(0.55, service->GetScore(url2)); | |
| 157 EXPECT_DOUBLE_EQ(1.25, service->GetTotalEngagementPoints()); | |
| 158 } | |
| 159 | |
| 160 IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest, | |
| 161 MixedInputEngagementAccumulation) { | |
| 162 GURL url1("https://www.google.com/"); | |
| 163 GURL url2("http://www.google.com/"); | |
| 164 content::WebContents* web_contents = | |
| 165 browser()->tab_strip_model()->GetActiveWebContents(); | |
| 166 | |
| 167 scoped_ptr<SiteEngagementHelper> helper(CreateHelper(web_contents)); | |
| 168 SiteEngagementService* service = | |
| 169 SiteEngagementServiceFactory::GetForProfile(browser()->profile()); | |
| 170 DCHECK(service); | |
| 171 | |
| 172 base::HistogramTester histograms; | |
| 173 | |
| 174 // Histograms should start off empty. | |
| 175 histograms.ExpectTotalCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 176 0); | |
| 177 | |
| 178 ui_test_utils::NavigateToURL(browser(), url1); | |
| 179 EXPECT_DOUBLE_EQ(0.5, service->GetScore(url1)); | |
| 180 EXPECT_EQ(0, service->GetScore(url2)); | |
| 181 histograms.ExpectTotalCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 182 1); | |
| 183 histograms.ExpectBucketCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 184 SiteEngagementMetrics::ENGAGEMENT_NAVIGATION, 1); | |
| 185 | |
| 186 HandleKeyPress(helper.get(), ui::VKEY_UP); | |
| 187 HandleKeyPress(helper.get(), ui::VKEY_RETURN); | |
| 188 HandleKeyPress(helper.get(), ui::VKEY_J); | |
| 189 | |
| 190 HandleMouseEvent(helper.get(), blink::WebMouseEvent::ButtonLeft, | |
| 191 blink::WebInputEvent::MouseDown); | |
| 192 | |
| 193 EXPECT_DOUBLE_EQ(0.7, service->GetScore(url1)); | |
| 194 EXPECT_EQ(0, service->GetScore(url2)); | |
| 195 histograms.ExpectTotalCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 196 5); | |
| 197 histograms.ExpectBucketCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 198 SiteEngagementMetrics::ENGAGEMENT_NAVIGATION, 1); | |
| 199 histograms.ExpectBucketCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 200 SiteEngagementMetrics::ENGAGEMENT_KEYPRESS, 3); | |
| 201 histograms.ExpectBucketCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 202 SiteEngagementMetrics::ENGAGEMENT_MOUSE, 1); | |
| 203 | |
| 204 HandleMouseEvent(helper.get(), blink::WebMouseEvent::ButtonRight, | |
| 205 blink::WebInputEvent::MouseDown); | |
| 206 HandleMouseEvent(helper.get(), blink::WebMouseEvent::ButtonMiddle, | |
| 207 blink::WebInputEvent::MouseDown); | |
| 208 HandleMouseEvent(helper.get(), blink::WebMouseEvent::ButtonNone, | |
| 209 blink::WebInputEvent::MouseWheel); | |
| 210 | |
| 211 EXPECT_DOUBLE_EQ(0.85, service->GetScore(url1)); | |
| 212 EXPECT_EQ(0, service->GetScore(url2)); | |
| 213 histograms.ExpectTotalCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 214 8); | |
| 215 histograms.ExpectBucketCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 216 SiteEngagementMetrics::ENGAGEMENT_MOUSE, 4); | |
| 217 | |
| 218 ui_test_utils::NavigateToURL(browser(), url2); | |
| 219 | |
| 220 EXPECT_DOUBLE_EQ(0.85, service->GetScore(url1)); | |
| 221 EXPECT_DOUBLE_EQ(0.5, service->GetScore(url2)); | |
| 222 EXPECT_DOUBLE_EQ(1.35, service->GetTotalEngagementPoints()); | |
| 223 | |
| 224 HandleMouseEvent(helper.get(), blink::WebMouseEvent::ButtonNone, | |
| 225 blink::WebInputEvent::MouseWheel); | |
| 226 HandleKeyPress(helper.get(), ui::VKEY_DOWN); | |
| 227 | |
| 228 EXPECT_DOUBLE_EQ(0.85, service->GetScore(url1)); | |
| 229 EXPECT_DOUBLE_EQ(0.6, service->GetScore(url2)); | |
| 230 EXPECT_DOUBLE_EQ(1.45, service->GetTotalEngagementPoints()); | |
| 231 histograms.ExpectTotalCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 232 11); | |
| 233 histograms.ExpectBucketCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 234 SiteEngagementMetrics::ENGAGEMENT_NAVIGATION, 2); | |
| 235 histograms.ExpectBucketCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 236 SiteEngagementMetrics::ENGAGEMENT_KEYPRESS, 4); | |
| 237 histograms.ExpectBucketCount(SiteEngagementMetrics::kEngagementTypeHistogram, | |
| 238 SiteEngagementMetrics::ENGAGEMENT_MOUSE, 5); | |
| 239 } | |
| 240 | |
| 241 IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest, | |
| 242 CheckTimerAndCallbacks) { | |
| 243 GURL url1("https://www.google.com/"); | |
| 244 GURL url2("http://www.google.com/"); | |
| 245 content::WebContents* web_contents = | |
| 246 browser()->tab_strip_model()->GetActiveWebContents(); | |
| 247 | |
| 248 base::MockTimer* input_tracker_timer = new base::MockTimer(true, false); | |
| 249 scoped_ptr<SiteEngagementHelper> helper(CreateHelper(web_contents)); | |
| 250 SetInputTrackerPauseTimer(helper.get(), make_scoped_ptr(input_tracker_timer)); | |
| 251 | |
| 252 SiteEngagementService* service = | |
| 253 SiteEngagementServiceFactory::GetForProfile(browser()->profile()); | |
| 254 DCHECK(service); | |
| 255 | |
| 256 ui_test_utils::NavigateToURL(browser(), url1); | |
| 257 EXPECT_DOUBLE_EQ(0.5, service->GetScore(url1)); | |
| 258 EXPECT_EQ(0, service->GetScore(url2)); | |
| 259 | |
| 260 // Timer should be running for navigation delay. | |
| 261 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 262 EXPECT_FALSE(IsTracking(helper.get())); | |
| 263 input_tracker_timer->Fire(); | |
| 264 | |
| 265 // Timer should start running again after input. | |
| 266 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 267 EXPECT_TRUE(IsTracking(helper.get())); | |
| 268 HandleKeyPress(helper.get(), ui::VKEY_RETURN); | |
| 269 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 270 EXPECT_FALSE(IsTracking(helper.get())); | |
| 271 | |
| 272 EXPECT_DOUBLE_EQ(0.55, service->GetScore(url1)); | |
| 273 EXPECT_EQ(0, service->GetScore(url2)); | |
| 274 | |
| 275 input_tracker_timer->Fire(); | |
| 276 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 277 EXPECT_TRUE(IsTracking(helper.get())); | |
| 278 | |
| 279 // Timer should start running again after input. | |
| 280 HandleMouseEvent(helper.get(), blink::WebMouseEvent::ButtonNone, | |
| 281 blink::WebInputEvent::MouseWheel); | |
| 282 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 283 EXPECT_FALSE(IsTracking(helper.get())); | |
| 284 | |
| 285 EXPECT_DOUBLE_EQ(0.6, service->GetScore(url1)); | |
| 286 EXPECT_EQ(0, service->GetScore(url2)); | |
| 287 | |
| 288 input_tracker_timer->Fire(); | |
| 289 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 290 EXPECT_TRUE(IsTracking(helper.get())); | |
| 291 | |
| 292 // Timer should be running for navigation delay. | |
| 293 ui_test_utils::NavigateToURL(browser(), url2); | |
| 294 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 295 EXPECT_FALSE(IsTracking(helper.get())); | |
| 296 | |
| 297 EXPECT_DOUBLE_EQ(0.6, service->GetScore(url1)); | |
| 298 EXPECT_DOUBLE_EQ(0.5, service->GetScore(url2)); | |
| 299 | |
| 300 input_tracker_timer->Fire(); | |
| 301 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 302 EXPECT_TRUE(IsTracking(helper.get())); | |
| 303 | |
| 304 HandleMouseEvent(helper.get(), blink::WebMouseEvent::ButtonRight, | |
| 305 blink::WebInputEvent::MouseDown); | |
| 306 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 307 EXPECT_FALSE(IsTracking(helper.get())); | |
| 308 | |
| 309 EXPECT_DOUBLE_EQ(0.6, service->GetScore(url1)); | |
| 310 EXPECT_DOUBLE_EQ(0.55, service->GetScore(url2)); | |
| 311 EXPECT_DOUBLE_EQ(1.15, service->GetTotalEngagementPoints()); | |
| 312 } | |
| 313 | |
| 314 // Ensure that navigation does not trigger input tracking until after a delay. | |
| 315 IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest, ShowAndHide) { | |
| 316 GURL url1("https://www.google.com/"); | |
| 317 GURL url2("http://www.google.com/"); | |
| 318 content::WebContents* web_contents = | |
| 319 browser()->tab_strip_model()->GetActiveWebContents(); | |
| 320 | |
| 321 base::MockTimer* input_tracker_timer = new base::MockTimer(true, false); | |
| 322 scoped_ptr<SiteEngagementHelper> helper(CreateHelper(web_contents)); | |
| 323 SetInputTrackerPauseTimer(helper.get(), make_scoped_ptr(input_tracker_timer)); | |
| 324 | |
| 325 ui_test_utils::NavigateToURL(browser(), url1); | |
| 326 input_tracker_timer->Fire(); | |
| 327 | |
| 328 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 329 EXPECT_TRUE(IsTracking(helper.get())); | |
| 330 | |
| 331 // Hiding the tab should stop input tracking. | |
| 332 ui_test_utils::NavigateToURLWithDisposition( | |
| 333 browser(), url2, NEW_FOREGROUND_TAB, | |
| 334 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); | |
| 335 | |
| 336 EXPECT_FALSE(IsTracking(helper.get())); | |
| 337 | |
| 338 // Showing the tab should start tracking again after another delay. | |
| 339 browser()->tab_strip_model()->ActivateTabAt(0, true); | |
| 340 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 341 EXPECT_FALSE(IsTracking(helper.get())); | |
| 342 | |
| 343 input_tracker_timer->Fire(); | |
| 344 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 345 EXPECT_TRUE(IsTracking(helper.get())); | |
| 346 | |
| 347 // New background tabs should not affect the current tab's input tracking. | |
| 348 ui_test_utils::NavigateToURLWithDisposition( | |
| 349 browser(), url2, NEW_BACKGROUND_TAB, | |
| 350 ui_test_utils::BROWSER_TEST_WAIT_FOR_TAB); | |
| 351 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 352 EXPECT_TRUE(IsTracking(helper.get())); | |
| 353 | |
| 354 // Ensure behavior holds when tab is hidden before the initial delay timer | |
| 355 // fires. | |
| 356 ui_test_utils::NavigateToURL(browser(), url2); | |
| 357 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 358 EXPECT_FALSE(IsTracking(helper.get())); | |
| 359 | |
| 360 ui_test_utils::NavigateToURLWithDisposition( | |
| 361 browser(), url2, NEW_FOREGROUND_TAB, | |
| 362 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); | |
| 363 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 364 EXPECT_FALSE(IsTracking(helper.get())); | |
| 365 | |
| 366 // Showing the tab should start tracking again after another delay. | |
| 367 browser()->tab_strip_model()->ActivateTabAt(0, true); | |
| 368 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 369 EXPECT_FALSE(IsTracking(helper.get())); | |
| 370 | |
| 371 input_tracker_timer->Fire(); | |
| 372 EXPECT_TRUE(IsTracking(helper.get())); | |
| 373 } | |
| 374 | |
| 375 // Ensure tracking behavior is correct for multiple navigations in a single tab. | |
| 376 IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest, SingleTabNavigation) { | |
| 377 GURL url1("https://www.google.com/"); | |
| 378 GURL url2("https://www.example.com/"); | |
| 379 content::WebContents* web_contents = | |
| 380 browser()->tab_strip_model()->GetActiveWebContents(); | |
| 381 | |
| 382 base::MockTimer* input_tracker_timer = new base::MockTimer(true, false); | |
| 383 scoped_ptr<SiteEngagementHelper> helper(CreateHelper(web_contents)); | |
| 384 SetInputTrackerPauseTimer(helper.get(), make_scoped_ptr(input_tracker_timer)); | |
| 385 | |
| 386 // Navigation should start the initial delay timer. | |
| 387 ui_test_utils::NavigateToURL(browser(), url1); | |
| 388 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 389 EXPECT_FALSE(IsTracking(helper.get())); | |
| 390 | |
| 391 // Navigating before the timer fires should simply reset the timer. | |
| 392 ui_test_utils::NavigateToURL(browser(), url2); | |
| 393 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 394 EXPECT_FALSE(IsTracking(helper.get())); | |
| 395 | |
| 396 // When the timer fires, callbacks are added. | |
| 397 input_tracker_timer->Fire(); | |
| 398 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 399 EXPECT_TRUE(IsTracking(helper.get())); | |
| 400 | |
| 401 // Navigation should start the initial delay timer again. | |
| 402 ui_test_utils::NavigateToURL(browser(), url1); | |
| 403 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 404 EXPECT_FALSE(IsTracking(helper.get())); | |
| 405 } | |
| 406 | |
| 407 // Ensure tracking behavior is correct for multiple navigations in a single tab. | |
| 408 IN_PROC_BROWSER_TEST_F(SiteEngagementServiceBrowserTest, SwitchRenderViewHost) { | |
| 409 GURL url1("https://www.google.com/"); | |
| 410 GURL url2("https://www.example.com/"); | |
| 411 content::WebContents* web_contents = | |
| 412 browser()->tab_strip_model()->GetActiveWebContents(); | |
| 413 | |
| 414 base::MockTimer* input_tracker_timer = new base::MockTimer(true, false); | |
| 415 scoped_ptr<SiteEngagementHelper> helper(CreateHelper(web_contents)); | |
| 416 SetInputTrackerPauseTimer(helper.get(), make_scoped_ptr(input_tracker_timer)); | |
| 417 | |
| 418 // Navigation starts the initial delay timer. | |
| 419 ui_test_utils::NavigateToURL(browser(), url1); | |
| 420 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 421 EXPECT_FALSE(IsTracking(helper.get())); | |
| 422 | |
| 423 content::RenderViewHost* rvh1 = web_contents->GetRenderViewHost(); | |
| 424 | |
| 425 ui_test_utils::NavigateToURLWithDisposition( | |
| 426 browser(), url2, NEW_BACKGROUND_TAB, | |
| 427 ui_test_utils::BROWSER_TEST_WAIT_FOR_NAVIGATION); | |
| 428 content::RenderViewHost* rvh2 = | |
| 429 browser()->tab_strip_model()->GetWebContentsAt(1)->GetRenderViewHost(); | |
| 430 | |
| 431 // The timer should still be running after the RenderViewHost is changed. | |
| 432 helper->RenderViewHostChanged(rvh1, rvh2); | |
| 433 EXPECT_TRUE(input_tracker_timer->IsRunning()); | |
| 434 EXPECT_FALSE(IsTracking(helper.get())); | |
| 435 EXPECT_EQ(rvh2, InputTrackerHost(helper.get())); | |
| 436 | |
| 437 // Firing the timer should add the callbacks. | |
| 438 input_tracker_timer->Fire(); | |
| 439 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 440 EXPECT_TRUE(IsTracking(helper.get())); | |
| 441 | |
| 442 // The callbacks should be on readded another RVH change since the timer has | |
| 443 // already fired. | |
| 444 helper->RenderViewHostChanged(rvh2, rvh1); | |
| 445 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 446 EXPECT_TRUE(IsTracking(helper.get())); | |
| 447 EXPECT_EQ(rvh1, InputTrackerHost(helper.get())); | |
| 448 | |
| 449 // Ensure nothing bad happens with a destroyed RVH. | |
| 450 helper->RenderViewHostChanged(nullptr, rvh2); | |
| 451 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 452 EXPECT_TRUE(IsTracking(helper.get())); | |
| 453 EXPECT_EQ(rvh2, InputTrackerHost(helper.get())); | |
| 454 | |
| 455 // Ensure nothing happens when RVH change happens for a hidden tab. | |
| 456 helper->WasHidden(); | |
| 457 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 458 EXPECT_FALSE(IsTracking(helper.get())); | |
| 459 | |
| 460 helper->RenderViewHostChanged(rvh2, rvh1); | |
| 461 EXPECT_FALSE(input_tracker_timer->IsRunning()); | |
| 462 EXPECT_FALSE(IsTracking(helper.get())); | |
| 463 EXPECT_EQ(nullptr, InputTrackerHost(helper.get())); | |
| 464 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 1388293002:
Notify WebContentsObservers of user interactions. (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master