Turn GoogleURLTrackerNavigationHelper(Impl) into a per-tab object.

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"
@@ skipping 15 matching lines @@
 #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[] =
     "https://www.google.com/searchdomaincheck?format=url&type=chrome";
 
-GoogleURLTracker::GoogleURLTracker(
-    Profile* profile,
-    scoped_ptr<GoogleURLTrackerClient> client,
-    scoped_ptr<GoogleURLTrackerNavigationHelper> nav_helper,
-    Mode mode)
+GoogleURLTracker::GoogleURLTracker(Profile* profile,
+                                   scoped_ptr<GoogleURLTrackerClient> client,
+                                   Mode mode)
     : profile_(profile),
       client_(client.Pass()),
-      nav_helper_(nav_helper.Pass()),
       infobar_creator_(base::Bind(&GoogleURLTrackerInfoBarDelegate::Create)),
-      google_url_(mode == UNIT_TEST_MODE ? kDefaultGoogleHomepage :
-          profile->GetPrefs()->GetString(prefs::kLastKnownGoogleURL)),
+      google_url_(mode == UNIT_TEST_MODE ? kDefaultGoogleHomepage
+                                         : profile->GetPrefs()->GetString(
+                                               prefs::kLastKnownGoogleURL)),

[Peter Kasting, 2014/05/15 21:29:52]

Nit: Wrap like this:

      google_url_((mode == UNIT_TEST_MODE) ?
          kDefaultGoogleHomepage :
          profile->GetPrefs()->GetString(prefs::kLastKnownGoogleURL)),

[blundell, 2014/05/16 11:54:18]

