Move most of the component updater artifacts to update_client.

components/component_updater/component_updater_service.h

 // Copyright 2014 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 COMPONENTS_COMPONENT_UPDATER_COMPONENT_UPDATER_SERVICE_H_
 #define COMPONENTS_COMPONENT_UPDATER_COMPONENT_UPDATER_SERVICE_H_
 
 #include <stdint.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;
 class SupervisedUserWhitelistService;
 
 namespace base {
 class DictionaryValue;
 class FilePath;
 class SequencedTaskRunner;
 }
 
+namespace content {
+class ResourceThrottle;
+}
+
 namespace net {
 class URLRequestContextGetter;
 class URLRequest;
 }
 
-namespace content {
-class ResourceThrottle;
+namespace update_client {
+class ComponentInstaller;
+class Configurator;
+struct CrxComponent;
+struct CrxUpdateItem;
 }
 
 namespace component_updater {
 
-class Configurator;
 class OnDemandUpdater;
 
-// Component specific installers must derive from this class and implement
-// OnUpdateError() and Install(). A valid instance of this class must be
-// given to ComponentUpdateService::RegisterComponent().
-class ComponentInstaller {
- public:
-  // Called by the component updater on the main thread when there was a
-  // problem unpacking or verifying the component. |error| is a non-zero
-  // value which is only meaningful to the component updater.
-  virtual void OnUpdateError(int error) = 0;
-
-  // Called by the component updater when a component has been unpacked
-  // and is ready to be installed. |manifest| contains the CRX manifest
-  // json dictionary and |unpack_path| contains the temporary directory
-  // with all the unpacked CRX files. This method may be called from
-  // a thread other than the main thread.
-  virtual bool Install(const base::DictionaryValue& manifest,
-                       const base::FilePath& unpack_path) = 0;
-
-  // Set |installed_file| to the full path to the installed |file|. |file| is
-  // the filename of the file in this component's CRX. Returns false if this is
-  // not possible (the file has been removed or modified, or its current
-  // location is unknown). Otherwise, returns true.
-  virtual bool GetInstalledFile(const std::string& file,
-                                base::FilePath* installed_file) = 0;
-
-  virtual ~ComponentInstaller() {}
-};
-
-// Describes a particular component that can be installed or updated. This
-// structure is required to register a component with the component updater.
-// |pk_hash| is the SHA256 hash of the component's public key. If the component
-// is to be installed then version should be "0" or "0.0", else it should be
-// the current version. |fingerprint|, and |name| are optional.
-// |allow_background_download| specifies that the component can be background
-// downloaded in some cases. The default for this value is |true| and the value
-// can be overriden at the registration time. This is a temporary change until
-// the issue 340448 is resolved.
-struct CrxComponent {
-  std::vector<uint8_t> pk_hash;
-  ComponentInstaller* installer;
-  Version version;
-  std::string fingerprint;
-  std::string name;
-  bool allow_background_download;
-  CrxComponent();
-  ~CrxComponent();
-};
-
-struct CrxUpdateItem;
-
 // The component update service is in charge of installing or upgrading
 // select parts of chrome. Each part is called a component and managed by
 // instances of CrxComponent registered using RegisterComponent(). On the
 // server, each component is packaged as a CRX which is the same format used
 // to package extensions. To the update service each component is identified
 // by its public key hash (CrxComponent::pk_hash). If there is an update
 // available and its version is bigger than (CrxComponent::version), it will
 // be downloaded, verified and unpacked. Then component-specific installer
 // ComponentInstaller::Install (of CrxComponent::installer) will be called.
 //
@@ skipping 57 matching lines @@
   // Start doing update checks and installing new versions of registered
   // components after Configurator::InitialDelay() seconds.
   virtual Status Start() = 0;
 
   // Stop doing update checks. In-flight requests and pending installations
   // 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;
+  virtual Status RegisterComponent(
+      const update_client::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;
 
   // This method is used to trigger an on-demand update for component |crx_id|.
   // This can be used when loading a resource that depends on this component.
@@ skipping 11 matching lines @@
                              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:
   // 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;
+  virtual bool GetComponentDetails(
+      const std::string& component_id,
+      update_client::CrxUpdateItem* item) const = 0;
 
   friend class ::ComponentsUI;
 };
 
 typedef ComponentUpdateService::Observer ServiceObserver;
 
 class OnDemandUpdater {
  public:
   virtual ~OnDemandUpdater() {}
 
  private:
   friend class OnDemandTester;
   friend class SupervisedUserWhitelistInstaller;
   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;
 };
 
 // Creates the component updater. You must pass a valid |config| allocated on
 // the heap which the component updater will own.
-ComponentUpdateService* ComponentUpdateServiceFactory(Configurator* config);
+ComponentUpdateService* ComponentUpdateServiceFactory(
+    update_client::Configurator* config);
 
 }  // namespace component_updater
 
 #endif  // COMPONENTS_COMPONENT_UPDATER_COMPONENT_UPDATER_SERVICE_H_