chrome/browser/google/google_url_tracker_unittest.cc

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