Implement Just-In-Time Flash updates.

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 <memory>
 #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 "components/update_client/update_client.h"
 #include "url/gurl.h"
 
 class ComponentsUI;
+class PluginObserver;
 class SupervisedUserWhitelistService;
 
 namespace base {
 class DictionaryValue;
 class FilePath;
 class SequencedTaskRunner;
 }
 
 namespace content {
 class ResourceThrottle;
@@ skipping 12 matching lines @@
 }
 
 namespace component_updater {
 
 class OnDemandUpdater;
 
 using Configurator = update_client::Configurator;
 using CrxComponent = update_client::CrxComponent;
 using CrxUpdateItem = update_client::CrxUpdateItem;
 
+struct ComponentInfo {
+  ComponentInfo();
+  ~ComponentInfo();
+
+  std::string id;
+  base::string16 name;
+};
+
 // 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 25 matching lines @@
   // existing versions of the component from disk. Returns true if the
   // uninstall has completed successfully and the component files have been
   // removed, or if the uninstalled has been deferred because the component
   // is being updated. Returns false if the component id is not known or the
   /// uninstall encountered an error.
   virtual bool UnregisterComponent(const std::string& id) = 0;
 
   // Returns a list of registered components.
   virtual std::vector<std::string> GetComponentIDs() const = 0;
 
+  // Returns true and fills the members of |info| if there is a registered
+  // component that implements a handler for the specified |mime_type|; else
+  // returns false and does not mutate the members of |info|. If multiple
+  // such components exist, returns information for the one that was most
+  // recently registered.
+  virtual bool GetComponentForMimeType(const std::string& mime_type,
+                                       ComponentInfo* info) const = 0;

[Sorin Jianu, 2016/07/28 21:04:05]

Another idea for this would be to return by value an
std::unique_ptr<ComponentInfo> or nullptr instead of bool and the comment about
not mutating |info|.

[waffles, 2016/07/28 23:05:52]

Done.

+
   // 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 |id|.
   // This can be used when loading a resource that depends on this component.
   //
   // |callback| is called on the main thread once the on-demand update is
   // complete, regardless of success. |callback| may be called immediately
   // within the method body.
@@ skipping 24 matching lines @@
 using ServiceObserver = ComponentUpdateService::Observer;
 
 class OnDemandUpdater {
  public:
   virtual ~OnDemandUpdater() {}
 
  private:
   friend class OnDemandTester;
   friend class SupervisedUserWhitelistInstaller;
   friend class ::ComponentsUI;
+  friend class ::PluginObserver;
 
   // Triggers an update check for a 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.
   // TODO(sorin): improve this API so that the result of this non-blocking
   // call is provided by a callback.
   virtual bool OnDemandUpdate(const std::string& id) = 0;
 };
 
 // Creates the component updater.
 std::unique_ptr<ComponentUpdateService> ComponentUpdateServiceFactory(
     const scoped_refptr<Configurator>& config);
 
 }  // namespace component_updater
 
 #endif  // COMPONENTS_COMPONENT_UPDATER_COMPONENT_UPDATER_SERVICE_H_