Eliminate dependence of GoogleURLTracker et al. on InfoBarService

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 14 matching lines @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 class GoogleURLTrackerTest;
 
 namespace {
 
 // TestInfoBarDelegate --------------------------------------------------------
 
 class TestInfoBarDelegate : public GoogleURLTrackerInfoBarDelegate {
  public:
-  // Creates a test infobar and delegate and returns the infobar.  Unlike the
-  // parent class, this does not add the infobar to |infobar_service|, since
-  // that "pointer" is really just a magic number.  Thus there is no
-  // InfoBarService ownership of the returned object; and since the caller
-  // doesn't own the returned object, we rely on |test_harness| cleaning this up
-  // eventually in GoogleURLTrackerTest::OnInfoBarClosed() to avoid leaks.
-  static infobars::InfoBar* Create(GoogleURLTrackerTest* test_harness,
-                                   InfoBarService* infobar_service,
-                                   GoogleURLTracker* google_url_tracker,
-                                   const GURL& search_url);
+   // Creates a test infobar and delegate and returns the infobar.  Unlike the
+   // parent class, this does not add the infobar to |infobar_manager|, since
+   // that "pointer" is really just a magic number.  Thus there is no
+   // InfoBarManager ownership of the returned object; and since the caller
+   // doesn't own the returned object, we rely on |test_harness| cleaning this
+   // up eventually in GoogleURLTrackerTest::OnInfoBarClosed() to avoid leaks.
+   static infobars::InfoBar* Create(
+      GoogleURLTrackerTest* test_harness,
+      infobars::InfoBarManager* infobar_manager,
+      GoogleURLTracker* google_url_tracker,
+      const GURL& search_url);
 
  private:
   TestInfoBarDelegate(GoogleURLTrackerTest* test_harness,
-                      InfoBarService* infobar_service,
+                      infobars::InfoBarManager* infobar_manager,
                       GoogleURLTracker* google_url_tracker,
                       const GURL& search_url);
   virtual ~TestInfoBarDelegate();
 
   // GoogleURLTrackerInfoBarDelegate:
   virtual void Update(const GURL& search_url) OVERRIDE;
   virtual void Close(bool redo_search) OVERRIDE;
 
   GoogleURLTrackerTest* test_harness_;
-  InfoBarService* infobar_service_;
+  infobars::InfoBarManager* infobar_manager_;
 
   DISALLOW_COPY_AND_ASSIGN(TestInfoBarDelegate);
 };
 
 // The member function definitions come after the declaration of
 // GoogleURLTrackerTest, so they can call members on it.
 
 
 // TestCallbackListener ---------------------------------------------------
 
@@ skipping 74 matching lines @@
 class TestGoogleURLTrackerNavigationHelper
     : public GoogleURLTrackerNavigationHelper {
  public:
   explicit TestGoogleURLTrackerNavigationHelper(GoogleURLTracker* tracker);
   virtual ~TestGoogleURLTrackerNavigationHelper();
 
   virtual void SetListeningForNavigationCommit(bool listen) OVERRIDE;
   virtual bool IsListeningForNavigationCommit() OVERRIDE;
   virtual void SetListeningForTabDestruction(bool listen) OVERRIDE;
   virtual bool IsListeningForTabDestruction() OVERRIDE;
+  virtual void OpenURL(GURL url,
+                       WindowOpenDisposition disposition,
+                       bool user_clicked_on_link) OVERRIDE;
 
  private:
   bool listening_for_nav_commit_;
   bool listening_for_tab_destruction_;
 
   DISALLOW_COPY_AND_ASSIGN(TestGoogleURLTrackerNavigationHelper);
 };
 
 TestGoogleURLTrackerNavigationHelper::TestGoogleURLTrackerNavigationHelper(
     GoogleURLTracker* tracker)
@@ skipping 16 matching lines @@
 
 void TestGoogleURLTrackerNavigationHelper::SetListeningForTabDestruction(
     bool listen) {
   listening_for_tab_destruction_ = listen;
 }
 
 bool TestGoogleURLTrackerNavigationHelper::IsListeningForTabDestruction() {
   return listening_for_tab_destruction_;
 }
 
+void TestGoogleURLTrackerNavigationHelper::OpenURL(
+    GURL url,
+    WindowOpenDisposition disposition,
+    bool user_clicked_on_link) {
+}
+
 }  // namespace
 
 
 // GoogleURLTrackerTest -------------------------------------------------------
 
 // Ths class exercises GoogleURLTracker.  In order to avoid instantiating more
 // of the Chrome infrastructure than necessary, the GoogleURLTracker functions
 // are carefully written so that many of the functions which take
