1 // Copyright 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 "components/google/core/browser/google_url_tracker.h" 6 7 #include <set> 8 #include <string> 9 10 #include "base/memory/scoped_ptr.h" 11 #include "base/message_loop/message_loop.h" 12 #include "base/prefs/pref_service.h" 13 #include "chrome/browser/google/google_url_tracker_factory.h" 14 #include "chrome/test/base/testing_profile.h" 15 #include "components/google/core/browser/google_pref_names.h" 16 #include "components/google/core/browser/google_url_tracker_client.h" 17 #include "components/google/core/browser/google_url_tracker_infobar_delegate.h" 18 #include "components/google/core/browser/google_url_tracker_navigation_helper.h" 19 #include "components/infobars/core/infobar.h" 20 #include "components/infobars/core/infobar_delegate.h" 21 #include "content/public/test/test_browser_thread_bundle.h" 22 #include "net/url_request/test_url_fetcher_factory.h" 23 #include "net/url_request/url_fetcher.h" 24 #include "testing/gtest/include/gtest/gtest.h" 25 26 namespace { 27 28 // TestCallbackListener --------------------------------------------------- 29 30 class TestCallbackListener { 31 public: 32 TestCallbackListener(); 33 virtual ~TestCallbackListener(); 34 35 bool HasRegisteredCallback(); 36 void RegisterCallback(GoogleURLTracker* google_url_tracker); 37 38 bool notified() const { return notified_; } 39 void clear_notified() { notified_ = false; } 40 41 private: 42 void OnGoogleURLUpdated(GURL old_url, GURL new_url); 43 44 bool notified_; 45 scoped_ptr<GoogleURLTracker::Subscription> google_url_updated_subscription_; 46 }; 47 48 TestCallbackListener::TestCallbackListener() : notified_(false) { 49 } 50 51 TestCallbackListener::~TestCallbackListener() { 52 } 53 54 void TestCallbackListener::OnGoogleURLUpdated(GURL old_url, GURL new_url) { 55 notified_ = true; 56 } 57 58 bool TestCallbackListener::HasRegisteredCallback() { 59 return google_url_updated_subscription_.get(); 60 } 61 62 void TestCallbackListener::RegisterCallback( 63 GoogleURLTracker* google_url_tracker) { 64 google_url_updated_subscription_ = 65 google_url_tracker->RegisterCallback(base::Bind( 66 &TestCallbackListener::OnGoogleURLUpdated, base::Unretained(this))); 67 } 68 69 70 // TestGoogleURLTrackerClient ------------------------------------------------- 71 72 class TestGoogleURLTrackerClient : public GoogleURLTrackerClient { 73 public: 74 TestGoogleURLTrackerClient(Profile* profile_); 75 virtual ~TestGoogleURLTrackerClient(); 76 77 virtual void SetListeningForNavigationStart(bool listen) OVERRIDE; 78 virtual bool IsListeningForNavigationStart() OVERRIDE; 79 virtual bool IsBackgroundNetworkingEnabled() OVERRIDE; 80 virtual PrefService* GetPrefs() OVERRIDE; 81 virtual net::URLRequestContextGetter* GetRequestContext() OVERRIDE; 82 83 private: 84 Profile* profile_; 85 bool observe_nav_start_; 86 87 DISALLOW_COPY_AND_ASSIGN(TestGoogleURLTrackerClient); 88 }; 89 90 TestGoogleURLTrackerClient::TestGoogleURLTrackerClient(Profile* profile) 91 : profile_(profile), 92 observe_nav_start_(false) { 93 } 94 95 TestGoogleURLTrackerClient::~TestGoogleURLTrackerClient() { 96 } 97 98 void TestGoogleURLTrackerClient::SetListeningForNavigationStart(bool listen) { 99 observe_nav_start_ = listen; 100 } 101 102 bool TestGoogleURLTrackerClient::IsListeningForNavigationStart() { 103 return observe_nav_start_; 104 } 105 106 bool TestGoogleURLTrackerClient::IsBackgroundNetworkingEnabled() { 107 return true; 108 } 109 110 PrefService* TestGoogleURLTrackerClient::GetPrefs() { 111 return profile_->GetPrefs(); 112 } 113 114 net::URLRequestContextGetter* TestGoogleURLTrackerClient::GetRequestContext() { 115 return profile_->GetRequestContext(); 116 } 117 118 119 // TestGoogleURLTrackerNavigationHelper --------------------------------------- 120 121 class TestGoogleURLTrackerNavigationHelper 122 : public GoogleURLTrackerNavigationHelper { 123 public: 124 explicit TestGoogleURLTrackerNavigationHelper(GoogleURLTracker* tracker); 125 virtual ~TestGoogleURLTrackerNavigationHelper(); 126 127 virtual void SetListeningForNavigationCommit(bool listen) OVERRIDE; 128 virtual bool IsListeningForNavigationCommit() OVERRIDE; 129 virtual void SetListeningForTabDestruction(bool listen) OVERRIDE; 130 virtual bool IsListeningForTabDestruction() OVERRIDE; 131 virtual void OpenURL(GURL url, 132 WindowOpenDisposition disposition, 133 bool user_clicked_on_link) OVERRIDE; 134 135 private: 136 bool listening_for_nav_commit_; 137 bool listening_for_tab_destruction_; 138 139 DISALLOW_COPY_AND_ASSIGN(TestGoogleURLTrackerNavigationHelper); 140 }; 141 142 TestGoogleURLTrackerNavigationHelper::TestGoogleURLTrackerNavigationHelper( 143 GoogleURLTracker* tracker) 144 : GoogleURLTrackerNavigationHelper(tracker), 145 listening_for_nav_commit_(false), 146 listening_for_tab_destruction_(false) { 147 } 148 149 TestGoogleURLTrackerNavigationHelper::~TestGoogleURLTrackerNavigationHelper() { 150 } 151 152 void TestGoogleURLTrackerNavigationHelper::SetListeningForNavigationCommit( 153 bool listen) { 154 listening_for_nav_commit_ = listen; 155 } 156 157 bool TestGoogleURLTrackerNavigationHelper::IsListeningForNavigationCommit() { 158 return listening_for_nav_commit_; 159 } 160 161 void TestGoogleURLTrackerNavigationHelper::SetListeningForTabDestruction( 162 bool listen) { 163 listening_for_tab_destruction_ = listen; 164 } 165 166 bool TestGoogleURLTrackerNavigationHelper::IsListeningForTabDestruction() { 167 return listening_for_tab_destruction_; 168 } 169 170 void TestGoogleURLTrackerNavigationHelper::OpenURL( 171 GURL url, 172 WindowOpenDisposition disposition, 173 bool user_clicked_on_link) { 174 } 175 176 // TestInfoBarManager --------------------------------------------------------- 177 178 class TestInfoBarManager : public infobars::InfoBarManager { 179 public: 180 explicit TestInfoBarManager(int unique_id); 181 virtual ~TestInfoBarManager(); 182 virtual int GetActiveEntryID() OVERRIDE; 183 184 private: 185 int unique_id_; 186 DISALLOW_COPY_AND_ASSIGN(TestInfoBarManager); 187 }; 188 189 TestInfoBarManager::TestInfoBarManager(int unique_id) : unique_id_(unique_id) { 190 } 191 192 TestInfoBarManager::~TestInfoBarManager() { 193 ShutDown(); 194 } 195 196 int TestInfoBarManager::GetActiveEntryID() { 197 return unique_id_; 198 } 199 200 } // namespace 201 202 // GoogleURLTrackerTest ------------------------------------------------------- 203 204 class GoogleURLTrackerTest : public testing::Test { 205 protected: 206 GoogleURLTrackerTest(); 207 virtual ~GoogleURLTrackerTest(); 208 209 // testing::Test 210 virtual void SetUp() OVERRIDE; 211 virtual void TearDown() OVERRIDE; 212 213 net::TestURLFetcher* GetFetcher(); 214 void MockSearchDomainCheckResponse(const std::string& domain); 215 void RequestServerCheck(); 216 void FinishSleep(); 217 void NotifyIPAddressChanged(); 218 GURL fetched_google_url() const { 219 return google_url_tracker_->fetched_google_url(); 220 } 221 void set_google_url(const GURL& url) { 222 google_url_tracker_->google_url_ = url; 223 } 224 GURL google_url() const { return google_url_tracker_->google_url(); } 225 void SetLastPromptedGoogleURL(const GURL& url); 226 GURL GetLastPromptedGoogleURL(); 227 void SetNavigationPending(infobars::InfoBarManager* infobar_manager, 228 bool is_search); 229 void CommitNonSearch(infobars::InfoBarManager* infobar_manager); 230 void CommitSearch(infobars::InfoBarManager* infobar_manager, 231 const GURL& search_url); 232 void CloseTab(infobars::InfoBarManager* infobar_manager); 233 GoogleURLTrackerMapEntry* GetMapEntry( 234 infobars::InfoBarManager* infobar_manager); 235 GoogleURLTrackerInfoBarDelegate* GetInfoBarDelegate( 236 infobars::InfoBarManager* infobar_manager); 237 GoogleURLTrackerNavigationHelper* GetNavigationHelper( 238 infobars::InfoBarManager* infobar_manager); 239 void ExpectDefaultURLs() const; 240 void ExpectListeningForCommit(infobars::InfoBarManager* infobar_manager, 241 bool listening); 242 bool listener_notified() const { return listener_.notified(); } 243 void clear_listener_notified() { listener_.clear_notified(); } 244 245 private: 246 // These are required by the TestURLFetchers GoogleURLTracker will create (see 247 // test_url_fetcher_factory.h). 248 content::TestBrowserThreadBundle thread_bundle_; 249 250 // Creating this allows us to call 251 // net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(). 252 scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_; 253 net::TestURLFetcherFactory fetcher_factory_; 254 GoogleURLTrackerClient* client_; 255 TestingProfile profile_; 256 scoped_ptr<GoogleURLTracker> google_url_tracker_; 257 TestCallbackListener listener_; 258 // This tracks the different "tabs" a test has "opened", so we can close them 259 // properly before shutting down |google_url_tracker_|, which expects that. 260 std::set<infobars::InfoBarManager*> infobar_managers_seen_; 261 }; 262 263 GoogleURLTrackerTest::GoogleURLTrackerTest() 264 : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) { 265 GoogleURLTrackerFactory::GetInstance()-> 266 RegisterUserPrefsOnBrowserContextForTest(&profile_); 267 } 268 269 GoogleURLTrackerTest::~GoogleURLTrackerTest() { 270 } 271 272 void GoogleURLTrackerTest::SetUp() { 273 network_change_notifier_.reset(net::NetworkChangeNotifier::CreateMock()); 274 // Ownership is passed to google_url_tracker_, but a weak pointer is kept; 275 // this is safe since GoogleURLTracker keeps the client for its lifetime. 276 client_ = new TestGoogleURLTrackerClient(&profile_); 277 scoped_ptr<GoogleURLTrackerClient> client(client_); 278 google_url_tracker_.reset(new GoogleURLTracker( 279 client.Pass(), GoogleURLTracker::UNIT_TEST_MODE)); 280 } 281 282 void GoogleURLTrackerTest::TearDown() { 283 while (!infobar_managers_seen_.empty()) 284 CloseTab(*infobar_managers_seen_.begin()); 285 google_url_tracker_->Shutdown(); 286 } 287 288 net::TestURLFetcher* GoogleURLTrackerTest::GetFetcher() { 289 // This will return the last fetcher created. If no fetchers have been 290 // created, we'll pass GetFetcherByID() "-1", and it will return NULL. 291 return fetcher_factory_.GetFetcherByID(google_url_tracker_->fetcher_id_ - 1); 292 } 293 294 void GoogleURLTrackerTest::MockSearchDomainCheckResponse( 295 const std::string& domain) { 296 net::TestURLFetcher* fetcher = GetFetcher(); 297 if (!fetcher) 298 return; 299 fetcher_factory_.RemoveFetcherFromMap(fetcher->id()); 300 fetcher->set_url(GURL(GoogleURLTracker::kSearchDomainCheckURL)); 301 fetcher->set_response_code(200); 302 fetcher->SetResponseString(domain); 303 fetcher->delegate()->OnURLFetchComplete(fetcher); 304 // At this point, |fetcher| is deleted. 305 } 306 307 void GoogleURLTrackerTest::RequestServerCheck() { 308 if (!listener_.HasRegisteredCallback()) 309 listener_.RegisterCallback(google_url_tracker_.get()); 310 google_url_tracker_->SetNeedToFetch(); 311 } 312 313 void GoogleURLTrackerTest::FinishSleep() { 314 google_url_tracker_->FinishSleep(); 315 } 316 317 void GoogleURLTrackerTest::NotifyIPAddressChanged() { 318 net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); 319 // For thread safety, the NCN queues tasks to do the actual notifications, so 320 // we need to spin the message loop so the tracker will actually be notified. 321 base::MessageLoop::current()->RunUntilIdle(); 322 } 323 324 void GoogleURLTrackerTest::SetLastPromptedGoogleURL(const GURL& url) { 325 profile_.GetPrefs()->SetString(prefs::kLastPromptedGoogleURL, url.spec()); 326 } 327 328 GURL GoogleURLTrackerTest::GetLastPromptedGoogleURL() { 329 return GURL(profile_.GetPrefs()->GetString(prefs::kLastPromptedGoogleURL)); 330 } 331 332 void GoogleURLTrackerTest::SetNavigationPending( 333 infobars::InfoBarManager* infobar_manager, 334 bool is_search) { 335 if (is_search) { 336 google_url_tracker_->SearchCommitted(); 337 // Note that the call above might not have actually registered a listener 338 // for navigation starts if the searchdomaincheck response was bogus. 339 } 340 infobar_managers_seen_.insert(infobar_manager); 341 if (client_->IsListeningForNavigationStart()) { 342 google_url_tracker_->OnNavigationPending( 343 scoped_ptr<GoogleURLTrackerNavigationHelper>( 344 new TestGoogleURLTrackerNavigationHelper( 345 google_url_tracker_.get())), 346 infobar_manager, 347 infobar_manager->GetActiveEntryID()); 348 } 349 } 350 351 void GoogleURLTrackerTest::CommitNonSearch( 352 infobars::InfoBarManager* infobar_manager) { 353 GoogleURLTrackerMapEntry* map_entry = GetMapEntry(infobar_manager); 354 if (!map_entry) 355 return; 356 357 ExpectListeningForCommit(infobar_manager, false); 358 359 // The infobar should be showing; otherwise the pending non-search should 360 // have closed it. 361 ASSERT_TRUE(map_entry->has_infobar_delegate()); 362 363 // The pending_id should have been reset to 0 when the non-search became 364 // pending. 365 EXPECT_EQ(0, map_entry->infobar_delegate()->pending_id()); 366 367 // Committing the navigation would close the infobar. 368 map_entry->infobar_delegate()->Close(false); 369 } 370 371 void GoogleURLTrackerTest::CommitSearch( 372 infobars::InfoBarManager* infobar_manager, 373 const GURL& search_url) { 374 DCHECK(search_url.is_valid()); 375 GoogleURLTrackerNavigationHelper* nav_helper = 376 GetNavigationHelper(infobar_manager); 377 if (nav_helper && nav_helper->IsListeningForNavigationCommit()) { 378 google_url_tracker_->OnNavigationCommitted(infobar_manager, search_url); 379 } 380 } 381 382 void GoogleURLTrackerTest::CloseTab(infobars::InfoBarManager* infobar_manager) { 383 infobar_managers_seen_.erase(infobar_manager); 384 GoogleURLTrackerNavigationHelper* nav_helper = 385 GetNavigationHelper(infobar_manager); 386 if (nav_helper && nav_helper->IsListeningForTabDestruction()) { 387 google_url_tracker_->OnTabClosed(nav_helper); 388 } else { 389 // Closing a tab with an infobar showing would close the infobar. 390 GoogleURLTrackerInfoBarDelegate* delegate = 391 GetInfoBarDelegate(infobar_manager); 392 if (delegate) 393 delegate->Close(false); 394 } 395 } 396 397 GoogleURLTrackerMapEntry* GoogleURLTrackerTest::GetMapEntry( 398 infobars::InfoBarManager* infobar_manager) { 399 GoogleURLTracker::EntryMap::const_iterator i = 400 google_url_tracker_->entry_map_.find(infobar_manager); 401 return (i == google_url_tracker_->entry_map_.end()) ? NULL : i->second; 402 } 403 404 GoogleURLTrackerInfoBarDelegate* GoogleURLTrackerTest::GetInfoBarDelegate( 405 infobars::InfoBarManager* infobar_manager) { 406 GoogleURLTrackerMapEntry* map_entry = GetMapEntry(infobar_manager); 407 return map_entry ? map_entry->infobar_delegate() : NULL; 408 } 409 410 GoogleURLTrackerNavigationHelper* GoogleURLTrackerTest::GetNavigationHelper( 411 infobars::InfoBarManager* infobar_manager) { 412 GoogleURLTrackerMapEntry* map_entry = GetMapEntry(infobar_manager); 413 return map_entry ? map_entry->navigation_helper() : NULL; 414 } 415 416 void GoogleURLTrackerTest::ExpectDefaultURLs() const { 417 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 418 EXPECT_EQ(GURL(), fetched_google_url()); 419 } 420 421 void GoogleURLTrackerTest::ExpectListeningForCommit( 422 infobars::InfoBarManager* infobar_manager, 423 bool listening) { 424 GoogleURLTrackerMapEntry* map_entry = GetMapEntry(infobar_manager); 425 if (map_entry) { 426 EXPECT_EQ(listening, 427 map_entry->navigation_helper()->IsListeningForNavigationCommit()); 428 } else { 429 EXPECT_FALSE(listening); 430 } 431 } 432 433 // Tests ---------------------------------------------------------------------- 434 435 TEST_F(GoogleURLTrackerTest, DontFetchWhenNoOneRequestsCheck) { 436 ExpectDefaultURLs(); 437 FinishSleep(); 438 // No one called RequestServerCheck() so nothing should have happened. 439 EXPECT_FALSE(GetFetcher()); 440 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 441 ExpectDefaultURLs(); 442 EXPECT_FALSE(listener_notified()); 443 } 444 445 TEST_F(GoogleURLTrackerTest, UpdateOnFirstRun) { 446 RequestServerCheck(); 447 EXPECT_FALSE(GetFetcher()); 448 ExpectDefaultURLs(); 449 EXPECT_FALSE(listener_notified()); 450 451 FinishSleep(); 452 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 453 EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); 454 // GoogleURL should be updated, becase there was no last prompted URL. 455 EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); 456 EXPECT_TRUE(listener_notified()); 457 } 458 459 TEST_F(GoogleURLTrackerTest, DontUpdateWhenUnchanged) { 460 SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); 461 462 RequestServerCheck(); 463 EXPECT_FALSE(GetFetcher()); 464 ExpectDefaultURLs(); 465 EXPECT_FALSE(listener_notified()); 466 467 FinishSleep(); 468 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 469 EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); 470 // GoogleURL should not be updated, because the fetched and prompted URLs 471 // match. 472 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 473 EXPECT_FALSE(listener_notified()); 474 } 475 476 TEST_F(GoogleURLTrackerTest, DontPromptOnBadReplies) { 477 TestInfoBarManager infobar_manager(1); 478 SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); 479 480 RequestServerCheck(); 481 EXPECT_FALSE(GetFetcher()); 482 ExpectDefaultURLs(); 483 EXPECT_FALSE(listener_notified()); 484 485 // Old-style domain string. 486 FinishSleep(); 487 MockSearchDomainCheckResponse(".google.co.in"); 488 EXPECT_EQ(GURL(), fetched_google_url()); 489 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 490 EXPECT_FALSE(listener_notified()); 491 SetNavigationPending(&infobar_manager, true); 492 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 493 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 494 495 // Bad subdomain. 496 NotifyIPAddressChanged(); 497 MockSearchDomainCheckResponse("http://mail.google.com/"); 498 EXPECT_EQ(GURL(), fetched_google_url()); 499 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 500 EXPECT_FALSE(listener_notified()); 501 SetNavigationPending(&infobar_manager, true); 502 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 503 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 504 505 // Non-empty path. 506 NotifyIPAddressChanged(); 507 MockSearchDomainCheckResponse("http://www.google.com/search"); 508 EXPECT_EQ(GURL(), fetched_google_url()); 509 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 510 EXPECT_FALSE(listener_notified()); 511 SetNavigationPending(&infobar_manager, true); 512 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 513 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 514 515 // Non-empty query. 516 NotifyIPAddressChanged(); 517 MockSearchDomainCheckResponse("http://www.google.com/?q=foo"); 518 EXPECT_EQ(GURL(), fetched_google_url()); 519 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 520 EXPECT_FALSE(listener_notified()); 521 SetNavigationPending(&infobar_manager, true); 522 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 523 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 524 525 // Non-empty ref. 526 NotifyIPAddressChanged(); 527 MockSearchDomainCheckResponse("http://www.google.com/#anchor"); 528 EXPECT_EQ(GURL(), fetched_google_url()); 529 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 530 EXPECT_FALSE(listener_notified()); 531 SetNavigationPending(&infobar_manager, true); 532 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 533 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 534 535 // Complete garbage. 536 NotifyIPAddressChanged(); 537 MockSearchDomainCheckResponse("HJ)*qF)_*&@f1"); 538 EXPECT_EQ(GURL(), fetched_google_url()); 539 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 540 EXPECT_FALSE(listener_notified()); 541 SetNavigationPending(&infobar_manager, true); 542 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 543 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 544 } 545 546 TEST_F(GoogleURLTrackerTest, UpdatePromptedURLOnReturnToPreviousLocation) { 547 SetLastPromptedGoogleURL(GURL("http://www.google.co.jp/")); 548 set_google_url(GURL("http://www.google.co.uk/")); 549 RequestServerCheck(); 550 FinishSleep(); 551 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 552 EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); 553 EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); 554 EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); 555 EXPECT_FALSE(listener_notified()); 556 } 557 558 TEST_F(GoogleURLTrackerTest, SilentlyAcceptSchemeChange) { 559 // We should auto-accept changes to the current Google URL that merely change 560 // the scheme, regardless of what the last prompted URL was. 561 SetLastPromptedGoogleURL(GURL("http://www.google.co.jp/")); 562 set_google_url(GURL("http://www.google.co.uk/")); 563 RequestServerCheck(); 564 FinishSleep(); 565 MockSearchDomainCheckResponse("https://www.google.co.uk/"); 566 EXPECT_EQ(GURL("https://www.google.co.uk/"), fetched_google_url()); 567 EXPECT_EQ(GURL("https://www.google.co.uk/"), google_url()); 568 EXPECT_EQ(GURL("https://www.google.co.uk/"), GetLastPromptedGoogleURL()); 569 EXPECT_TRUE(listener_notified()); 570 571 NotifyIPAddressChanged(); 572 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 573 EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); 574 EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); 575 EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); 576 EXPECT_TRUE(listener_notified()); 577 } 578 579 TEST_F(GoogleURLTrackerTest, RefetchOnIPAddressChange) { 580 RequestServerCheck(); 581 FinishSleep(); 582 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 583 EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); 584 EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); 585 EXPECT_TRUE(listener_notified()); 586 clear_listener_notified(); 587 588 NotifyIPAddressChanged(); 589 MockSearchDomainCheckResponse("http://www.google.co.in/"); 590 EXPECT_EQ(GURL("http://www.google.co.in/"), fetched_google_url()); 591 // Just fetching a new URL shouldn't reset things without a prompt. 592 EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); 593 EXPECT_FALSE(listener_notified()); 594 } 595 596 TEST_F(GoogleURLTrackerTest, DontRefetchWhenNoOneRequestsCheck) { 597 FinishSleep(); 598 NotifyIPAddressChanged(); 599 // No one called RequestServerCheck() so nothing should have happened. 600 EXPECT_FALSE(GetFetcher()); 601 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 602 ExpectDefaultURLs(); 603 EXPECT_FALSE(listener_notified()); 604 } 605 606 TEST_F(GoogleURLTrackerTest, FetchOnLateRequest) { 607 FinishSleep(); 608 NotifyIPAddressChanged(); 609 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 610 611 RequestServerCheck(); 612 // The first request for a check should trigger a fetch if it hasn't happened 613 // already. 614 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 615 EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); 616 EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); 617 EXPECT_TRUE(listener_notified()); 618 } 619 620 TEST_F(GoogleURLTrackerTest, DontFetchTwiceOnLateRequests) { 621 FinishSleep(); 622 NotifyIPAddressChanged(); 623 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 624 625 RequestServerCheck(); 626 // The first request for a check should trigger a fetch if it hasn't happened 627 // already. 628 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 629 EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); 630 EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); 631 EXPECT_TRUE(listener_notified()); 632 clear_listener_notified(); 633 634 RequestServerCheck(); 635 // The second request should be ignored. 636 EXPECT_FALSE(GetFetcher()); 637 MockSearchDomainCheckResponse("http://www.google.co.in/"); 638 EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); 639 EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); 640 EXPECT_FALSE(listener_notified()); 641 } 642 643 TEST_F(GoogleURLTrackerTest, SearchingDoesNothingIfNoNeedToPrompt) { 644 TestInfoBarManager infobar_manager(1); 645 RequestServerCheck(); 646 FinishSleep(); 647 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 648 EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); 649 EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); 650 EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); 651 EXPECT_TRUE(listener_notified()); 652 clear_listener_notified(); 653 654 SetNavigationPending(&infobar_manager, true); 655 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 656 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 657 EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); 658 EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); 659 EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); 660 EXPECT_FALSE(listener_notified()); 661 } 662 663 TEST_F(GoogleURLTrackerTest, TabClosedOnPendingSearch) { 664 TestInfoBarManager infobar_manager(1); 665 SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); 666 RequestServerCheck(); 667 FinishSleep(); 668 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 669 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 670 EXPECT_EQ(GURL("http://www.google.co.jp/"), fetched_google_url()); 671 EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); 672 EXPECT_FALSE(listener_notified()); 673 674 SetNavigationPending(&infobar_manager, true); 675 GoogleURLTrackerMapEntry* map_entry = GetMapEntry(&infobar_manager); 676 ASSERT_FALSE(map_entry == NULL); 677 EXPECT_FALSE(map_entry->has_infobar_delegate()); 678 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 679 EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); 680 EXPECT_FALSE(listener_notified()); 681 682 CloseTab(&infobar_manager); 683 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 684 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 685 EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); 686 EXPECT_FALSE(listener_notified()); 687 } 688 689 TEST_F(GoogleURLTrackerTest, TabClosedOnCommittedSearch) { 690 TestInfoBarManager infobar_manager(1); 691 SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); 692 RequestServerCheck(); 693 FinishSleep(); 694 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 695 696 SetNavigationPending(&infobar_manager, true); 697 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 698 EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); 699 700 CloseTab(&infobar_manager); 701 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 702 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 703 EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); 704 EXPECT_FALSE(listener_notified()); 705 } 706 707 TEST_F(GoogleURLTrackerTest, InfoBarClosed) { 708 TestInfoBarManager infobar_manager(1); 709 SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); 710 RequestServerCheck(); 711 FinishSleep(); 712 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 713 714 SetNavigationPending(&infobar_manager, true); 715 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 716 GoogleURLTrackerInfoBarDelegate* infobar = 717 GetInfoBarDelegate(&infobar_manager); 718 ASSERT_FALSE(infobar == NULL); 719 720 infobar->Close(false); 721 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 722 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 723 EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); 724 EXPECT_FALSE(listener_notified()); 725 } 726 727 TEST_F(GoogleURLTrackerTest, InfoBarRefused) { 728 TestInfoBarManager infobar_manager(1); 729 SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); 730 RequestServerCheck(); 731 FinishSleep(); 732 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 733 734 SetNavigationPending(&infobar_manager, true); 735 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 736 GoogleURLTrackerInfoBarDelegate* infobar = 737 GetInfoBarDelegate(&infobar_manager); 738 ASSERT_FALSE(infobar == NULL); 739 740 infobar->Cancel(); 741 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 742 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 743 EXPECT_EQ(GURL("http://www.google.co.jp/"), GetLastPromptedGoogleURL()); 744 EXPECT_FALSE(listener_notified()); 745 } 746 747 TEST_F(GoogleURLTrackerTest, InfoBarAccepted) { 748 TestInfoBarManager infobar_manager(1); 749 SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); 750 RequestServerCheck(); 751 FinishSleep(); 752 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 753 754 SetNavigationPending(&infobar_manager, true); 755 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 756 GoogleURLTrackerInfoBarDelegate* infobar = 757 GetInfoBarDelegate(&infobar_manager); 758 ASSERT_FALSE(infobar == NULL); 759 760 infobar->Accept(); 761 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 762 EXPECT_EQ(GURL("http://www.google.co.jp/"), google_url()); 763 EXPECT_EQ(GURL("http://www.google.co.jp/"), GetLastPromptedGoogleURL()); 764 EXPECT_TRUE(listener_notified()); 765 } 766 767 TEST_F(GoogleURLTrackerTest, FetchesCanAutomaticallyCloseInfoBars) { 768 TestInfoBarManager infobar_manager(1); 769 RequestServerCheck(); 770 FinishSleep(); 771 MockSearchDomainCheckResponse(google_url().spec()); 772 773 // Re-fetching the accepted URL after showing an infobar for another URL 774 // should close the infobar. 775 NotifyIPAddressChanged(); 776 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 777 SetNavigationPending(&infobar_manager, true); 778 CommitSearch(&infobar_manager, GURL("http://www.google.com/search?q=test")); 779 EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); 780 NotifyIPAddressChanged(); 781 MockSearchDomainCheckResponse(google_url().spec()); 782 EXPECT_EQ(google_url(), GetLastPromptedGoogleURL()); 783 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 784 785 // As should fetching a URL that differs from the accepted only by the scheme. 786 NotifyIPAddressChanged(); 787 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 788 SetNavigationPending(&infobar_manager, true); 789 CommitSearch(&infobar_manager, GURL("http://www.google.com/search?q=test")); 790 EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); 791 NotifyIPAddressChanged(); 792 url::Replacements<char> replacements; 793 const std::string& scheme("https"); 794 replacements.SetScheme(scheme.data(), url::Component(0, scheme.length())); 795 GURL new_google_url(google_url().ReplaceComponents(replacements)); 796 MockSearchDomainCheckResponse(new_google_url.spec()); 797 EXPECT_EQ(new_google_url, GetLastPromptedGoogleURL()); 798 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 799 800 // As should re-fetching the last prompted URL. 801 SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); 802 NotifyIPAddressChanged(); 803 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 804 SetNavigationPending(&infobar_manager, true); 805 CommitSearch(&infobar_manager, GURL("http://www.google.com/search?q=test")); 806 EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); 807 NotifyIPAddressChanged(); 808 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 809 EXPECT_EQ(new_google_url, google_url()); 810 EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); 811 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 812 813 // And one that differs from the last prompted URL only by the scheme. 814 NotifyIPAddressChanged(); 815 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 816 SetNavigationPending(&infobar_manager, true); 817 CommitSearch(&infobar_manager, GURL("http://www.google.com/search?q=test")); 818 EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); 819 NotifyIPAddressChanged(); 820 MockSearchDomainCheckResponse("https://www.google.co.uk/"); 821 EXPECT_EQ(new_google_url, google_url()); 822 EXPECT_EQ(GURL("https://www.google.co.uk/"), GetLastPromptedGoogleURL()); 823 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 824 825 // And fetching a different URL entirely. 826 NotifyIPAddressChanged(); 827 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 828 SetNavigationPending(&infobar_manager, true); 829 CommitSearch(&infobar_manager, GURL("http://www.google.com/search?q=test")); 830 EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); 831 NotifyIPAddressChanged(); 832 MockSearchDomainCheckResponse("https://www.google.co.in/"); 833 EXPECT_EQ(new_google_url, google_url()); 834 EXPECT_EQ(GURL("https://www.google.co.uk/"), GetLastPromptedGoogleURL()); 835 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 836 } 837 838 TEST_F(GoogleURLTrackerTest, ResetInfoBarGoogleURLs) { 839 TestInfoBarManager infobar_manager(1); 840 RequestServerCheck(); 841 FinishSleep(); 842 MockSearchDomainCheckResponse(google_url().spec()); 843 844 NotifyIPAddressChanged(); 845 MockSearchDomainCheckResponse("http://www.google.co.uk/"); 846 SetNavigationPending(&infobar_manager, true); 847 CommitSearch(&infobar_manager, GURL("http://www.google.com/search?q=test")); 848 GoogleURLTrackerInfoBarDelegate* delegate = 849 GetInfoBarDelegate(&infobar_manager); 850 ASSERT_FALSE(delegate == NULL); 851 EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); 852 853 // If while an infobar is showing we fetch a new URL that differs from the 854 // infobar's only by scheme, the infobar should stay showing. 855 NotifyIPAddressChanged(); 856 MockSearchDomainCheckResponse("https://www.google.co.uk/"); 857 EXPECT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); 858 EXPECT_EQ(GURL("https://www.google.co.uk/"), fetched_google_url()); 859 } 860 861 TEST_F(GoogleURLTrackerTest, NavigationsAfterPendingSearch) { 862 TestInfoBarManager infobar_manager(1); 863 SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); 864 RequestServerCheck(); 865 FinishSleep(); 866 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 867 868 // A pending non-search after a pending search should delete the map entry. 869 SetNavigationPending(&infobar_manager, true); 870 GoogleURLTrackerMapEntry* map_entry = GetMapEntry(&infobar_manager); 871 ASSERT_FALSE(map_entry == NULL); 872 EXPECT_FALSE(map_entry->has_infobar_delegate()); 873 SetNavigationPending(&infobar_manager, false); 874 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 875 876 // A pending search after a pending search should leave the map entry alive. 877 SetNavigationPending(&infobar_manager, true); 878 map_entry = GetMapEntry(&infobar_manager); 879 ASSERT_FALSE(map_entry == NULL); 880 EXPECT_FALSE(map_entry->has_infobar_delegate()); 881 SetNavigationPending(&infobar_manager, true); 882 ASSERT_EQ(map_entry, GetMapEntry(&infobar_manager)); 883 EXPECT_FALSE(map_entry->has_infobar_delegate()); 884 ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, true)); 885 886 // Committing this search should show an infobar. 887 CommitSearch(&infobar_manager, 888 GURL("http://www.google.co.uk/search?q=test2")); 889 EXPECT_TRUE(map_entry->has_infobar_delegate()); 890 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 891 EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); 892 EXPECT_FALSE(listener_notified()); 893 ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); 894 } 895 896 TEST_F(GoogleURLTrackerTest, NavigationsAfterCommittedSearch) { 897 TestInfoBarManager infobar_manager(1); 898 SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); 899 RequestServerCheck(); 900 FinishSleep(); 901 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 902 SetNavigationPending(&infobar_manager, true); 903 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 904 GoogleURLTrackerInfoBarDelegate* delegate = 905 GetInfoBarDelegate(&infobar_manager); 906 ASSERT_FALSE(delegate == NULL); 907 ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); 908 909 // A pending non-search on a visible infobar should basically do nothing. 910 SetNavigationPending(&infobar_manager, false); 911 ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); 912 EXPECT_EQ(0, delegate->pending_id()); 913 ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); 914 915 // As should another pending non-search after the first. 916 SetNavigationPending(&infobar_manager, false); 917 ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); 918 EXPECT_EQ(0, delegate->pending_id()); 919 ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); 920 921 // Committing this non-search should close the infobar. The control flow in 922 // these tests is not really comparable to in the real browser, but at least a 923 // few sanity-checks will be performed. 924 ASSERT_NO_FATAL_FAILURE(CommitNonSearch(&infobar_manager)); 925 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 926 927 // A pending search on a visible infobar should cause the infobar to listen 928 // for the search to commit. 929 SetNavigationPending(&infobar_manager, true); 930 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 931 delegate = GetInfoBarDelegate(&infobar_manager); 932 ASSERT_FALSE(delegate == NULL); 933 SetNavigationPending(&infobar_manager, true); 934 ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); 935 EXPECT_EQ(1, delegate->pending_id()); 936 ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, true)); 937 938 // But a non-search after this should cancel that state. 939 SetNavigationPending(&infobar_manager, false); 940 ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); 941 EXPECT_EQ(0, delegate->pending_id()); 942 ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); 943 944 // Another pending search after the non-search should put us back into 945 // "waiting for commit" mode. 946 SetNavigationPending(&infobar_manager, true); 947 ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); 948 EXPECT_EQ(1, delegate->pending_id()); 949 ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, true)); 950 951 // A second pending search after the first should not really change anything. 952 SetNavigationPending(&infobar_manager, true); 953 ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); 954 EXPECT_EQ(1, delegate->pending_id()); 955 ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, true)); 956 957 // Committing this search should change the visible infobar's search_url. 958 CommitSearch(&infobar_manager, 959 GURL("http://www.google.co.uk/search?q=test2")); 960 ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); 961 EXPECT_EQ(GURL("http://www.google.co.uk/search?q=test2"), 962 delegate->search_url()); 963 EXPECT_EQ(0, delegate->pending_id()); 964 ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); 965 EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); 966 EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); 967 EXPECT_FALSE(listener_notified()); 968 } 969 970 TEST_F(GoogleURLTrackerTest, MultipleMapEntries) { 971 TestInfoBarManager infobar_manager(1); 972 TestInfoBarManager infobar_manager2(2); 973 TestInfoBarManager infobar_manager3(3); 974 TestInfoBarManager infobar_manager4(4); 975 SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); 976 RequestServerCheck(); 977 FinishSleep(); 978 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 979 980 SetNavigationPending(&infobar_manager, true); 981 GoogleURLTrackerMapEntry* map_entry = GetMapEntry(&infobar_manager); 982 ASSERT_FALSE(map_entry == NULL); 983 EXPECT_FALSE(map_entry->has_infobar_delegate()); 984 985 SetNavigationPending(&infobar_manager2, true); 986 CommitSearch(&infobar_manager2, 987 GURL("http://www.google.co.uk/search?q=test2")); 988 GoogleURLTrackerInfoBarDelegate* delegate2 = 989 GetInfoBarDelegate(&infobar_manager2); 990 ASSERT_FALSE(delegate2 == NULL); 991 EXPECT_EQ(GURL("http://www.google.co.uk/search?q=test2"), 992 delegate2->search_url()); 993 994 SetNavigationPending(&infobar_manager3, true); 995 GoogleURLTrackerMapEntry* map_entry3 = GetMapEntry(&infobar_manager3); 996 ASSERT_FALSE(map_entry3 == NULL); 997 EXPECT_FALSE(map_entry3->has_infobar_delegate()); 998 999 SetNavigationPending(&infobar_manager4, true); 1000 CommitSearch(&infobar_manager4, 1001 GURL("http://www.google.co.uk/search?q=test4")); 1002 GoogleURLTrackerInfoBarDelegate* delegate4 = 1003 GetInfoBarDelegate(&infobar_manager4); 1004 ASSERT_FALSE(delegate4 == NULL); 1005 EXPECT_EQ(GURL("http://www.google.co.uk/search?q=test4"), 1006 delegate4->search_url()); 1007 1008 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 1009 EXPECT_TRUE(map_entry->has_infobar_delegate()); 1010 1011 delegate2->Close(false); 1012 EXPECT_TRUE(GetMapEntry(&infobar_manager2) == NULL); 1013 EXPECT_FALSE(listener_notified()); 1014 1015 delegate4->Accept(); 1016 EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); 1017 EXPECT_TRUE(GetMapEntry(&infobar_manager3) == NULL); 1018 EXPECT_TRUE(GetMapEntry(&infobar_manager4) == NULL); 1019 EXPECT_EQ(GURL("http://www.google.co.jp/"), google_url()); 1020 EXPECT_EQ(GURL("http://www.google.co.jp/"), GetLastPromptedGoogleURL()); 1021 EXPECT_TRUE(listener_notified()); 1022 } 1023 1024 TEST_F(GoogleURLTrackerTest, IgnoreIrrelevantNavigation) { 1025 TestInfoBarManager infobar_manager(1); 1026 TestInfoBarManager infobar_manager2(2); 1027 SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); 1028 RequestServerCheck(); 1029 FinishSleep(); 1030 MockSearchDomainCheckResponse("http://www.google.co.jp/"); 1031 1032 // This tests a particularly gnarly sequence of events that used to cause us 1033 // to erroneously listen for a non-search navigation to commit. 1034 SetNavigationPending(&infobar_manager, true); 1035 CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); 1036 SetNavigationPending(&infobar_manager2, true); 1037 CommitSearch(&infobar_manager2, 1038 GURL("http://www.google.co.uk/search?q=test2")); 1039 EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); 1040 GoogleURLTrackerInfoBarDelegate* delegate2 = 1041 GetInfoBarDelegate(&infobar_manager2); 1042 ASSERT_FALSE(delegate2 == NULL); 1043 SetNavigationPending(&infobar_manager, true); 1044 ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, true)); 1045 delegate2->Close(false); 1046 SetNavigationPending(&infobar_manager, false); 1047 ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); 1048 } 1049