src/components/google/core/browser/google_url_tracker.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef COMPONENTS_GOOGLE_CORE_BROWSER_GOOGLE_URL_TRACKER_H_
   6 #define COMPONENTS_GOOGLE_CORE_BROWSER_GOOGLE_URL_TRACKER_H_
   7
   8 #include <map>
   9 #include <string>
  10 #include <utility>
  11
  12 #include "base/callback_forward.h"
  13 #include "base/callback_list.h"
  14 #include "base/gtest_prod_util.h"
  15 #include "base/memory/scoped_ptr.h"
  16 #include "base/memory/weak_ptr.h"
  17 #include "components/google/core/browser/google_url_tracker_client.h"
  18 #include "components/google/core/browser/google_url_tracker_map_entry.h"
  19 #include "components/keyed_service/core/keyed_service.h"
  20 #include "net/base/network_change_notifier.h"
  21 #include "net/url_request/url_fetcher.h"
  22 #include "net/url_request/url_fetcher_delegate.h"
  23 #include "url/gurl.h"
  24
  25 class GoogleURLTrackerNavigationHelper;
  26 class PrefService;
  27
  28 namespace infobars {
  29 class InfoBar;
  30 }
  31
  32 // This object is responsible for checking the Google URL once per network
  33 // change, and if necessary prompting the user to see if they want to change to
  34 // using it.  The current and last prompted values are saved to prefs.
  35 //
  36 // Most consumers should only call google_url().  Consumers who need to be
  37 // notified when things change should register a callback that provides the
  38 // original and updated values via RegisterCallback().
  39 //
  40 // To protect users' privacy and reduce server load, no updates will be
  41 // performed (ever) unless at least one consumer registers interest by calling
  42 // RequestServerCheck().
  43 class GoogleURLTracker
  44     : public net::URLFetcherDelegate,
  45       public net::NetworkChangeNotifier::NetworkChangeObserver,
  46       public KeyedService {
  47  public:
  48   // Callback that is called when the Google URL is updated. The arguments are
  49   // the old and new URLs.
  50   typedef base::Callback<void()> OnGoogleURLUpdatedCallback;
  51   typedef base::CallbackList<void()> CallbackList;
  52   typedef CallbackList::Subscription Subscription;
  53
  54   // The constructor does different things depending on which of these values
  55   // you pass it.  Hopefully these are self-explanatory.
  56   enum Mode {
  57     NORMAL_MODE,
  58     UNIT_TEST_MODE,
  59   };
  60
  61   static const char kDefaultGoogleHomepage[];
  62
  63   // Only the GoogleURLTrackerFactory and tests should call this.
  64   GoogleURLTracker(scoped_ptr<GoogleURLTrackerClient> client, Mode mode);
  65
  66   ~GoogleURLTracker() override;
  67
  68   // Returns the current Google homepage URL.
  69   const GURL& google_url() const { return google_url_; }
  70
  71   // Requests that the tracker perform a server check to update the Google URL
  72   // as necessary.  If |force| is false, this will happen at most once per
  73   // network change, not sooner than five seconds after startup (checks
  74   // requested before that time will occur then; checks requested afterwards
  75   // will occur immediately, if no other checks have been made during this run).
  76   // If |force| is true, and the tracker has already performed any requested
  77   // check, it will check again.
  78   void RequestServerCheck(bool force);
  79
  80   // Notifies the tracker that the user has started a Google search.
  81   // If prompting is necessary, we then listen for the subsequent pending
  82   // navigation to get the appropriate NavigationHelper. When the load
  83   // commits, we'll show the infobar.
  84   void SearchCommitted();
  85
  86   // No one but GoogleURLTrackerInfoBarDelegate or test code should call these.
  87   void AcceptGoogleURL(bool redo_searches);
  88   void CancelGoogleURL();
  89   const GURL& fetched_google_url() const { return fetched_google_url_; }
  90   GoogleURLTrackerClient* client() { return client_.get(); }
  91
  92   // No one but GoogleURLTrackerMapEntry should call this.
  93   void DeleteMapEntryForManager(
  94       const infobars::InfoBarManager* infobar_manager);
  95
  96   // Called by the client after SearchCommitted() registers listeners,
  97   // to indicate that we've received the "load now pending" notification.
  98   // |nav_helper| is the GoogleURLTrackerNavigationHelper associated with this
  99   // navigation; |infobar_manager| is the InfoBarManager of the associated tab;
 100   // and |pending_id| is the unique ID of the newly pending NavigationEntry.
 101   // If there is already a visible GoogleURLTracker infobar for this tab, this
 102   // function resets its associated pending entry ID to the new ID.  Otherwise
 103   // this function creates a map entry for the associated tab.
 104   virtual void OnNavigationPending(
 105       scoped_ptr<GoogleURLTrackerNavigationHelper> nav_helper,
 106       infobars::InfoBarManager* infobar_manager,
 107       int pending_id);
 108
 109   // Called by the navigation observer once a load we're watching commits.
 110   // |infobar_manager| is the same as for OnNavigationPending();
 111   // |search_url| is guaranteed to be valid.
 112   virtual void OnNavigationCommitted(infobars::InfoBarManager* infobar_manager,
 113                                      const GURL& search_url);
 114
 115   // Called by the navigation observer when a tab closes.
 116   virtual void OnTabClosed(GoogleURLTrackerNavigationHelper* nav_helper);
 117
 118   scoped_ptr<Subscription> RegisterCallback(
 119       const OnGoogleURLUpdatedCallback& cb);
 120
 121  private:
 122   friend class GoogleURLTrackerTest;
 123   friend class SyncTest;
 124
 125   typedef std::map<const infobars::InfoBarManager*, GoogleURLTrackerMapEntry*>
 126       EntryMap;
 127
 128   static const char kSearchDomainCheckURL[];
 129
 130   // net::URLFetcherDelegate:
 131   void OnURLFetchComplete(const net::URLFetcher* source) override;
 132
 133   // NetworkChangeNotifier::IPAddressObserver:
 134   void OnNetworkChanged(
 135       net::NetworkChangeNotifier::ConnectionType type) override;
 136
 137   // KeyedService:
 138   void Shutdown() override;
 139
 140   // Registers consumer interest in getting an updated URL from the server.
 141   // Observe chrome::NOTIFICATION_GOOGLE_URL_UPDATED to be notified when the URL
 142   // changes.
 143   void SetNeedToFetch();
 144
 145   // Called when the five second startup sleep has finished.  Runs any pending
 146   // fetch.
 147   void FinishSleep();
 148
 149   // Starts the fetch of the up-to-date Google URL if we actually want to fetch
 150   // it and can currently do so.
 151   void StartFetchIfDesirable();
 152
 153   // Closes all map entries.  If |redo_searches| is true, this also triggers
 154   // each tab with an infobar to re-perform the user's search, but on the new
 155   // Google TLD.
 156   void CloseAllEntries(bool redo_searches);
 157
 158   // Unregisters any listeners for the navigation helper in |map_entry|.
 159   // This sanity-DCHECKs that these are registered (or not) in the specific
 160   // cases we expect.  (|must_be_listening_for_commit| is used purely for this
 161   // sanity-checking.)  This also unregisters the global navigation pending
 162   // listener if there are no remaining listeners for navigation commits, as we
 163   // no longer need them until another search is committed.
 164   void UnregisterForEntrySpecificNotifications(
 165       GoogleURLTrackerMapEntry* map_entry,
 166       bool must_be_listening_for_commit);
 167
 168   void NotifyGoogleURLUpdated();
 169
 170   CallbackList callback_list_;
 171
 172   scoped_ptr<GoogleURLTrackerClient> client_;
 173
 174   GURL google_url_;
 175   GURL fetched_google_url_;
 176   scoped_ptr<net::URLFetcher> fetcher_;
 177   int fetcher_id_;
 178   bool in_startup_sleep_;  // True if we're in the five-second "no fetching"
 179                            // period that begins at browser start.
 180   bool already_fetched_;   // True if we've already fetched a URL once this run;
 181                            // we won't fetch again until after a restart.
 182   bool need_to_fetch_;     // True if a consumer actually wants us to fetch an
 183                            // updated URL.  If this is never set, we won't
 184                            // bother to fetch anything.
 185                            // Consumers should register a callback via
 186                            // RegisterCallback().
 187   bool need_to_prompt_;    // True if the last fetched Google URL is not
 188                            // matched with current user's default Google URL
 189                            // nor the last prompted Google URL.
 190   bool search_committed_;  // True when we're expecting a notification of a new
 191                            // pending search navigation.
 192   EntryMap entry_map_;
 193   base::WeakPtrFactory<GoogleURLTracker> weak_ptr_factory_;
 194
 195   DISALLOW_COPY_AND_ASSIGN(GoogleURLTracker);
 196 };
 197
 198 #endif  // COMPONENTS_GOOGLE_CORE_BROWSER_GOOGLE_URL_TRACKER_H_