Elimate NOTIFICATION_GOOGLE_URL_UPDATED

chrome/browser/google/google_url_tracker_unittest.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/google/google_url_tracker.h"
 
 #include <set>
 #include <string>
 
 #include "base/message_loop/message_loop.h"
@@ skipping 43 matching lines @@
   virtual void Close(bool redo_search) OVERRIDE;
 
   GoogleURLTrackerTest* test_harness_;
   InfoBarService* infobar_service_;
 
   DISALLOW_COPY_AND_ASSIGN(TestInfoBarDelegate);
 };
 
 // The member function definitions come after the declaration of
 // GoogleURLTrackerTest, so they can call members on it.
 

[Peter Kasting, 2014/05/16 23:23:45]

Nit: Preserve two blank lines here

[blundell, 2014/05/17 11:25:36]

Done.

+// TestCallbackListener ---------------------------------------------------
 
-// TestNotificationObserver ---------------------------------------------------
+class TestCallbackListener {
+ public:
+  TestCallbackListener();
+  virtual ~TestCallbackListener();
 
-class TestNotificationObserver : public content::NotificationObserver {
- public:
-  TestNotificationObserver();
-  virtual ~TestNotificationObserver();
+  bool HasRegisteredCallback();
+  void RegisterCallback(GoogleURLTracker* google_url_tracker);
 
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) OVERRIDE;
   bool notified() const { return notified_; }
   void clear_notified() { notified_ = false; }
 
  private:
+  void OnGoogleURLUpdated(GURL old_url, GURL new_url);
+
   bool notified_;
+  scoped_ptr<GoogleURLTracker::Subscription> google_url_updated_subscription_;
 };
 