Done.

       fetcher_id_(0),
       in_startup_sleep_(true),
       already_fetched_(false),
       need_to_fetch_(false),
       need_to_prompt_(false),
       search_committed_(false),
       weak_ptr_factory_(this) {
   net::NetworkChangeNotifier::AddIPAddressObserver(this);
   client_->set_google_url_tracker(this);
-  nav_helper_->SetGoogleURLTracker(this);
 
   // Because this function can be called during startup, when kicking off a URL
   // fetch can eat up 20 ms of time, we delay five seconds, which is hopefully
   // long enough to be after startup, but still get results back quickly.
   // Ideally, instead of this timer, we'd do something like "check if the
   // browser is starting up, and if so, come back later", but there is currently
   // no function to do this.
   //
   // In UNIT_TEST mode, where we want to explicitly control when the tracker
   // "wakes up", we do nothing at all.
@@ skipping 132 matching lines @@
   }
 }
 
 void GoogleURLTracker::OnIPAddressChanged() {
   already_fetched_ = false;
   StartFetchIfDesirable();
 }
 
 void GoogleURLTracker::Shutdown() {
   client_.reset();
-  nav_helper_.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
   // dereference it!  See OnTabClosed().
   EntryMap::iterator i(entry_map_.find(infobar_service));
@@ skipping 55 matching lines @@
   if (need_to_prompt_) {
     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(
-    content::NavigationController* navigation_controller,
+    GoogleURLTrackerNavigationHelper* nav_helper,
     InfoBarService* infobar_service,
     int pending_id) {
   EntryMap::iterator i(entry_map_.find(infobar_service));
 
   if (search_committed_) {
     search_committed_ = false;
     // 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 (!nav_helper_->IsListeningForNavigationCommit(navigation_controller)) {
-      nav_helper_->SetListeningForNavigationCommit(navigation_controller,
-                                                   true);
+    if (!nav_helper->IsListeningForNavigationCommit()) {
+      nav_helper->SetListeningForNavigationCommit(true);
     }
     if (i == entry_map_.end()) {
       // 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.
-      nav_helper_->SetListeningForTabDestruction(navigation_controller, true);
+      nav_helper->SetListeningForTabDestruction(true);
       entry_map_.insert(std::make_pair(
           infobar_service,
-          new GoogleURLTrackerMapEntry(this, infobar_service,
-                                       navigation_controller)));
+          new GoogleURLTrackerMapEntry(this, infobar_service, nav_helper)));
     } else if (i->second->has_infobar_delegate()) {
       // This is a new search on a tab where we already have an infobar.
       i->second->infobar_delegate()->set_pending_id(pending_id);
     }
   } else if (i != entry_map_.end()){
     if (i->second->has_infobar_delegate()) {
       // This is a non-search navigation on a tab with an infobar.  If there was
       // a previous pending search on this tab, this means it won't commit, so
       // undo anything we did in response to seeing that.  Note that if there
       // was no pending search on this tab, these statements are effectively a
@@ skipping 32 matching lines @@
     if (infobar) {
       map_entry->SetInfoBarDelegate(
           static_cast<GoogleURLTrackerInfoBarDelegate*>(infobar->delegate()));
     } else {
       map_entry->Close(false);
     }
   }
 }
 
 void GoogleURLTracker::OnTabClosed(
-    content::NavigationController* navigation_controller) {
+    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
   // 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
   // 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_controller() == navigation_controller) {
+    if (i->second->navigation_helper() == nav_helper) {
       i->second->Close(false);
       return;
     }
   }
   NOTREACHED();
 }
 
 void GoogleURLTracker::CloseAllEntries(bool redo_searches) {
   // Delete all entries, whether they have infobars or not.
   while (!entry_map_.empty())
     entry_map_.begin()->second->Close(redo_searches);
 }
 
 void GoogleURLTracker::UnregisterForEntrySpecificNotifications(
-    const GoogleURLTrackerMapEntry& map_entry,
+    GoogleURLTrackerMapEntry& map_entry,
     bool must_be_listening_for_commit) {
   // For tabs with map entries but no infobars, we should always be listening
   // for both these notifications.  For tabs with infobars, we may be listening
   // for navigation commits if the user has performed a new search on this tab.
-  if (nav_helper_->IsListeningForNavigationCommit(
-          map_entry.navigation_controller())) {
-    nav_helper_->SetListeningForNavigationCommit(
-        map_entry.navigation_controller(), false);
+  if (map_entry.navigation_helper()->IsListeningForNavigationCommit()) {

[blundell, 2014/05/15 15:24:14]

This is the core of the change: rather than there being one NavHelper to which
GoogleURLTracker passes the NavigationController of the tab in question, there
is a NavHelper for each tab and GoogleURLTracker directly calls the one of the
tab in question.

+    map_entry.navigation_helper()->SetListeningForNavigationCommit(false);
   } else {
     DCHECK(!must_be_listening_for_commit);
     DCHECK(map_entry.has_infobar_delegate());
   }
   const bool registered_for_tab_destruction =
-      nav_helper_->IsListeningForTabDestruction(
-          map_entry.navigation_controller());
+      map_entry.navigation_helper()->IsListeningForTabDestruction();
   DCHECK_NE(registered_for_tab_destruction, map_entry.has_infobar_delegate());
   if (registered_for_tab_destruction) {
-    nav_helper_->SetListeningForTabDestruction(
-        map_entry.navigation_controller(), false);
+    map_entry.navigation_helper()->SetListeningForTabDestruction(false);
   }
 
   // Our global listeners for these other notifications should be in place iff
   // we have any tabs still listening for commits.  These tabs either have no
   // infobars or have received new pending searches atop existing infobars; in
   // either case we want to catch subsequent pending non-search navigations.
   // See the various cases inside OnNavigationPending().
   for (EntryMap::const_iterator i(entry_map_.begin()); i != entry_map_.end();
        ++i) {
-    if (nav_helper_->IsListeningForNavigationCommit(
-            i->second->navigation_controller())) {
+    if (i->second->navigation_helper()->IsListeningForNavigationCommit()) {
       DCHECK(client_->IsListeningForNavigationStart());
       return;
     }
   }
   if (client_->IsListeningForNavigationStart()) {
     DCHECK(!search_committed_);
     client_->SetListeningForNavigationStart(false);
   }
 }