Eliminate dependence of GoogleURLTracker et al. on InfoBarService

chrome/browser/google/google_url_tracker.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/google/google_url_tracker_factory.h"
 #include "chrome/browser/google/google_url_tracker_infobar_delegate.h"
 #include "chrome/browser/google/google_url_tracker_navigation_helper.h"
 #include "chrome/browser/google/google_util.h"
-#include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/pref_names.h"
 #include "components/google/core/browser/google_url_tracker_client.h"
 #include "components/infobars/core/infobar.h"
-#include "content/public/browser/navigation_controller.h"
-#include "content/public/browser/navigation_entry.h"
+#include "components/infobars/core/infobar_manager.h"
 #include "content/public/browser/notification_service.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_util.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_request_status.h"
 
 
 const char GoogleURLTracker::kDefaultGoogleHomepage[] =
     "http://www.google.com/";
 const char GoogleURLTracker::kSearchDomainCheckURL[] =
@@ skipping 167 matching lines @@
   StartFetchIfDesirable();
 }
 
 void GoogleURLTracker::Shutdown() {
   client_.reset();
   fetcher_.reset();
   weak_ptr_factory_.InvalidateWeakPtrs();
   net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
 }
 
-void GoogleURLTracker::DeleteMapEntryForService(
-    const InfoBarService* infobar_service) {
-  // WARNING: |infobar_service| may point to a deleted object.  Do not
+void GoogleURLTracker::DeleteMapEntryForManager(
+    const infobars::InfoBarManager* infobar_manager) {
+  // WARNING: |infobar_manager| may point to a deleted object.  Do not
   // dereference it!  See OnTabClosed().
-  EntryMap::iterator i(entry_map_.find(infobar_service));
+  EntryMap::iterator i(entry_map_.find(infobar_manager));
   DCHECK(i != entry_map_.end());
   GoogleURLTrackerMapEntry* map_entry = i->second;
 
   UnregisterForEntrySpecificNotifications(map_entry, false);
   entry_map_.erase(i);
   delete map_entry;
 }
 
 void GoogleURLTracker::SetNeedToFetch() {
   need_to_fetch_ = true;
@@ skipping 46 matching lines @@
     search_committed_ = true;
     // These notifications will fire a bit later in the same call chain we're
     // currently in.
     if (!client_->IsListeningForNavigationStart())
       client_->SetListeningForNavigationStart(true);
   }
 }
 
 void GoogleURLTracker::OnNavigationPending(
     scoped_ptr<GoogleURLTrackerNavigationHelper> nav_helper,
-    InfoBarService* infobar_service,
+    infobars::InfoBarManager* infobar_manager,
     int pending_id) {
   GoogleURLTrackerMapEntry* map_entry = NULL;
 
-  EntryMap::iterator i(entry_map_.find(infobar_service));
+  EntryMap::iterator i(entry_map_.find(infobar_manager));
   if (i != entry_map_.end())
     map_entry = i->second;
 
   if (search_committed_) {
     search_committed_ = false;
     if (!map_entry) {
       // This is a search on a tab that doesn't have one of our infobars, so
       // prepare to add one.  Note that we only listen for the tab's destruction
       // on this path; if there was already a map entry, then either it doesn't
       // yet have an infobar and we're already registered for this, or it has an
       // infobar and the infobar's owner will handle tearing it down when the
       // tab is destroyed.
       map_entry = new GoogleURLTrackerMapEntry(
-          this, infobar_service, nav_helper.Pass());
+          this, infobar_manager, nav_helper.Pass());
       map_entry->navigation_helper()->SetListeningForTabDestruction(true);
-      entry_map_.insert(std::make_pair(infobar_service, map_entry));
+      entry_map_.insert(std::make_pair(infobar_manager, map_entry));
     } else if (map_entry->infobar_delegate()) {
       // This is a new search on a tab where we already have an infobar.
       map_entry->infobar_delegate()->set_pending_id(pending_id);
     }
 
     // Whether there's an existing infobar or not, we need to listen for the
     // load to commit, so we can show and/or update the infobar when it does.
     // (We may already be registered for this if there is an existing infobar
     // that had a previous pending search that hasn't yet committed.)
     if (!map_entry->navigation_helper()->IsListeningForNavigationCommit())
@@ skipping 16 matching lines @@
       // an infobar.  This means the original search won't commit, so delete the
       // entry.
       map_entry->Close(false);
     }
   } else {
     // Non-search navigation on a tab without an infobars.  This is irrelevant
     // to us.
   }
 }
 
-void GoogleURLTracker::OnNavigationCommitted(InfoBarService* infobar_service,
-                                             const GURL& search_url) {
-  EntryMap::iterator i(entry_map_.find(infobar_service));
+void GoogleURLTracker::OnNavigationCommitted(
+    infobars::InfoBarManager* infobar_manager,
+    const GURL& search_url) {
+  EntryMap::iterator i(entry_map_.find(infobar_manager));
   DCHECK(i != entry_map_.end());
   GoogleURLTrackerMapEntry* map_entry = i->second;
   DCHECK(search_url.is_valid());
 
   UnregisterForEntrySpecificNotifications(map_entry, true);
   if (map_entry->has_infobar_delegate()) {
     map_entry->infobar_delegate()->Update(search_url);
   } else {
-    infobars::InfoBar* infobar =
-        infobar_creator_.Run(infobar_service, this, search_url);
+    infobars::InfoBar* infobar = infobar_creator_.Run(
+        infobar_manager, this, map_entry->navigation_helper(), search_url);
     if (infobar) {
       map_entry->SetInfoBarDelegate(
           static_cast<GoogleURLTrackerInfoBarDelegate*>(infobar->delegate()));
     } else {
       map_entry->Close(false);
     }
   }
 }
 
 void GoogleURLTracker::OnTabClosed(
     GoogleURLTrackerNavigationHelper* nav_helper) {
-  // Because InfoBarService tears itself down on tab destruction, it's possible
-  // to get a non-NULL InfoBarService pointer here, depending on which order
+  // Because InfoBarManager tears itself down on tab destruction, it's possible
+  // to get a non-NULL InfoBarManager pointer here, depending on which order
   // notifications fired in.  Likewise, the pointer in |entry_map_| (and in its
-  // associated MapEntry) may point to deleted memory.  Therefore, if we were to
-  // access the InfoBarService* we have for this tab, we'd need to ensure we
+  // associated MapEntry) may point to deleted memory.  Therefore, if we were
+  // to access the InfoBarManager* we have for this tab, we'd need to ensure we
   // just looked at the raw pointer value, and never dereferenced it.  This
   // function doesn't need to do even that, but others in the call chain from
   // here might (and have comments pointing back here).
   for (EntryMap::iterator i(entry_map_.begin()); i != entry_map_.end(); ++i) {
     if (i->second->navigation_helper() == nav_helper) {
       i->second->Close(false);
       return;
     }
   }
   NOTREACHED();
@@ skipping 34 matching lines @@
     if (i->second->navigation_helper()->IsListeningForNavigationCommit()) {
       DCHECK(client_->IsListeningForNavigationStart());
       return;
     }
   }
   if (client_->IsListeningForNavigationStart()) {
     DCHECK(!search_committed_);
     client_->SetListeningForNavigationStart(false);
   }
 }