-TestNotificationObserver::TestNotificationObserver() : notified_(false) {
+TestCallbackListener::TestCallbackListener() : notified_(false) {
 }
 
-TestNotificationObserver::~TestNotificationObserver() {
+TestCallbackListener::~TestCallbackListener() {
 }
 
-void TestNotificationObserver::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
+void TestCallbackListener::OnGoogleURLUpdated(GURL old_url, GURL new_url) {
   notified_ = true;
 }
 
+bool TestCallbackListener::HasRegisteredCallback() {
+  return google_url_updated_subscription_.get();
+}
+
+void TestCallbackListener::RegisterCallback(
+    GoogleURLTracker* google_url_tracker) {
+  google_url_updated_subscription_ =
+      google_url_tracker->RegisterCallback(base::Bind(
+          &TestCallbackListener::OnGoogleURLUpdated, base::Unretained(this)));
+}
 
 // TestGoogleURLTrackerNavigationHelper -------------------------------------
 
 class TestGoogleURLTrackerNavigationHelper
     : public GoogleURLTrackerNavigationHelper {
  public:
   TestGoogleURLTrackerNavigationHelper();
   virtual ~TestGoogleURLTrackerNavigationHelper();
 
   virtual void SetGoogleURLTracker(GoogleURLTracker* tracker) OVERRIDE;
@@ skipping 119 matching lines @@
   void SetLastPromptedGoogleURL(const GURL& url);
   GURL GetLastPromptedGoogleURL();
   void SetNavigationPending(intptr_t unique_id, bool is_search);
   void CommitNonSearch(intptr_t unique_id);
   void CommitSearch(intptr_t unique_id, const GURL& search_url);
   void CloseTab(intptr_t unique_id);
   GoogleURLTrackerMapEntry* GetMapEntry(intptr_t unique_id);
   GoogleURLTrackerInfoBarDelegate* GetInfoBarDelegate(intptr_t unique_id);
   void ExpectDefaultURLs() const;
   void ExpectListeningForCommit(intptr_t unique_id, bool listening);
-  bool observer_notified() const { return observer_.notified(); }
-  void clear_observer_notified() { observer_.clear_notified(); }
+  bool listener_notified() const { return listener_.notified(); }
+  void clear_listener_notified() { listener_.clear_notified(); }
 
  private:
   // Since |infobar_service| is really a magic number rather than an actual
   // object, we don't add the created infobar to it.  Instead we will simulate
   // any helper<->infobar interaction necessary.  The returned object will be
   // cleaned up in OnInfoBarClosed().
   infobars::InfoBar* CreateTestInfoBar(InfoBarService* infobar_service,
                                        GoogleURLTracker* google_url_tracker,
                                        const GURL& search_url);
 
   // These are required by the TestURLFetchers GoogleURLTracker will create (see
   // test_url_fetcher_factory.h).
   content::TestBrowserThreadBundle thread_bundle_;
   // Creating this allows us to call
   // net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests().
   scoped_ptr<net::NetworkChangeNotifier> network_change_notifier_;
   net::TestURLFetcherFactory fetcher_factory_;
-  content::NotificationRegistrar registrar_;
-  TestNotificationObserver observer_;
   GoogleURLTrackerNavigationHelper* nav_helper_;
   TestingProfile profile_;
   scoped_ptr<GoogleURLTracker> google_url_tracker_;
+  TestCallbackListener listener_;
   // This tracks the different "tabs" a test has "opened", so we can close them
   // properly before shutting down |google_url_tracker_|, which expects that.
   std::set<int> unique_ids_seen_;
 };
 
 void GoogleURLTrackerTest::OnInfoBarClosed(
     scoped_ptr<infobars::InfoBar> infobar,
     InfoBarService* infobar_service) {
   // First, simulate the InfoBarService firing INFOBAR_REMOVED.
   infobars::InfoBar::RemovedDetails removed_details(infobar.get(), false);
@@ skipping 31 matching lines @@
                            GoogleURLTracker::UNIT_TEST_MODE));
   google_url_tracker_->infobar_creator_ = base::Bind(
       &GoogleURLTrackerTest::CreateTestInfoBar, base::Unretained(this));
 }
 
 void GoogleURLTrackerTest::TearDown() {
   while (!unique_ids_seen_.empty())
     CloseTab(*unique_ids_seen_.begin());
 
   nav_helper_ = NULL;
-  google_url_tracker_.reset();
   network_change_notifier_.reset();
 }
 
 net::TestURLFetcher* GoogleURLTrackerTest::GetFetcher() {
   // This will return the last fetcher created.  If no fetchers have been
   // created, we'll pass GetFetcherByID() "-1", and it will return NULL.
   return fetcher_factory_.GetFetcherByID(google_url_tracker_->fetcher_id_ - 1);
 }
 
 void GoogleURLTrackerTest::MockSearchDomainCheckResponse(
     const std::string& domain) {
   net::TestURLFetcher* fetcher = GetFetcher();
   if (!fetcher)
     return;
   fetcher_factory_.RemoveFetcherFromMap(fetcher->id());
   fetcher->set_url(GURL(GoogleURLTracker::kSearchDomainCheckURL));
   fetcher->set_response_code(200);
   fetcher->SetResponseString(domain);
   fetcher->delegate()->OnURLFetchComplete(fetcher);
   // At this point, |fetcher| is deleted.
 }
 
 void GoogleURLTrackerTest::RequestServerCheck() {
-  if (!registrar_.IsRegistered(&observer_,
-                               chrome::NOTIFICATION_GOOGLE_URL_UPDATED,
-                               content::Source<Profile>(&profile_))) {
-    registrar_.Add(&observer_, chrome::NOTIFICATION_GOOGLE_URL_UPDATED,
-                   content::Source<Profile>(&profile_));
-  }
+  if (!listener_.HasRegisteredCallback())
+    listener_.RegisterCallback(google_url_tracker_.get());
   google_url_tracker_->SetNeedToFetch();
 }
 
 void GoogleURLTrackerTest::FinishSleep() {
   google_url_tracker_->FinishSleep();
 }
 
 void GoogleURLTrackerTest::NotifyIPAddressChanged() {
   net::NetworkChangeNotifier::NotifyObserversOfIPAddressChangeForTests();
   // For thread safety, the NCN queues tasks to do the actual notifications, so
@@ skipping 150 matching lines @@
 
 // Tests ----------------------------------------------------------------------
 
 TEST_F(GoogleURLTrackerTest, DontFetchWhenNoOneRequestsCheck) {
   ExpectDefaultURLs();
   FinishSleep();
   // No one called RequestServerCheck() so nothing should have happened.
   EXPECT_FALSE(GetFetcher());
   MockSearchDomainCheckResponse("http://www.google.co.uk/");
   ExpectDefaultURLs();
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, UpdateOnFirstRun) {
   RequestServerCheck();
   EXPECT_FALSE(GetFetcher());
   ExpectDefaultURLs();
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.uk/");
   EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url());
   // GoogleURL should be updated, becase there was no last prompted URL.
   EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url());
