Create GoogleURLTrackerClient interface and //chrome implementation

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 "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[] =
     "https://www.google.com/searchdomaincheck?format=url&type=chrome";
 
 GoogleURLTracker::GoogleURLTracker(
     Profile* profile,
+    scoped_ptr<GoogleURLTrackerClient> client,
     scoped_ptr<GoogleURLTrackerNavigationHelper> nav_helper,
     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)),
       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_->SetGoogleURLTracker(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
@@ skipping 132 matching lines @@
       CloseAllEntries(false);
   }
 }
 
 void GoogleURLTracker::OnIPAddressChanged() {
   already_fetched_ = false;
   StartFetchIfDesirable();
 }
 
 void GoogleURLTracker::Shutdown() {
+  client_.reset();
   nav_helper_.reset();
   fetcher_.reset();
   weak_ptr_factory_.InvalidateWeakPtrs();

[Peter Kasting, 2014/05/14 23:30:28]

Why are the four lines above necessary?

[blundell, 2014/05/15 07:58:03]

I'm not familiar with this code. For KeyedServices, the general pattern is to
tear down state in Shutdown(). I'd prefer to avoid changing this code in this
CL.

On 2014/05/14 23:30:28, Peter Kasting wrote:

[Peter Kasting, 2014/05/15 21:19:21]

Ah, I overlooked that this is Shutdown() instead of the destructor.  I still
think we could remove some of these, but I'm not as worried in that case.

   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));
   DCHECK(i != entry_map_.end());
   GoogleURLTrackerMapEntry* map_entry = i->second;
@@ skipping 47 matching lines @@
   fetcher_->SetMaxRetriesOn5xx(kMaxRetries);
 
   fetcher_->Start();
 }
 
 void GoogleURLTracker::SearchCommitted() {
   if (need_to_prompt_) {
     search_committed_ = true;
     // These notifications will fire a bit later in the same call chain we're
     // currently in.
-    if (!nav_helper_->IsListeningForNavigationStart())
-      nav_helper_->SetListeningForNavigationStart(true);
+    if (!client_->IsListeningForNavigationStart())
+      client_->SetListeningForNavigationStart(true);
   }
 }
 
 void GoogleURLTracker::OnNavigationPending(
     content::NavigationController* navigation_controller,
     InfoBarService* infobar_service,
     int pending_id) {
   EntryMap::iterator i(entry_map_.find(infobar_service));
 
   if (search_committed_) {
@@ skipping 119 matching lines @@
 
   // 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())) {
-      DCHECK(nav_helper_->IsListeningForNavigationStart());
+      DCHECK(client_->IsListeningForNavigationStart());
       return;
     }
   }
-  if (nav_helper_->IsListeningForNavigationStart()) {
+  if (client_->IsListeningForNavigationStart()) {
     DCHECK(!search_committed_);
-    nav_helper_->SetListeningForNavigationStart(false);
+    client_->SetListeningForNavigationStart(false);
   }
 }