| // Copyright 2012 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "components/google/core/browser/google_url_tracker.h" |
| |
| #include <set> |
| #include <string> |
| |
| #include "base/memory/scoped_ptr.h" |
| #include "base/message_loop/message_loop.h" |
| #include "base/prefs/pref_service.h" |
| #include "chrome/browser/google/google_url_tracker_factory.h" |
| #include "chrome/test/base/testing_profile.h" |
| #include "components/google/core/browser/google_pref_names.h" |
| #include "components/google/core/browser/google_url_tracker_client.h" |
| #include "components/google/core/browser/google_url_tracker_infobar_delegate.h" |
| #include "components/google/core/browser/google_url_tracker_navigation_helper.h" |
| #include "components/infobars/core/infobar.h" |
| #include "components/infobars/core/infobar_delegate.h" |
| #include "content/public/test/test_browser_thread_bundle.h" |
| #include "net/url_request/test_url_fetcher_factory.h" |
| #include "net/url_request/url_fetcher.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| namespace { |
| |
| // TestCallbackListener --------------------------------------------------- |
| |
| class TestCallbackListener { |
| public: |
| TestCallbackListener(); |
| virtual ~TestCallbackListener(); |
| |
| bool HasRegisteredCallback(); |
| void RegisterCallback(GoogleURLTracker* google_url_tracker); |
| |
| bool notified() const { return notified_; } |
| void clear_notified() { notified_ = false; } |
| |
| private: |
| void OnGoogleURLUpdated(GURL old_url, GURL new_url); |
| |
| bool notified_; |
| scoped_ptr<GoogleURLTracker::Subscription> google_url_updated_subscription_; |
| }; |
| |
| TestCallbackListener::TestCallbackListener() : notified_(false) { |
| } |
| |
| TestCallbackListener::~TestCallbackListener() { |
| } |
| |
| void TestCallbackListener::OnGoogleURLUpdated(GURL old_url, GURL new_url) { |
| notified_ = true; |
| } |
| |
| bool TestCallbackListener::HasRegisteredCallback() { |
| return google_url_updated_subscription_.get(); |
| } |
| |
| void TestCallbackListener::RegisterCallback( |
| GoogleURLTracker* google_url_tracker) { |
| google_url_updated_subscription_ = |
| google_url_tracker->RegisterCallback(base::Bind( |
| &TestCallbackListener::OnGoogleURLUpdated, base::Unretained(this))); |
| } |
| |
| |
| // TestGoogleURLTrackerClient ------------------------------------------------- |
| |
| class TestGoogleURLTrackerClient : public GoogleURLTrackerClient { |
| public: |
| TestGoogleURLTrackerClient(Profile* profile_); |
| virtual ~TestGoogleURLTrackerClient(); |
| |
| virtual void SetListeningForNavigationStart(bool listen) OVERRIDE; |
| virtual bool IsListeningForNavigationStart() OVERRIDE; |
| virtual bool IsBackgroundNetworkingEnabled() OVERRIDE; |
| virtual PrefService* GetPrefs() OVERRIDE; |
| virtual net::URLRequestContextGetter* GetRequestContext() OVERRIDE; |
| |
| private: |
| Profile* profile_; |
| bool observe_nav_start_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TestGoogleURLTrackerClient); |
| }; |
| |
| TestGoogleURLTrackerClient::TestGoogleURLTrackerClient(Profile* profile) |
| : profile_(profile), |
| observe_nav_start_(false) { |
| } |
| |
| TestGoogleURLTrackerClient::~TestGoogleURLTrackerClient() { |
| } |
| |
| void TestGoogleURLTrackerClient::SetListeningForNavigationStart(bool listen) { |
| observe_nav_start_ = listen; |
| } |
| |
| bool TestGoogleURLTrackerClient::IsListeningForNavigationStart() { |
| return observe_nav_start_; |
| } |
| |
| bool TestGoogleURLTrackerClient::IsBackgroundNetworkingEnabled() { |
| return true; |
| } |
| |
| PrefService* TestGoogleURLTrackerClient::GetPrefs() { |
| return profile_->GetPrefs(); |
| } |
| |
| net::URLRequestContextGetter* TestGoogleURLTrackerClient::GetRequestContext() { |
| return profile_->GetRequestContext(); |
| } |
| |
| |
| // TestGoogleURLTrackerNavigationHelper --------------------------------------- |
| |
| class TestGoogleURLTrackerNavigationHelper |
| : public GoogleURLTrackerNavigationHelper { |
| public: |
| explicit TestGoogleURLTrackerNavigationHelper(GoogleURLTracker* tracker); |
| virtual ~TestGoogleURLTrackerNavigationHelper(); |
| |
| virtual void SetListeningForNavigationCommit(bool listen) OVERRIDE; |
| virtual bool IsListeningForNavigationCommit() OVERRIDE; |
| virtual void SetListeningForTabDestruction(bool listen) OVERRIDE; |
| virtual bool IsListeningForTabDestruction() OVERRIDE; |
| virtual void OpenURL(GURL url, |
| WindowOpenDisposition disposition, |
| bool user_clicked_on_link) OVERRIDE; |
| |
| private: |
| bool listening_for_nav_commit_; |
| bool listening_for_tab_destruction_; |
| |
| DISALLOW_COPY_AND_ASSIGN(TestGoogleURLTrackerNavigationHelper); |
| }; |
| |
| TestGoogleURLTrackerNavigationHelper::TestGoogleURLTrackerNavigationHelper( |
| GoogleURLTracker* tracker) |
| : GoogleURLTrackerNavigationHelper(tracker), |
| listening_for_nav_commit_(false), |
| listening_for_tab_destruction_(false) { |
| } |
| |
| TestGoogleURLTrackerNavigationHelper::~TestGoogleURLTrackerNavigationHelper() { |
| } |
| |
| void TestGoogleURLTrackerNavigationHelper::SetListeningForNavigationCommit( |
| bool listen) { |
| listening_for_nav_commit_ = listen; |
| } |
| |
| bool TestGoogleURLTrackerNavigationHelper::IsListeningForNavigationCommit() { |
| return listening_for_nav_commit_; |
| } |
| |
| void TestGoogleURLTrackerNavigationHelper::SetListeningForTabDestruction( |
| bool listen) { |
| listening_for_tab_destruction_ = listen; |
| } |
| |
| bool TestGoogleURLTrackerNavigationHelper::IsListeningForTabDestruction() { |
| return listening_for_tab_destruction_; |
| } |
| |
| void TestGoogleURLTrackerNavigationHelper::OpenURL( |
| GURL url, |
| WindowOpenDisposition disposition, |
| bool user_clicked_on_link) { |
| } |
| |
| // TestInfoBarManager --------------------------------------------------------- |
| |
| class TestInfoBarManager : public infobars::InfoBarManager { |
| public: |
| explicit TestInfoBarManager(int unique_id); |
| virtual ~TestInfoBarManager(); |
| virtual int GetActiveEntryID() OVERRIDE; |
| |
| private: |
| int unique_id_; |
| DISALLOW_COPY_AND_ASSIGN(TestInfoBarManager); |
| }; |
| |
| TestInfoBarManager::TestInfoBarManager(int unique_id) : unique_id_(unique_id) { |
| } |
| |
| TestInfoBarManager::~TestInfoBarManager() { |
| ShutDown(); |
| } |
| |
| int TestInfoBarManager::GetActiveEntryID() { |
| return unique_id_; |
| } |
| |
| } // namespace |
| |
| // GoogleURLTrackerTest ------------------------------------------------------- |
| |
| class GoogleURLTrackerTest : public testing::Test { |
| protected: |
| GoogleURLTrackerTest(); |
| virtual ~GoogleURLTrackerTest(); |
| |
| // testing::Test |
| virtual void SetUp() OVERRIDE; |
| virtual void TearDown() OVERRIDE; |
| |
| net::TestURLFetcher* GetFetcher(); |
| void MockSearchDomainCheckResponse(const std::string& domain); |
| void RequestServerCheck(); |
| void FinishSleep(); |
| void NotifyIPAddressChanged(); |
| GURL fetched_google_url() const { |
| return google_url_tracker_->fetched_google_url(); |
| } |
| void set_google_url(const GURL& url) { |
| google_url_tracker_->google_url_ = url; |
| } |
| GURL google_url() const { return google_url_tracker_->google_url(); } |
| void SetLastPromptedGoogleURL(const GURL& url); |
| GURL GetLastPromptedGoogleURL(); |
| void SetNavigationPending(infobars::InfoBarManager* infobar_manager, |
| bool is_search); |
| void CommitNonSearch(infobars::InfoBarManager* infobar_manager); |
| void CommitSearch(infobars::InfoBarManager* infobar_manager, |
| const GURL& search_url); |
| void CloseTab(infobars::InfoBarManager* infobar_manager); |
| GoogleURLTrackerMapEntry* GetMapEntry( |
| infobars::InfoBarManager* infobar_manager); |
| GoogleURLTrackerInfoBarDelegate* GetInfoBarDelegate( |
| infobars::InfoBarManager* infobar_manager); |
| GoogleURLTrackerNavigationHelper* GetNavigationHelper( |
| infobars::InfoBarManager* infobar_manager); |
| void ExpectDefaultURLs() const; |
| void ExpectListeningForCommit(infobars::InfoBarManager* infobar_manager, |
| bool listening); |
| bool listener_notified() const { return listener_.notified(); } |
| void clear_listener_notified() { listener_.clear_notified(); } |
| |
| private: |
| // These are required by the TestURLFetchers GoogleURLTracker will create (see |
| // test_url_fetcher_factory.h). |
| content::TestBrowserThreadBundle thread_bundle_; |
| |
| // Creating this allows us to call |
| // net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(). |
| scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_; |
| net::TestURLFetcherFactory fetcher_factory_; |
| GoogleURLTrackerClient* client_; |
| TestingProfile profile_; |
| scoped_ptr<GoogleURLTracker> google_url_tracker_; |
| TestCallbackListener listener_; |
| // This tracks the different "tabs" a test has "opened", so we can close them |
| // properly before shutting down |google_url_tracker_|, which expects that. |
| std::set<infobars::InfoBarManager*> infobar_managers_seen_; |
| }; |
| |
| GoogleURLTrackerTest::GoogleURLTrackerTest() |
| : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) { |
| GoogleURLTrackerFactory::GetInstance()-> |
| RegisterUserPrefsOnBrowserContextForTest(&profile_); |
| } |
| |
| GoogleURLTrackerTest::~GoogleURLTrackerTest() { |
| } |
| |
| void GoogleURLTrackerTest::SetUp() { |
| network_change_notifier_.reset(net::NetworkChangeNotifier::CreateMock()); |
| // Ownership is passed to google_url_tracker_, but a weak pointer is kept; |
| // this is safe since GoogleURLTracker keeps the client for its lifetime. |
| client_ = new TestGoogleURLTrackerClient(&profile_); |
| scoped_ptr<GoogleURLTrackerClient> client(client_); |
| google_url_tracker_.reset(new GoogleURLTracker( |
| client.Pass(), GoogleURLTracker::UNIT_TEST_MODE)); |
| } |
| |
| void GoogleURLTrackerTest::TearDown() { |
| while (!infobar_managers_seen_.empty()) |
| CloseTab(*infobar_managers_seen_.begin()); |
| google_url_tracker_->Shutdown(); |
| } |
| |
| net::TestURLFetcher* GoogleURLTrackerTest::GetFetcher() { |
| // This will return the last fetcher created. If no fetchers have been |
| // created, we'll pass GetFetcherByID() "-1", and it will return NULL. |
| return fetcher_factory_.GetFetcherByID(google_url_tracker_->fetcher_id_ - 1); |
| } |
| |
| void GoogleURLTrackerTest::MockSearchDomainCheckResponse( |
| const std::string& domain) { |
| net::TestURLFetcher* fetcher = GetFetcher(); |
| if (!fetcher) |
| return; |
| fetcher_factory_.RemoveFetcherFromMap(fetcher->id()); |
| fetcher->set_url(GURL(GoogleURLTracker::kSearchDomainCheckURL)); |
| fetcher->set_response_code(200); |
| fetcher->SetResponseString(domain); |
| fetcher->delegate()->OnURLFetchComplete(fetcher); |
| // At this point, |fetcher| is deleted. |
| } |
| |
| void GoogleURLTrackerTest::RequestServerCheck() { |
| if (!listener_.HasRegisteredCallback()) |
| listener_.RegisterCallback(google_url_tracker_.get()); |
| google_url_tracker_->SetNeedToFetch(); |
| } |
| |
| void GoogleURLTrackerTest::FinishSleep() { |
| google_url_tracker_->FinishSleep(); |
| } |
| |
| void GoogleURLTrackerTest::NotifyIPAddressChanged() { |
| net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests(); |
| // For thread safety, the NCN queues tasks to do the actual notifications, so |
| // we need to spin the message loop so the tracker will actually be notified. |
| base::MessageLoop::current()->RunUntilIdle(); |
| } |
| |
| void GoogleURLTrackerTest::SetLastPromptedGoogleURL(const GURL& url) { |
| profile_.GetPrefs()->SetString(prefs::kLastPromptedGoogleURL, url.spec()); |
| } |
| |
| GURL GoogleURLTrackerTest::GetLastPromptedGoogleURL() { |
| return GURL(profile_.GetPrefs()->GetString(prefs::kLastPromptedGoogleURL)); |
| } |
| |
| void GoogleURLTrackerTest::SetNavigationPending( |
| infobars::InfoBarManager* infobar_manager, |
| bool is_search) { |
| if (is_search) { |
| google_url_tracker_->SearchCommitted(); |
| // Note that the call above might not have actually registered a listener |
| // for navigation starts if the searchdomaincheck response was bogus. |
| } |
| infobar_managers_seen_.insert(infobar_manager); |
| if (client_->IsListeningForNavigationStart()) { |
| google_url_tracker_->OnNavigationPending( |
| scoped_ptr<GoogleURLTrackerNavigationHelper>( |
| new TestGoogleURLTrackerNavigationHelper( |
| google_url_tracker_.get())), |
| infobar_manager, |
| infobar_manager->GetActiveEntryID()); |
| } |
| } |
| |
| void GoogleURLTrackerTest::CommitNonSearch( |
| infobars::InfoBarManager* infobar_manager) { |
| GoogleURLTrackerMapEntry* map_entry = GetMapEntry(infobar_manager); |
| if (!map_entry) |
| return; |
| |
| ExpectListeningForCommit(infobar_manager, false); |
| |
| // The infobar should be showing; otherwise the pending non-search should |
| // have closed it. |
| ASSERT_TRUE(map_entry->has_infobar_delegate()); |
| |
| // The pending_id should have been reset to 0 when the non-search became |
| // pending. |
| EXPECT_EQ(0, map_entry->infobar_delegate()->pending_id()); |
| |
| // Committing the navigation would close the infobar. |
| map_entry->infobar_delegate()->Close(false); |
| } |
| |
| void GoogleURLTrackerTest::CommitSearch( |
| infobars::InfoBarManager* infobar_manager, |
| const GURL& search_url) { |
| DCHECK(search_url.is_valid()); |
| GoogleURLTrackerNavigationHelper* nav_helper = |
| GetNavigationHelper(infobar_manager); |
| if (nav_helper && nav_helper->IsListeningForNavigationCommit()) { |
| google_url_tracker_->OnNavigationCommitted(infobar_manager, search_url); |
| } |
| } |
| |
| void GoogleURLTrackerTest::CloseTab(infobars::InfoBarManager* infobar_manager) { |
| infobar_managers_seen_.erase(infobar_manager); |
| GoogleURLTrackerNavigationHelper* nav_helper = |
| GetNavigationHelper(infobar_manager); |
| if (nav_helper && nav_helper->IsListeningForTabDestruction()) { |
| google_url_tracker_->OnTabClosed(nav_helper); |
| } else { |
| // Closing a tab with an infobar showing would close the infobar. |
| GoogleURLTrackerInfoBarDelegate* delegate = |
| GetInfoBarDelegate(infobar_manager); |
| if (delegate) |
| delegate->Close(false); |
| } |
| } |
| |
| GoogleURLTrackerMapEntry* GoogleURLTrackerTest::GetMapEntry( |
| infobars::InfoBarManager* infobar_manager) { |
| GoogleURLTracker::EntryMap::const_iterator i = |
| google_url_tracker_->entry_map_.find(infobar_manager); |
| return (i == google_url_tracker_->entry_map_.end()) ? NULL : i->second; |
| } |
| |
| GoogleURLTrackerInfoBarDelegate* GoogleURLTrackerTest::GetInfoBarDelegate( |
| infobars::InfoBarManager* infobar_manager) { |
| GoogleURLTrackerMapEntry* map_entry = GetMapEntry(infobar_manager); |
| return map_entry ? map_entry->infobar_delegate() : NULL; |
| } |
| |
| GoogleURLTrackerNavigationHelper* GoogleURLTrackerTest::GetNavigationHelper( |
| infobars::InfoBarManager* infobar_manager) { |
| GoogleURLTrackerMapEntry* map_entry = GetMapEntry(infobar_manager); |
| return map_entry ? map_entry->navigation_helper() : NULL; |
| } |
| |
| void GoogleURLTrackerTest::ExpectDefaultURLs() const { |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_EQ(GURL(), fetched_google_url()); |
| } |
| |
| void GoogleURLTrackerTest::ExpectListeningForCommit( |
| infobars::InfoBarManager* infobar_manager, |
| bool listening) { |
| GoogleURLTrackerMapEntry* map_entry = GetMapEntry(infobar_manager); |
| if (map_entry) { |
| EXPECT_EQ(listening, |
| map_entry->navigation_helper()->IsListeningForNavigationCommit()); |
| } else { |
| EXPECT_FALSE(listening); |
| } |
| } |
| |
| // Tests ---------------------------------------------------------------------- |
| |
| TEST_F(GoogleURLTrackerTest, DontFetchWhenNoOneRequestsCheck) { |
| ExpectDefaultURLs(); |
| FinishSleep(); |
| // No one called RequestServerCheck() so nothing should have happened. |
| EXPECT_FALSE(GetFetcher()); |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| ExpectDefaultURLs(); |
| EXPECT_FALSE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, UpdateOnFirstRun) { |
| RequestServerCheck(); |
| EXPECT_FALSE(GetFetcher()); |
| ExpectDefaultURLs(); |
| EXPECT_FALSE(listener_notified()); |
| |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); |
| // GoogleURL should be updated, becase there was no last prompted URL. |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); |
| EXPECT_TRUE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, DontUpdateWhenUnchanged) { |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); |
| |
| RequestServerCheck(); |
| EXPECT_FALSE(GetFetcher()); |
| ExpectDefaultURLs(); |
| EXPECT_FALSE(listener_notified()); |
| |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); |
| // GoogleURL should not be updated, because the fetched and prompted URLs |
| // match. |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_FALSE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, DontPromptOnBadReplies) { |
| TestInfoBarManager infobar_manager(1); |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); |
| |
| RequestServerCheck(); |
| EXPECT_FALSE(GetFetcher()); |
| ExpectDefaultURLs(); |
| EXPECT_FALSE(listener_notified()); |
| |
| // Old-style domain string. |
| FinishSleep(); |
| MockSearchDomainCheckResponse(".google.co.in"); |
| EXPECT_EQ(GURL(), fetched_google_url()); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_FALSE(listener_notified()); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| |
| // Bad subdomain. |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://mail.google.com/"); |
| EXPECT_EQ(GURL(), fetched_google_url()); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_FALSE(listener_notified()); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| |
| // Non-empty path. |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.com/search"); |
| EXPECT_EQ(GURL(), fetched_google_url()); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_FALSE(listener_notified()); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| |
| // Non-empty query. |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.com/?q=foo"); |
| EXPECT_EQ(GURL(), fetched_google_url()); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_FALSE(listener_notified()); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| |
| // Non-empty ref. |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.com/#anchor"); |
| EXPECT_EQ(GURL(), fetched_google_url()); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_FALSE(listener_notified()); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| |
| // Complete garbage. |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("HJ)*qF)_*&@f1"); |
| EXPECT_EQ(GURL(), fetched_google_url()); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_FALSE(listener_notified()); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, UpdatePromptedURLOnReturnToPreviousLocation) { |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.jp/")); |
| set_google_url(GURL("http://www.google.co.uk/")); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_FALSE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, SilentlyAcceptSchemeChange) { |
| // We should auto-accept changes to the current Google URL that merely change |
| // the scheme, regardless of what the last prompted URL was. |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.jp/")); |
| set_google_url(GURL("http://www.google.co.uk/")); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("https://www.google.co.uk/"); |
| EXPECT_EQ(GURL("https://www.google.co.uk/"), fetched_google_url()); |
| EXPECT_EQ(GURL("https://www.google.co.uk/"), google_url()); |
| EXPECT_EQ(GURL("https://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_TRUE(listener_notified()); |
| |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_TRUE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, RefetchOnIPAddressChange) { |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); |
| EXPECT_TRUE(listener_notified()); |
| clear_listener_notified(); |
| |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.co.in/"); |
| EXPECT_EQ(GURL("http://www.google.co.in/"), fetched_google_url()); |
| // Just fetching a new URL shouldn't reset things without a prompt. |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); |
| EXPECT_FALSE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, DontRefetchWhenNoOneRequestsCheck) { |
| FinishSleep(); |
| NotifyIPAddressChanged(); |
| // No one called RequestServerCheck() so nothing should have happened. |
| EXPECT_FALSE(GetFetcher()); |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| ExpectDefaultURLs(); |
| EXPECT_FALSE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, FetchOnLateRequest) { |
| FinishSleep(); |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| |
| RequestServerCheck(); |
| // The first request for a check should trigger a fetch if it hasn't happened |
| // already. |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); |
| EXPECT_TRUE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, DontFetchTwiceOnLateRequests) { |
| FinishSleep(); |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| |
| RequestServerCheck(); |
| // The first request for a check should trigger a fetch if it hasn't happened |
| // already. |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); |
| EXPECT_TRUE(listener_notified()); |
| clear_listener_notified(); |
| |
| RequestServerCheck(); |
| // The second request should be ignored. |
| EXPECT_FALSE(GetFetcher()); |
| MockSearchDomainCheckResponse("http://www.google.co.in/"); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); |
| EXPECT_FALSE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, SearchingDoesNothingIfNoNeedToPrompt) { |
| TestInfoBarManager infobar_manager(1); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_TRUE(listener_notified()); |
| clear_listener_notified(); |
| |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_FALSE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, TabClosedOnPendingSearch) { |
| TestInfoBarManager infobar_manager(1); |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.jp/"), fetched_google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_FALSE(listener_notified()); |
| |
| SetNavigationPending(&infobar_manager, true); |
| GoogleURLTrackerMapEntry* map_entry = GetMapEntry(&infobar_manager); |
| ASSERT_FALSE(map_entry == NULL); |
| EXPECT_FALSE(map_entry->has_infobar_delegate()); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_FALSE(listener_notified()); |
| |
| CloseTab(&infobar_manager); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_FALSE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, TabClosedOnCommittedSearch) { |
| TestInfoBarManager infobar_manager(1); |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); |
| |
| CloseTab(&infobar_manager); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_FALSE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, InfoBarClosed) { |
| TestInfoBarManager infobar_manager(1); |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| GoogleURLTrackerInfoBarDelegate* infobar = |
| GetInfoBarDelegate(&infobar_manager); |
| ASSERT_FALSE(infobar == NULL); |
| |
| infobar->Close(false); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_FALSE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, InfoBarRefused) { |
| TestInfoBarManager infobar_manager(1); |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| GoogleURLTrackerInfoBarDelegate* infobar = |
| GetInfoBarDelegate(&infobar_manager); |
| ASSERT_FALSE(infobar == NULL); |
| |
| infobar->Cancel(); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.jp/"), GetLastPromptedGoogleURL()); |
| EXPECT_FALSE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, InfoBarAccepted) { |
| TestInfoBarManager infobar_manager(1); |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| GoogleURLTrackerInfoBarDelegate* infobar = |
| GetInfoBarDelegate(&infobar_manager); |
| ASSERT_FALSE(infobar == NULL); |
| |
| infobar->Accept(); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| EXPECT_EQ(GURL("http://www.google.co.jp/"), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.jp/"), GetLastPromptedGoogleURL()); |
| EXPECT_TRUE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, FetchesCanAutomaticallyCloseInfoBars) { |
| TestInfoBarManager infobar_manager(1); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse(google_url().spec()); |
| |
| // Re-fetching the accepted URL after showing an infobar for another URL |
| // should close the infobar. |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.com/search?q=test")); |
| EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse(google_url().spec()); |
| EXPECT_EQ(google_url(), GetLastPromptedGoogleURL()); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| |
| // As should fetching a URL that differs from the accepted only by the scheme. |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.com/search?q=test")); |
| EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); |
| NotifyIPAddressChanged(); |
| url::Replacements<char> replacements; |
| const std::string& scheme("https"); |
| replacements.SetScheme(scheme.data(), url::Component(0, scheme.length())); |
| GURL new_google_url(google_url().ReplaceComponents(replacements)); |
| MockSearchDomainCheckResponse(new_google_url.spec()); |
| EXPECT_EQ(new_google_url, GetLastPromptedGoogleURL()); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| |
| // As should re-fetching the last prompted URL. |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.com/search?q=test")); |
| EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| EXPECT_EQ(new_google_url, google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| |
| // And one that differs from the last prompted URL only by the scheme. |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.com/search?q=test")); |
| EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("https://www.google.co.uk/"); |
| EXPECT_EQ(new_google_url, google_url()); |
| EXPECT_EQ(GURL("https://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| |
| // And fetching a different URL entirely. |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.com/search?q=test")); |
| EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("https://www.google.co.in/"); |
| EXPECT_EQ(new_google_url, google_url()); |
| EXPECT_EQ(GURL("https://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, ResetInfoBarGoogleURLs) { |
| TestInfoBarManager infobar_manager(1); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse(google_url().spec()); |
| |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("http://www.google.co.uk/"); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.com/search?q=test")); |
| GoogleURLTrackerInfoBarDelegate* delegate = |
| GetInfoBarDelegate(&infobar_manager); |
| ASSERT_FALSE(delegate == NULL); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url()); |
| |
| // If while an infobar is showing we fetch a new URL that differs from the |
| // infobar's only by scheme, the infobar should stay showing. |
| NotifyIPAddressChanged(); |
| MockSearchDomainCheckResponse("https://www.google.co.uk/"); |
| EXPECT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); |
| EXPECT_EQ(GURL("https://www.google.co.uk/"), fetched_google_url()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, NavigationsAfterPendingSearch) { |
| TestInfoBarManager infobar_manager(1); |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| |
| // A pending non-search after a pending search should delete the map entry. |
| SetNavigationPending(&infobar_manager, true); |
| GoogleURLTrackerMapEntry* map_entry = GetMapEntry(&infobar_manager); |
| ASSERT_FALSE(map_entry == NULL); |
| EXPECT_FALSE(map_entry->has_infobar_delegate()); |
| SetNavigationPending(&infobar_manager, false); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| |
| // A pending search after a pending search should leave the map entry alive. |
| SetNavigationPending(&infobar_manager, true); |
| map_entry = GetMapEntry(&infobar_manager); |
| ASSERT_FALSE(map_entry == NULL); |
| EXPECT_FALSE(map_entry->has_infobar_delegate()); |
| SetNavigationPending(&infobar_manager, true); |
| ASSERT_EQ(map_entry, GetMapEntry(&infobar_manager)); |
| EXPECT_FALSE(map_entry->has_infobar_delegate()); |
| ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, true)); |
| |
| // Committing this search should show an infobar. |
| CommitSearch(&infobar_manager, |
| GURL("http://www.google.co.uk/search?q=test2")); |
| EXPECT_TRUE(map_entry->has_infobar_delegate()); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_FALSE(listener_notified()); |
| ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, NavigationsAfterCommittedSearch) { |
| TestInfoBarManager infobar_manager(1); |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| GoogleURLTrackerInfoBarDelegate* delegate = |
| GetInfoBarDelegate(&infobar_manager); |
| ASSERT_FALSE(delegate == NULL); |
| ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); |
| |
| // A pending non-search on a visible infobar should basically do nothing. |
| SetNavigationPending(&infobar_manager, false); |
| ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); |
| EXPECT_EQ(0, delegate->pending_id()); |
| ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); |
| |
| // As should another pending non-search after the first. |
| SetNavigationPending(&infobar_manager, false); |
| ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); |
| EXPECT_EQ(0, delegate->pending_id()); |
| ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); |
| |
| // Committing this non-search should close the infobar. The control flow in |
| // these tests is not really comparable to in the real browser, but at least a |
| // few sanity-checks will be performed. |
| ASSERT_NO_FATAL_FAILURE(CommitNonSearch(&infobar_manager)); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| |
| // A pending search on a visible infobar should cause the infobar to listen |
| // for the search to commit. |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| delegate = GetInfoBarDelegate(&infobar_manager); |
| ASSERT_FALSE(delegate == NULL); |
| SetNavigationPending(&infobar_manager, true); |
| ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); |
| EXPECT_EQ(1, delegate->pending_id()); |
| ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, true)); |
| |
| // But a non-search after this should cancel that state. |
| SetNavigationPending(&infobar_manager, false); |
| ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); |
| EXPECT_EQ(0, delegate->pending_id()); |
| ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); |
| |
| // Another pending search after the non-search should put us back into |
| // "waiting for commit" mode. |
| SetNavigationPending(&infobar_manager, true); |
| ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); |
| EXPECT_EQ(1, delegate->pending_id()); |
| ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, true)); |
| |
| // A second pending search after the first should not really change anything. |
| SetNavigationPending(&infobar_manager, true); |
| ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); |
| EXPECT_EQ(1, delegate->pending_id()); |
| ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, true)); |
| |
| // Committing this search should change the visible infobar's search_url. |
| CommitSearch(&infobar_manager, |
| GURL("http://www.google.co.uk/search?q=test2")); |
| ASSERT_EQ(delegate, GetInfoBarDelegate(&infobar_manager)); |
| EXPECT_EQ(GURL("http://www.google.co.uk/search?q=test2"), |
| delegate->search_url()); |
| EXPECT_EQ(0, delegate->pending_id()); |
| ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); |
| EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL()); |
| EXPECT_FALSE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, MultipleMapEntries) { |
| TestInfoBarManager infobar_manager(1); |
| TestInfoBarManager infobar_manager2(2); |
| TestInfoBarManager infobar_manager3(3); |
| TestInfoBarManager infobar_manager4(4); |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| |
| SetNavigationPending(&infobar_manager, true); |
| GoogleURLTrackerMapEntry* map_entry = GetMapEntry(&infobar_manager); |
| ASSERT_FALSE(map_entry == NULL); |
| EXPECT_FALSE(map_entry->has_infobar_delegate()); |
| |
| SetNavigationPending(&infobar_manager2, true); |
| CommitSearch(&infobar_manager2, |
| GURL("http://www.google.co.uk/search?q=test2")); |
| GoogleURLTrackerInfoBarDelegate* delegate2 = |
| GetInfoBarDelegate(&infobar_manager2); |
| ASSERT_FALSE(delegate2 == NULL); |
| EXPECT_EQ(GURL("http://www.google.co.uk/search?q=test2"), |
| delegate2->search_url()); |
| |
| SetNavigationPending(&infobar_manager3, true); |
| GoogleURLTrackerMapEntry* map_entry3 = GetMapEntry(&infobar_manager3); |
| ASSERT_FALSE(map_entry3 == NULL); |
| EXPECT_FALSE(map_entry3->has_infobar_delegate()); |
| |
| SetNavigationPending(&infobar_manager4, true); |
| CommitSearch(&infobar_manager4, |
| GURL("http://www.google.co.uk/search?q=test4")); |
| GoogleURLTrackerInfoBarDelegate* delegate4 = |
| GetInfoBarDelegate(&infobar_manager4); |
| ASSERT_FALSE(delegate4 == NULL); |
| EXPECT_EQ(GURL("http://www.google.co.uk/search?q=test4"), |
| delegate4->search_url()); |
| |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| EXPECT_TRUE(map_entry->has_infobar_delegate()); |
| |
| delegate2->Close(false); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager2) == NULL); |
| EXPECT_FALSE(listener_notified()); |
| |
| delegate4->Accept(); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager) == NULL); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager3) == NULL); |
| EXPECT_TRUE(GetMapEntry(&infobar_manager4) == NULL); |
| EXPECT_EQ(GURL("http://www.google.co.jp/"), google_url()); |
| EXPECT_EQ(GURL("http://www.google.co.jp/"), GetLastPromptedGoogleURL()); |
| EXPECT_TRUE(listener_notified()); |
| } |
| |
| TEST_F(GoogleURLTrackerTest, IgnoreIrrelevantNavigation) { |
| TestInfoBarManager infobar_manager(1); |
| TestInfoBarManager infobar_manager2(2); |
| SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/")); |
| RequestServerCheck(); |
| FinishSleep(); |
| MockSearchDomainCheckResponse("http://www.google.co.jp/"); |
| |
| // This tests a particularly gnarly sequence of events that used to cause us |
| // to erroneously listen for a non-search navigation to commit. |
| SetNavigationPending(&infobar_manager, true); |
| CommitSearch(&infobar_manager, GURL("http://www.google.co.uk/search?q=test")); |
| SetNavigationPending(&infobar_manager2, true); |
| CommitSearch(&infobar_manager2, |
| GURL("http://www.google.co.uk/search?q=test2")); |
| EXPECT_FALSE(GetInfoBarDelegate(&infobar_manager) == NULL); |
| GoogleURLTrackerInfoBarDelegate* delegate2 = |
| GetInfoBarDelegate(&infobar_manager2); |
| ASSERT_FALSE(delegate2 == NULL); |
| SetNavigationPending(&infobar_manager, true); |
| ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, true)); |
| delegate2->Close(false); |
| SetNavigationPending(&infobar_manager, false); |
| ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(&infobar_manager, false)); |
| } |