-  EXPECT_TRUE(observer_notified());
+  EXPECT_TRUE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, DontUpdateWhenUnchanged) {
   SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/"));
 
   RequestServerCheck();
   EXPECT_FALSE(GetFetcher());
   ExpectDefaultURLs();
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.uk/");
   EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url());
   // GoogleURL should not be updated, because the fetched and prompted URLs
   // match.
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, DontPromptOnBadReplies) {
   SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/"));
 
   RequestServerCheck();
   EXPECT_FALSE(GetFetcher());
   ExpectDefaultURLs();
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 
   // Old-style domain string.
   FinishSleep();
   MockSearchDomainCheckResponse(".google.co.in");
   EXPECT_EQ(GURL(), fetched_google_url());
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   EXPECT_TRUE(GetMapEntry(1) == NULL);
 
   // Bad subdomain.
   NotifyIPAddressChanged();
   MockSearchDomainCheckResponse("http://mail.google.com/");
   EXPECT_EQ(GURL(), fetched_google_url());
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   EXPECT_TRUE(GetMapEntry(1) == NULL);
 
   // Non-empty path.
   NotifyIPAddressChanged();
   MockSearchDomainCheckResponse("http://www.google.com/search");
   EXPECT_EQ(GURL(), fetched_google_url());
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   EXPECT_TRUE(GetMapEntry(1) == NULL);
 
   // Non-empty query.
   NotifyIPAddressChanged();
   MockSearchDomainCheckResponse("http://www.google.com/?q=foo");
   EXPECT_EQ(GURL(), fetched_google_url());
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   EXPECT_TRUE(GetMapEntry(1) == NULL);
 
   // Non-empty ref.
   NotifyIPAddressChanged();
   MockSearchDomainCheckResponse("http://www.google.com/#anchor");
   EXPECT_EQ(GURL(), fetched_google_url());
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   EXPECT_TRUE(GetMapEntry(1) == NULL);
 
   // Complete garbage.
   NotifyIPAddressChanged();
   MockSearchDomainCheckResponse("HJ)*qF)_*&@f1");
   EXPECT_EQ(GURL(), fetched_google_url());
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   EXPECT_TRUE(GetMapEntry(1) == NULL);
 }
 
 TEST_F(GoogleURLTrackerTest, UpdatePromptedURLOnReturnToPreviousLocation) {
   SetLastPromptedGoogleURL(GURL("http://www.google.co.jp/"));
   set_google_url(GURL("http://www.google.co.uk/"));
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.uk/");
   EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, SilentlyAcceptSchemeChange) {
   // We should auto-accept changes to the current Google URL that merely change
   // the scheme, regardless of what the last prompted URL was.
   SetLastPromptedGoogleURL(GURL("http://www.google.co.jp/"));
   set_google_url(GURL("http://www.google.co.uk/"));
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse("https://www.google.co.uk/");
   EXPECT_EQ(GURL("https://www.google.co.uk/"), fetched_google_url());
   EXPECT_EQ(GURL("https://www.google.co.uk/"), google_url());
   EXPECT_EQ(GURL("https://www.google.co.uk/"), GetLastPromptedGoogleURL());
-  EXPECT_TRUE(observer_notified());
+  EXPECT_TRUE(listener_notified());
 
   NotifyIPAddressChanged();
   MockSearchDomainCheckResponse("http://www.google.co.uk/");
   EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL());
-  EXPECT_TRUE(observer_notified());
+  EXPECT_TRUE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, RefetchOnIPAddressChange) {
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.uk/");
   EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url());