-// NavigationController* or InfoBarService* do not actually dereference the
+// NavigationController* or infobars::InfoBarManager* do not actually
+// dereference the
 // objects, merely use them for comparisons and lookups, e.g. in |entry_map_|.
 // This then allows the test code here to not create any of these objects, and
 // instead supply "pointers" that are actually reinterpret_cast<>()ed magic
 // numbers.  Then we write the necessary stubs/hooks, here and in
 // TestInfoBarDelegate above, to make everything continue to work.
 //
 // Technically, the C++98 spec defines the result of casting
 // T* -> intptr_t -> T* to be an identity, but intptr_t -> T* -> intptr_t (what
 // we use here) is "implementation-defined".  Since I've never seen a compiler
 // break this, though, and the result would simply be a failing test rather than
 // a bug in Chrome, we'll use it anyway.
 class GoogleURLTrackerTest : public testing::Test {
  public:
   // Called by TestInfoBarDelegate::Close().
   void OnInfoBarClosed(scoped_ptr<infobars::InfoBar> infobar,
-                       InfoBarService* infobar_service);
+                       infobars::InfoBarManager* infobar_manager);
 
  protected:
   GoogleURLTrackerTest();
   virtual ~GoogleURLTrackerTest();
 
   // testing::Test
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   net::TestURLFetcher* GetFetcher();
@@ skipping 16 matching lines @@
   void CloseTab(intptr_t unique_id);
   GoogleURLTrackerMapEntry* GetMapEntry(intptr_t unique_id);
   GoogleURLTrackerInfoBarDelegate* GetInfoBarDelegate(intptr_t unique_id);
   GoogleURLTrackerNavigationHelper* GetNavigationHelper(intptr_t unique_id);
   void ExpectDefaultURLs() const;
   void ExpectListeningForCommit(intptr_t unique_id, bool listening);
   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
