Revert of Rate limit programmatic update checks for extensions

chrome/browser/extensions/updater/extension_updater.h

 // 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_UPDATER_EXTENSION_UPDATER_H_
 #define CHROME_BROWSER_EXTENSIONS_UPDATER_EXTENSION_UPDATER_H_
 
 #include <list>
 #include <map>
 #include <memory>
@@ skipping 38 matching lines @@
 // ExtensionUpdater* updater = new ExtensionUpdater(my_extensions_service,
 //                                                  extension_prefs,
 //                                                  pref_service,
 //                                                  profile,
 //                                                  update_frequency_secs,
 //                                                  downloader_factory);
 // updater->Start();
 // ....
 // updater->Stop();
 class ExtensionUpdater : public ExtensionDownloaderDelegate,
+                         public ExtensionRegistryObserver,
                          public content::NotificationObserver {
  public:
   typedef base::Closure FinishedCallback;
 
   struct CheckParams {
     // Creates a default CheckParams instance that checks for all extensions.
     CheckParams();
     ~CheckParams();
 
     // The set of extensions that should be checked for updates. If empty
@@ skipping 27 matching lines @@
   void Start();
 
   // Stops the updater running, cancelling any outstanding update manifest and
   // crx downloads. Does not cancel any in-progress installs.
   void Stop();
 
   // Posts a task to do an update check.  Does nothing if there is
   // already a pending task that has not yet run.
   void CheckSoon();
 
-  // Starts an update check for the specified extension soon.
-  void CheckExtensionSoon(const std::string& extension_id,
+  // Starts an update check for the specified extension soon. If a check
+  // is already running, or finished too recently without an update being
+  // installed, this method returns false and the check won't be scheduled.
+  bool CheckExtensionSoon(const std::string& extension_id,
                           const FinishedCallback& callback);
 
   // Starts an update check right now, instead of waiting for the next
   // regularly scheduled check or a pending check from CheckSoon().
   void CheckNow(const CheckParams& params);
 
   // Returns true iff CheckSoon() has been called but the update check
   // hasn't been performed yet.  This is used mostly by tests; calling
   // code should just call CheckSoon().
   bool WillCheckSoon() const;
@@ skipping 30 matching lines @@
     InProgressCheck();
     InProgressCheck(const InProgressCheck& other);
     ~InProgressCheck();
 
     bool install_immediately;
     FinishedCallback callback;
     // The ids of extensions that have in-progress update checks.
     std::list<std::string> in_progress_ids_;
   };
 
+  struct ThrottleInfo;
+
   // Ensure that we have a valid ExtensionDownloader instance referenced by
   // |downloader|.
   void EnsureDownloaderCreated();
 
   // Computes when to schedule the first update check.
   base::TimeDelta DetermineFirstCheckDelay();
 
   // Sets the timer to call TimerFired after roughly |target_delay| from now.
   // To help spread load evenly on servers, this method adds some random
   // jitter. It also saves the scheduled time so it can be reloaded on
@@ skipping 34 matching lines @@
   void UpdatePingData(const std::string& id, const PingResult& ping_result);
 
   // Starts installing a crx file that has been fetched but not installed yet.
   void MaybeInstallCRXFile();
 
   // content::NotificationObserver implementation.
   void Observe(int type,
                const content::NotificationSource& source,
                const content::NotificationDetails& details) override;
 
+  // Implementation of ExtensionRegistryObserver.
+  void OnExtensionWillBeInstalled(content::BrowserContext* browser_context,
+                                  const Extension* extension,
+                                  bool is_update,
+                                  const std::string& old_name) override;
+
   // Send a notification that update checks are starting.
   void NotifyStarted();
 
   // Send a notification if we're finished updating.
   void NotifyIfFinished(int request_id);
 
   void ExtensionCheckFinished(const std::string& extension_id,
                               const FinishedCallback& callback);
 
   // Whether Start() has been called but not Stop().
@@ skipping 16 matching lines @@
   ExtensionPrefs* extension_prefs_;
   PrefService* prefs_;
   Profile* profile_;
 
   std::map<int, InProgressCheck> requests_in_progress_;
   int next_request_id_;
 
   // Observes CRX installs we initiate.
   content::NotificationRegistrar registrar_;
 
+  ScopedObserver<ExtensionRegistry, ExtensionRegistryObserver>
+      extension_registry_observer_;
+
   // True when a CrxInstaller is doing an install.  Used in MaybeUpdateCrxFile()
   // to keep more than one install from running at once.
   bool crx_install_is_running_;
 
   // Fetched CRX files waiting to be installed.
   std::stack<FetchedCRXFile> fetched_crx_files_;
   FetchedCRXFile current_crx_file_;
 
   ExtensionCache* extension_cache_;
 
+  // Keeps track of when an extension tried to update itself, so we can throttle
+  // checks to prevent too many requests from being made.
+  std::map<std::string, ThrottleInfo> throttle_info_;
+
   base::WeakPtrFactory<ExtensionUpdater> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionUpdater);
 };
 
 }  // namespace extensions
 
 #endif  // CHROME_BROWSER_EXTENSIONS_UPDATER_EXTENSION_UPDATER_H_