-  EXPECT_TRUE(observer_notified());
-  clear_observer_notified();
+  EXPECT_TRUE(listener_notified());
+  clear_listener_notified();
 
   NotifyIPAddressChanged();
   MockSearchDomainCheckResponse("http://www.google.co.in/");
   EXPECT_EQ(GURL("http://www.google.co.in/"), fetched_google_url());
   // Just fetching a new URL shouldn't reset things without a prompt.
   EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, DontRefetchWhenNoOneRequestsCheck) {
   FinishSleep();
   NotifyIPAddressChanged();
   // No one called RequestServerCheck() so nothing should have happened.
   EXPECT_FALSE(GetFetcher());
   MockSearchDomainCheckResponse("http://www.google.co.uk/");
   ExpectDefaultURLs();
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, FetchOnLateRequest) {
   FinishSleep();
   NotifyIPAddressChanged();
   MockSearchDomainCheckResponse("http://www.google.co.jp/");
 
   RequestServerCheck();
   // The first request for a check should trigger a fetch if it hasn't happened
   // already.
   MockSearchDomainCheckResponse("http://www.google.co.uk/");
   EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url());
-  EXPECT_TRUE(observer_notified());
+  EXPECT_TRUE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, DontFetchTwiceOnLateRequests) {
   FinishSleep();
   NotifyIPAddressChanged();
   MockSearchDomainCheckResponse("http://www.google.co.jp/");
 
   RequestServerCheck();
   // The first request for a check should trigger a fetch if it hasn't happened
   // already.
   MockSearchDomainCheckResponse("http://www.google.co.uk/");
   EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url());
-  EXPECT_TRUE(observer_notified());
-  clear_observer_notified();
+  EXPECT_TRUE(listener_notified());
+  clear_listener_notified();
 
   RequestServerCheck();
   // The second request should be ignored.
   EXPECT_FALSE(GetFetcher());
   MockSearchDomainCheckResponse("http://www.google.co.in/");
   EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, SearchingDoesNothingIfNoNeedToPrompt) {
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.uk/");
   EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL());