+  // Since |infobar_manager| 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);
+  infobars::InfoBar* CreateTestInfoBar(
+      infobars::InfoBarManager* infobar_manager,
+      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_;
   GoogleURLTrackerClient* client_;
   TestingProfile profile_;
   scoped_ptr<GoogleURLTracker> google_url_tracker_;
   TestCallbackListener listener_;
   // This tracks the different "tabs" a test has "opened", so we can close them
   // properly before shutting down |google_url_tracker_|, which expects that.
   std::set<int> unique_ids_seen_;
 };
 
 void GoogleURLTrackerTest::OnInfoBarClosed(
     scoped_ptr<infobars::InfoBar> infobar,
-    InfoBarService* infobar_service) {
-  // First, simulate the InfoBarService firing INFOBAR_REMOVED.
+    infobars::InfoBarManager* infobar_manager) {
+  // First, simulate the InfoBarManager firing INFOBAR_REMOVED.
+  // TODO(droger): Replace this flow with a call to the observer method once
+  // the map entry is observing InfoBarManager. crbug.com/373243
   infobars::InfoBar::RemovedDetails removed_details(infobar.get(), false);
   GoogleURLTracker::EntryMap::const_iterator i =
-      google_url_tracker_->entry_map_.find(infobar_service);
+      google_url_tracker_->entry_map_.find(infobar_manager);
   ASSERT_FALSE(i == google_url_tracker_->entry_map_.end());
   GoogleURLTrackerMapEntry* map_entry = i->second;
   ASSERT_EQ(infobar->delegate(), map_entry->infobar_delegate());
   map_entry->Observe(
       chrome::NOTIFICATION_TAB_CONTENTS_INFOBAR_REMOVED,
-      content::Source<InfoBarService>(infobar_service),
+      content::Source<infobars::InfoBarManager>(infobar_manager),
       content::Details<infobars::InfoBar::RemovedDetails>(&removed_details));
 
   // Second, simulate the infobar container closing the infobar in response.
   // This happens automatically as |infobar| goes out of scope.
 }
 
 GoogleURLTrackerTest::GoogleURLTrackerTest()
     : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {
   GoogleURLTrackerFactory::GetInstance()->
       RegisterUserPrefsOnBrowserContextForTest(&profile_);
@@ skipping 70 matching lines @@
     google_url_tracker_->SearchCommitted();
     // Note that the call above might not have actually registered a listener
     // for navigation starts if the searchdomaincheck response was bogus.
   }
   unique_ids_seen_.insert(unique_id);
   if (client_->IsListeningForNavigationStart()) {
     google_url_tracker_->OnNavigationPending(
         scoped_ptr<GoogleURLTrackerNavigationHelper>(
             new TestGoogleURLTrackerNavigationHelper(
                 google_url_tracker_.get())),
-        reinterpret_cast<InfoBarService*>(unique_id),
+        reinterpret_cast<infobars::InfoBarManager*>(unique_id),
         unique_id);
   }
 }
 
 void GoogleURLTrackerTest::CommitNonSearch(intptr_t unique_id) {
   GoogleURLTrackerMapEntry* map_entry = GetMapEntry(unique_id);
   if (!map_entry)
     return;
 
   ExpectListeningForCommit(unique_id, false);
 
   // The infobar should be showing; otherwise the pending non-search should
   // have closed it.
   ASSERT_TRUE(map_entry->has_infobar_delegate());
 
   // The pending_id should have been reset to 0 when the non-search became
   // pending.
   EXPECT_EQ(0, map_entry->infobar_delegate()->pending_id());
 
   // Committing the navigation would close the infobar.
   map_entry->infobar_delegate()->Close(false);
 }
 
 void GoogleURLTrackerTest::CommitSearch(intptr_t unique_id,
                                         const GURL& search_url) {
   DCHECK(search_url.is_valid());
   GoogleURLTrackerNavigationHelper* nav_helper = GetNavigationHelper(unique_id);
   if (nav_helper && nav_helper->IsListeningForNavigationCommit()) {
     google_url_tracker_->OnNavigationCommitted(
-        reinterpret_cast<InfoBarService*>(unique_id), search_url);
+        reinterpret_cast<infobars::InfoBarManager*>(unique_id), search_url);
   }
 }
 
 void GoogleURLTrackerTest::CloseTab(intptr_t unique_id) {
   unique_ids_seen_.erase(unique_id);
   GoogleURLTrackerNavigationHelper* nav_helper = GetNavigationHelper(unique_id);
   if (nav_helper && nav_helper->IsListeningForTabDestruction()) {
     google_url_tracker_->OnTabClosed(nav_helper);
   } else {
     // Closing a tab with an infobar showing would close the infobar.
     GoogleURLTrackerInfoBarDelegate* delegate = GetInfoBarDelegate(unique_id);
     if (delegate)
       delegate->Close(false);
   }
 }
 
 GoogleURLTrackerMapEntry* GoogleURLTrackerTest::GetMapEntry(
     intptr_t unique_id) {
   GoogleURLTracker::EntryMap::const_iterator i =
       google_url_tracker_->entry_map_.find(
-          reinterpret_cast<InfoBarService*>(unique_id));
+          reinterpret_cast<infobars::InfoBarManager*>(unique_id));
   return (i == google_url_tracker_->entry_map_.end()) ? NULL : i->second;
 }
 
 GoogleURLTrackerInfoBarDelegate* GoogleURLTrackerTest::GetInfoBarDelegate(
     intptr_t unique_id) {
   GoogleURLTrackerMapEntry* map_entry = GetMapEntry(unique_id);
   return map_entry ? map_entry->infobar_delegate() : NULL;
 }
 
 GoogleURLTrackerNavigationHelper* GoogleURLTrackerTest::GetNavigationHelper(
@@ skipping 12 matching lines @@
   GoogleURLTrackerMapEntry* map_entry = GetMapEntry(unique_id);
   if (map_entry) {
     EXPECT_EQ(listening,
               map_entry->navigation_helper()->IsListeningForNavigationCommit());
   } else {
     EXPECT_FALSE(listening);
   }
 }
 
 infobars::InfoBar* GoogleURLTrackerTest::CreateTestInfoBar(
-    InfoBarService* infobar_service,
+    infobars::InfoBarManager* infobar_manager,
     GoogleURLTracker* google_url_tracker,
     const GURL& search_url) {
-  return TestInfoBarDelegate::Create(this, infobar_service, google_url_tracker,
-                                     search_url);
+  return TestInfoBarDelegate::Create(
+      this, infobar_manager, google_url_tracker, search_url);
 }
 
 
 // TestInfoBarDelegate --------------------------------------------------------
 
 namespace {
 
 // static
 infobars::InfoBar* TestInfoBarDelegate::Create(
     GoogleURLTrackerTest* test_harness,
-    InfoBarService* infobar_service,
+    infobars::InfoBarManager* infobar_manager,
     GoogleURLTracker* google_url_tracker,
     const GURL& search_url) {
   return ConfirmInfoBarDelegate::CreateInfoBar(
       scoped_ptr<ConfirmInfoBarDelegate>(new TestInfoBarDelegate(
-          test_harness, infobar_service, google_url_tracker,
+          test_harness,
+          infobar_manager,
+          google_url_tracker,
           search_url))).release();
 }
 
-TestInfoBarDelegate::TestInfoBarDelegate(GoogleURLTrackerTest* test_harness,
-                                         InfoBarService* infobar_service,
-                                         GoogleURLTracker* google_url_tracker,
-                                         const GURL& search_url)
-  : GoogleURLTrackerInfoBarDelegate(google_url_tracker, search_url),
-    test_harness_(test_harness),
-    infobar_service_(infobar_service) {
+TestInfoBarDelegate::TestInfoBarDelegate(
+    GoogleURLTrackerTest* test_harness,
+    infobars::InfoBarManager* infobar_manager,
+    GoogleURLTracker* google_url_tracker,
+    const GURL& search_url)
+    : GoogleURLTrackerInfoBarDelegate(google_url_tracker,
+                                      search_url),
+      test_harness_(test_harness),
+      infobar_manager_(infobar_manager) {
 }
 
 TestInfoBarDelegate::~TestInfoBarDelegate() {
 }
 
 void TestInfoBarDelegate::Update(const GURL& search_url) {
   set_search_url(search_url);
   set_pending_id(0);
 }
 
 void TestInfoBarDelegate::Close(bool redo_search) {
   test_harness_->OnInfoBarClosed(scoped_ptr<infobars::InfoBar>(infobar()),
-                                 infobar_service_);
+                                 infobar_manager_);
   // WARNING: At this point |this| has been deleted!
 }
 
 }  // namespace
 
 
 // Tests ----------------------------------------------------------------------
 
 TEST_F(GoogleURLTrackerTest, DontFetchWhenNoOneRequestsCheck) {
   ExpectDefaultURLs();
@@ skipping 572 matching lines @@
   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));
 }