Implement Just-In-Time Flash updates.

components/component_updater/component_updater_service.cc

 // 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.
 
 #include "components/component_updater/component_updater_service.h"
 
 #include <algorithm>
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/sequenced_task_runner.h"
 #include "base/single_thread_task_runner.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread_checker.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/timer/timer.h"
 #include "components/component_updater/component_updater_service_internal.h"
 #include "components/component_updater/timer.h"
 #include "components/update_client/configurator.h"
 #include "components/update_client/crx_update_item.h"
 #include "components/update_client/update_client.h"
 #include "components/update_client/utils.h"
 #include "url/gurl.h"
 
 using CrxInstaller = update_client::CrxInstaller;
 using UpdateClient = update_client::UpdateClient;
 
 namespace {
 
 enum UpdateType {
   UPDATE_TYPE_MANUAL = 0,
   UPDATE_TYPE_AUTOMATIC,
   UPDATE_TYPE_COUNT,
 };
 
 }  // namespace
 
 namespace component_updater {
 
+ComponentInfo::ComponentInfo(const std::string& id, const base::string16& name)
+    : id(id), name(name) {}
+ComponentInfo::~ComponentInfo() {}
+
 CrxUpdateService::CrxUpdateService(
     const scoped_refptr<Configurator>& config,
     const scoped_refptr<UpdateClient>& update_client)
     : config_(config),
       update_client_(update_client),
       blocking_task_runner_(config->GetSequencedTaskRunner()) {
   AddObserver(this);
 }
 
 CrxUpdateService::~CrxUpdateService() {
@@ skipping 53 matching lines @@
   // Update the registration data if the component has been registered before.
   const std::string id(GetCrxComponentID(component));
   auto it = components_.find(id);
   if (it != components_.end()) {
     it->second = component;
     return true;
   }
 
   components_.insert(std::make_pair(id, component));
   components_order_.push_back(id);
+  for (const auto& mime_type : component.handled_mime_types)
+    component_ids_by_mime_type_[mime_type] = id;
 
   // Create an initial state for this component. The state is mutated in
   // response to events from the UpdateClient instance.
   CrxUpdateItem item;
   item.id = id;
   item.component = component;
   const auto inserted = component_states_.insert(std::make_pair(id, item));
   DCHECK(inserted.second);
 
   // Start the timer if this is the first component registered. The first timer
@@ skipping 43 matching lines @@
 }
 
 std::vector<std::string> CrxUpdateService::GetComponentIDs() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   std::vector<std::string> ids;
   for (const auto& it : components_)
     ids.push_back(it.first);
   return ids;
 }
 
+std::unique_ptr<ComponentInfo> CrxUpdateService::GetComponentForMimeType(
+    const std::string& mime_type) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  const auto it = component_ids_by_mime_type_.find(mime_type);
+  if (it == component_ids_by_mime_type_.end())
+    return nullptr;
+  const auto component = GetComponent(it->second);
+  if (!component)
+    return nullptr;
+  return base::MakeUnique<ComponentInfo>(GetCrxComponentID(*component),
+                                         base::UTF8ToUTF16(component->name));
+}
+
 OnDemandUpdater& CrxUpdateService::GetOnDemandUpdater() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return *this;
 }
 
 const CrxComponent* CrxUpdateService::GetComponent(
     const std::string& id) const {
   DCHECK(thread_checker_.CalledOnValidThread());
   const auto it(components_.find(id));
   return it != components_.end() ? &(it->second) : NULL;
@@ skipping 193 matching lines @@
 // TODO(sorin): consider making this a singleton.
 std::unique_ptr<ComponentUpdateService> ComponentUpdateServiceFactory(
     const scoped_refptr<Configurator>& config) {
   DCHECK(config);
   auto update_client = update_client::UpdateClientFactory(config);
   return base::WrapUnique(
       new CrxUpdateService(config, std::move(update_client)));
 }
 
 }  // namespace component_updater