Componentize component_updater: Split content::ResourceThrottle from CUS.

chrome/browser/component_updater/component_updater_service.h

 // Copyright 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_COMPONENT_UPDATER_COMPONENT_UPDATER_SERVICE_H_
 #define CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_UPDATER_SERVICE_H_
 
 #include <string>
 #include <vector>
 
+#include "base/callback_forward.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/version.h"
 #include "url/gurl.h"
 
 class ComponentsUI;
 
 namespace base {
 class DictionaryValue;
 class FilePath;
@@ skipping 139 matching lines @@
   // will not be canceled.
   virtual Status Stop() = 0;
 
   // Add component to be checked for updates. You can call this method
   // before calling Start().
   virtual Status RegisterComponent(const CrxComponent& component) = 0;
 
   // Returns a list of registered components.
   virtual std::vector<std::string> GetComponentIDs() const = 0;
 
-  // Returns an interface for on-demand updates. On-demand updates are
-  // proactively triggered outside the normal component update service schedule.
-  virtual OnDemandUpdater& GetOnDemandUpdater() = 0;
+  // |callback| is called on the main thread once the component with |crx_id|
+  // is downloaded and installed. |callback| may be called synchronously
+  // if component is already installed. The function implements a cooldown
+  // interval of 30 minutes. That means it will ineffective to call the
+  // function before the cooldown interval has passed. This behavior is intended
+  // to be defensive against programming bugs, usually triggered by web fetches,
+  // where the on-demand functionality is invoked too often.
+  virtual void MaybeThrottle(const std::string& crx_id,
+                             const base::Closure& callback) = 0;
 
   // Returns a task runner suitable for use by component installers.
   virtual scoped_refptr<base::SequencedTaskRunner> GetSequencedTaskRunner() = 0;
 
   virtual ~ComponentUpdateService() {}
 
  private:
+  friend class OnDemandTester;
+  friend class ::ComponentsUI;
+
   // Returns details about registered component in the |item| parameter. The
   // function returns true in case of success and false in case of errors.
   virtual bool GetComponentDetails(const std::string& component_id,
                                    CrxUpdateItem* item) const = 0;
 
-  friend class ::ComponentsUI;
-  FRIEND_TEST_ALL_PREFIXES(ComponentUpdaterTest, ResourceThrottleLiveNoUpdate);
-};
-
-typedef ComponentUpdateService::Observer ServiceObserver;
-
-class OnDemandUpdater {

[Sorin Jianu, 2014/07/31 00:16:01]

The idea here is that we want to have a class, where we can add friend
declarations for other classes or functions which are allowed to invoke the
on-demand functionality. We don't want to friend the whole service class (since
the friendship is not selective once it has been granted). We do this to allow
some level of control to which components are allowed to call OnDemandUpdate. So
far no exception has been granted but many have asked for one.

We'd like to keep this class if possible.

[tommycli, 2014/07/31 18:00:04]

Done. Makes sense. I restored this class.

I left MaybeThrottle within CUS, since it makes CUResourceThrottle a bit
simpler. Let me know if you want this moved back also.

- public:
-  virtual ~OnDemandUpdater() {}
-
-  // Returns a network resource throttle. It means that a component will be
-  // downloaded and installed before the resource is unthrottled. This function
-  // can be called from the IO thread. The function implements a cooldown
-  // interval of 30 minutes. That means it will ineffective to call the
-  // function before the cooldown interval has passed. This behavior is intended
-  // to be defensive against programming bugs, usually triggered by web fetches,
-  // where the on-demand functionality is invoked too often.
-  virtual content::ResourceThrottle* GetOnDemandResourceThrottle(
-      net::URLRequest* request,
-      const std::string& crx_id) = 0;
-
- private:
-  friend class OnDemandTester;
-  friend class ::ComponentsUI;
-
   // Triggers an update check for a component. |component_id| is a value
   // returned by GetCrxComponentID(). If an update for this component is already
   // in progress, the function returns |kInProgress|. If an update is available,
   // the update will be applied. The caller can subscribe to component update
   // service notifications to get an indication about the outcome of the
   // on-demand update. The function does not implement any cooldown interval.
   virtual ComponentUpdateService::Status OnDemandUpdate(
       const std::string& component_id) = 0;
 };
 
+typedef ComponentUpdateService::Observer ServiceObserver;
+
 // Creates the component updater. You must pass a valid |config| allocated on
 // the heap which the component updater will own.
 ComponentUpdateService* ComponentUpdateServiceFactory(Configurator* config);
 
 }  // namespace component_updater
 
 #endif  // CHROME_BROWSER_COMPONENT_UPDATER_COMPONENT_UPDATER_SERVICE_H_