-  EXPECT_TRUE(observer_notified());
-  clear_observer_notified();
+  EXPECT_TRUE(listener_notified());
+  clear_listener_notified();
 
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   EXPECT_TRUE(GetMapEntry(1) == NULL);
   EXPECT_EQ(GURL("http://www.google.co.uk/"), fetched_google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, TabClosedOnPendingSearch) {
   SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/"));
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.jp/");
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
   EXPECT_EQ(GURL("http://www.google.co.jp/"), fetched_google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 
   SetNavigationPending(1, true);
   GoogleURLTrackerMapEntry* map_entry = GetMapEntry(1);
   ASSERT_FALSE(map_entry == NULL);
   EXPECT_FALSE(map_entry->has_infobar_delegate());
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 
   CloseTab(1);
   EXPECT_TRUE(GetMapEntry(1) == NULL);
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, TabClosedOnCommittedSearch) {
   SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/"));
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.jp/");
 
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   EXPECT_FALSE(GetInfoBarDelegate(1) == NULL);
 
   CloseTab(1);
   EXPECT_TRUE(GetMapEntry(1) == NULL);
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, InfoBarClosed) {
   SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/"));
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.jp/");
 
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   GoogleURLTrackerInfoBarDelegate* infobar = GetInfoBarDelegate(1);
   ASSERT_FALSE(infobar == NULL);
 
   infobar->Close(false);
   EXPECT_TRUE(GetMapEntry(1) == NULL);
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, InfoBarRefused) {
   SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/"));
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.jp/");
 
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   GoogleURLTrackerInfoBarDelegate* infobar = GetInfoBarDelegate(1);
   ASSERT_FALSE(infobar == NULL);
 
   infobar->Cancel();
   EXPECT_TRUE(GetMapEntry(1) == NULL);
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
   EXPECT_EQ(GURL("http://www.google.co.jp/"), GetLastPromptedGoogleURL());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, InfoBarAccepted) {
   SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/"));
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.jp/");
 
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   GoogleURLTrackerInfoBarDelegate* infobar = GetInfoBarDelegate(1);
   ASSERT_FALSE(infobar == NULL);
 
   infobar->Accept();
   EXPECT_TRUE(GetMapEntry(1) == NULL);
   EXPECT_EQ(GURL("http://www.google.co.jp/"), google_url());
   EXPECT_EQ(GURL("http://www.google.co.jp/"), GetLastPromptedGoogleURL());
-  EXPECT_TRUE(observer_notified());
+  EXPECT_TRUE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, FetchesCanAutomaticallyCloseInfoBars) {
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse(google_url().spec());
 
   // Re-fetching the accepted URL after showing an infobar for another URL
   // should close the infobar.
   NotifyIPAddressChanged();
@@ skipping 102 matching lines @@
   SetNavigationPending(1, true);
   ASSERT_EQ(map_entry, GetMapEntry(1));
   EXPECT_FALSE(map_entry->has_infobar_delegate());
   ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(1, true));
 
   // Committing this search should show an infobar.
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test2"));
   EXPECT_TRUE(map_entry->has_infobar_delegate());
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
   ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(1, false));
 }
 
 TEST_F(GoogleURLTrackerTest, NavigationsAfterCommittedSearch) {
   SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/"));
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.jp/");
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
@@ skipping 51 matching lines @@
 
   // Committing this search should change the visible infobar's search_url.
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test2"));
   ASSERT_EQ(delegate, GetInfoBarDelegate(1));
   EXPECT_EQ(GURL("http://www.google.co.uk/search?q=test2"),
             delegate->search_url());
   EXPECT_EQ(0, delegate->pending_id());
   ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(1, false));
   EXPECT_EQ(GURL(GoogleURLTracker::kDefaultGoogleHomepage), google_url());
   EXPECT_EQ(GURL("http://www.google.co.uk/"), GetLastPromptedGoogleURL());
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, MultipleMapEntries) {
   SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/"));
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.jp/");
 
   SetNavigationPending(1, true);
   GoogleURLTrackerMapEntry* map_entry = GetMapEntry(1);
@@ skipping 17 matching lines @@
   GoogleURLTrackerInfoBarDelegate* delegate4 = GetInfoBarDelegate(4);
   ASSERT_FALSE(delegate4 == NULL);
   EXPECT_EQ(GURL("http://www.google.co.uk/search?q=test4"),
             delegate4->search_url());
 
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   EXPECT_TRUE(map_entry->has_infobar_delegate());
 
   delegate2->Close(false);
   EXPECT_TRUE(GetMapEntry(2) == NULL);
-  EXPECT_FALSE(observer_notified());
+  EXPECT_FALSE(listener_notified());
 
   delegate4->Accept();
   EXPECT_TRUE(GetMapEntry(1) == NULL);
   EXPECT_TRUE(GetMapEntry(3) == NULL);
   EXPECT_TRUE(GetMapEntry(4) == NULL);
   EXPECT_EQ(GURL("http://www.google.co.jp/"), google_url());
   EXPECT_EQ(GURL("http://www.google.co.jp/"), GetLastPromptedGoogleURL());
-  EXPECT_TRUE(observer_notified());
+  EXPECT_TRUE(listener_notified());
 }
 
 TEST_F(GoogleURLTrackerTest, IgnoreIrrelevantNavigation) {
   SetLastPromptedGoogleURL(GURL("http://www.google.co.uk/"));
   RequestServerCheck();
   FinishSleep();
   MockSearchDomainCheckResponse("http://www.google.co.jp/");
 
   // This tests a particularly gnarly sequence of events that used to cause us
   // to erroneously listen for a non-search navigation to commit.
   SetNavigationPending(1, true);
   CommitSearch(1, GURL("http://www.google.co.uk/search?q=test"));
   SetNavigationPending(2, true);
   CommitSearch(2, GURL("http://www.google.co.uk/search?q=test2"));
   EXPECT_FALSE(GetInfoBarDelegate(1) == NULL);
   GoogleURLTrackerInfoBarDelegate* delegate2 = GetInfoBarDelegate(2);
   ASSERT_FALSE(delegate2 == NULL);
   SetNavigationPending(1, true);
   ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(1, true));
   delegate2->Close(false);
   SetNavigationPending(1, false);
   ASSERT_NO_FATAL_FAILURE(ExpectListeningForCommit(1, false));
 }