google_url_tracker_unittest.cc revision a3f6a49ab37290eeeb8db0f41ec0f1cb74a68be7 
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
26class GoogleURLTrackerTest;
27
28namespace {
29
30// TestInfoBarDelegate --------------------------------------------------------
31
32class 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
68class 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
83TestNotificationObserver::TestNotificationObserver() : notified_(false) {
84}
85
86TestNotificationObserver::~TestNotificationObserver() {
87}
88
89void TestNotificationObserver::Observe(
90    int type,
91    const content::NotificationSource& source,
92    const content::NotificationDetails& details) {
93  notified_ = true;
94}
95
96
97// TestGoogleURLTrackerNavigationHelper -------------------------------------
98
99class 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
128TestGoogleURLTrackerNavigationHelper::TestGoogleURLTrackerNavigationHelper()
129    : tracker_(NULL),
130      observe_nav_start_(false) {
131}
132
133TestGoogleURLTrackerNavigationHelper::
134    ~TestGoogleURLTrackerNavigationHelper() {
135}
136
137void TestGoogleURLTrackerNavigationHelper::SetGoogleURLTracker(
138    GoogleURLTracker* tracker) {
139  tracker_ = tracker;
140}
141
142void TestGoogleURLTrackerNavigationHelper::SetListeningForNavigationStart(
143    bool listen) {
144  observe_nav_start_ = listen;
145}
146
147bool TestGoogleURLTrackerNavigationHelper::IsListeningForNavigationStart() {
148  return observe_nav_start_;
149}
150
151void 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
160bool TestGoogleURLTrackerNavigationHelper::IsListeningForNavigationCommit(
161    const content::NavigationController* nav_controller) {
162  return nav_controller_commit_listeners_.count(nav_controller) > 0;
163}
164
165void 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
174bool 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.
199class 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
264void 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
282GoogleURLTrackerTest::GoogleURLTrackerTest()
283    : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
284  GoogleURLTrackerFactory::GetInstance()->
285      RegisterUserPrefsOnBrowserContextForTest(&profile_);
286}
287
288GoogleURLTrackerTest::~GoogleURLTrackerTest() {
289}
290
291void 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
304void 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
313net::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
319void 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
332void 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
342void GoogleURLTrackerTest::FinishSleep() {
343  google_url_tracker_->FinishSleep();
344}
345
346void 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
353void GoogleURLTrackerTest::SetLastPromptedGoogleURL(const GURL& url) {
354  profile_.GetPrefs()->SetString(prefs::kLastPromptedGoogleURL, url.spec());
355}
356
357GURL GoogleURLTrackerTest::GetLastPromptedGoogleURL() {
358  return GURL(profile_.GetPrefs()->GetString(prefs::kLastPromptedGoogleURL));
359}
360
361void 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
376void 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
395void 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
405void 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
419GoogleURLTrackerMapEntry* 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
427GoogleURLTrackerInfoBarDelegate* 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
433void GoogleURLTrackerTest::ExpectDefaultURLs() const {
434  EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
435  EXPECT_EQ(GURL(), fetched_google_url());
436}
437
438void 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
449InfoBar* 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
460namespace {
461
462// static
463InfoBar* 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
473TestInfoBarDelegate::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
482TestInfoBarDelegate::~TestInfoBarDelegate() {
483}
484
485void TestInfoBarDelegate::Update(const GURL& search_url) {
486  set_search_url(search_url);
487  set_pending_id(0);
488}
489
490void 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
501TEST_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
511TEST_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
525TEST_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
542TEST_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
611TEST_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
623TEST_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
644TEST_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
661TEST_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
671TEST_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
685TEST_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
708TEST_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
727TEST_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
752TEST_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
769TEST_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
787TEST_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
805TEST_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
823TEST_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
894TEST_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
915TEST_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
948TEST_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
1019TEST_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
1065TEST_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}
1086