Update supported key system info from browser process if needed.

content/renderer/media/crypto/key_systems.cc

 // Copyright 2013 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 "content/renderer/media/crypto/key_systems.h"
 
 #include <string>
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
+#include "base/threading/thread_checker.h"
+#include "base/time/time.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/eme_codec.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "content/public/renderer/key_system_info.h"
 #include "content/renderer/media/crypto/key_systems_support_uma.h"
 
 #if defined(OS_ANDROID)
 #include "media/base/android/media_codec_bridge.h"
 #endif
 
@@ skipping 57 matching lines @@
 
   info.use_aes_decryptor = true;
 
   concrete_key_systems->push_back(info);
 }
 
 class KeySystems {
  public:
   static KeySystems& GetInstance();
 
+  void UpdateIfNeeded();
+
   bool IsConcreteSupportedKeySystem(const std::string& key_system);
 
   bool IsSupportedKeySystemWithMediaMimeType(
       const std::string& mime_type,
       const std::vector<std::string>& codecs,
       const std::string& key_system);
 
   bool UseAesDecryptor(const std::string& concrete_key_system);
 
 #if defined(ENABLE_PEPPER_CDMS)
   std::string GetPepperType(const std::string& concrete_key_system);
 #endif
 
   void AddContainerMask(const std::string& container, uint32 mask);
   void AddCodecMask(const std::string& codec, uint32 mask);
 
  private:
+  void UpdateSupportedKeySystems();
+
   void AddConcreteSupportedKeySystems(
       const std::vector<KeySystemInfo>& concrete_key_systems);
 
   void AddConcreteSupportedKeySystem(
       const std::string& key_system,
       bool use_aes_decryptor,
 #if defined(ENABLE_PEPPER_CDMS)
       const std::string& pepper_type,
 #endif
       SupportedCodecs supported_codecs,
@@ skipping 25 matching lines @@
   bool IsSupportedContainer(const std::string& container,
                             SupportedCodecs key_system_supported_codecs) const;
 
   // Returns true if all |codecs| are supported in |container| by checking
   // |key_system_supported_codecs|.
   bool IsSupportedContainerAndCodecs(
       const std::string& container,
       const std::vector<std::string>& codecs,
       SupportedCodecs key_system_supported_codecs) const;
 
+

[ddorwin, 2014/07/20 15:47:26]

extra line

[xhwang, 2014/07/21 18:07:27]

Done.

   // Map from key system string to capabilities.
   KeySystemPropertiesMap concrete_key_system_map_;
 
   // Map from parent key system to the concrete key system that should be used
   // to represent its capabilities.
   ParentKeySystemMap parent_key_system_map_;
 
   KeySystemsSupportUMA key_systems_support_uma_;
 
   CodecMaskMap container_codec_masks_;
   CodecMaskMap codec_masks_;
 
+  bool needs_update_;
+  base::Time last_update_time_;
+
+  // Makes sure all methods are called from the same thread.
+  base::ThreadChecker thread_checker_;
+
   DISALLOW_COPY_AND_ASSIGN(KeySystems);
 };
 
 static base::LazyInstance<KeySystems> g_key_systems = LAZY_INSTANCE_INITIALIZER;
 
 KeySystems& KeySystems::GetInstance() {
-  return g_key_systems.Get();
+  KeySystems& key_systems = g_key_systems.Get();
+  key_systems.UpdateIfNeeded();
+  return key_systems;
 }
 
 // Because we use a LazyInstance, the key systems info must be populated when
 // the instance is lazily initiated.
-KeySystems::KeySystems() {
+KeySystems::KeySystems() : needs_update_(true) {
   // Build container and codec masks for quick look up.
   for (size_t i = 0; i < arraysize(kContainerCodecMasks); ++i) {
     const CodecMask& container_codec_mask = kContainerCodecMasks[i];
     DCHECK(container_codec_masks_.find(container_codec_mask.type) ==
            container_codec_masks_.end());
     container_codec_masks_[container_codec_mask.type] =
         container_codec_mask.mask;
   }
   for (size_t i = 0; i < arraysize(kCodecMasks); ++i) {
     const CodecMask& codec_mask = kCodecMasks[i];
     DCHECK(codec_masks_.find(codec_mask.type) == codec_masks_.end());
     codec_masks_[codec_mask.type] = codec_mask.mask;
   }
 
-  std::vector<KeySystemInfo> key_systems_info;
-  GetContentClient()->renderer()->AddKeySystems(&key_systems_info);
-  // Clear Key is always supported.
-  AddClearKey(&key_systems_info);
-  AddConcreteSupportedKeySystems(key_systems_info);
+  UpdateSupportedKeySystems();
+
 #if defined(WIDEVINE_CDM_AVAILABLE)
   key_systems_support_uma_.AddKeySystemToReport(kWidevineKeySystem);
 #endif  // defined(WIDEVINE_CDM_AVAILABLE)
 }
 
+void KeySystems::UpdateIfNeeded() {
+#if defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
+  DCHECK(thread_checker_.CalledOnValidThread());
+  if (!needs_update_)
+    return;
+
+  // The update could involve a sync IPC to the browser process. Use a minimum
+  // update interval to avoid unnecessary frequent IPC to the browser.
+  static const int kMinUpdateIntervalInSeconds = 5;
+  base::Time now = base::Time::Now();
+  if (now - last_update_time_ <
+      base::TimeDelta::FromSeconds(kMinUpdateIntervalInSeconds)) {
+    return;
+  }
+
+  UpdateSupportedKeySystems();
+#endif
+}
+
+void KeySystems::UpdateSupportedKeySystems() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(needs_update_);
+  concrete_key_system_map_.clear();
+  parent_key_system_map_.clear();
+
+  // Build KeySystemInfo.
+  std::vector<KeySystemInfo> key_systems_info;
+  GetContentClient()->renderer()->AddKeySystems(&key_systems_info);
+  // Clear Key is always supported.
+  AddClearKey(&key_systems_info);
+
+  AddConcreteSupportedKeySystems(key_systems_info);
+
+#if defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
+  if (IsConcreteSupportedKeySystem(kWidevineKeySystem))
+    needs_update_ = false;
+#endif
+
+  last_update_time_ = base::Time::Now();
+}
+
 void KeySystems::AddConcreteSupportedKeySystems(
     const std::vector<KeySystemInfo>& concrete_key_systems) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(concrete_key_system_map_.empty());
+  DCHECK(parent_key_system_map_.empty());
+
   for (size_t i = 0; i < concrete_key_systems.size(); ++i) {
     const KeySystemInfo& key_system_info = concrete_key_systems[i];
     AddConcreteSupportedKeySystem(key_system_info.key_system,
                                   key_system_info.use_aes_decryptor,
 #if defined(ENABLE_PEPPER_CDMS)
                                   key_system_info.pepper_type,
 #endif
                                   key_system_info.supported_codecs,
                                   key_system_info.parent_key_system);
   }
 }
 
 void KeySystems::AddConcreteSupportedKeySystem(
     const std::string& concrete_key_system,
     bool use_aes_decryptor,
 #if defined(ENABLE_PEPPER_CDMS)
     const std::string& pepper_type,
 #endif
     SupportedCodecs supported_codecs,
     const std::string& parent_key_system) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!IsConcreteSupportedKeySystem(concrete_key_system))
       << "Key system '" << concrete_key_system << "' already registered";
   DCHECK(parent_key_system_map_.find(concrete_key_system) ==
          parent_key_system_map_.end())
       <<  "'" << concrete_key_system << " is already registered as a parent";
 
   KeySystemProperties properties;
   properties.use_aes_decryptor = use_aes_decryptor;
 #if defined(ENABLE_PEPPER_CDMS)
   DCHECK_EQ(use_aes_decryptor, pepper_type.empty());
   properties.pepper_type = pepper_type;
 #endif
 
   properties.supported_codecs = supported_codecs;
 
   concrete_key_system_map_[concrete_key_system] = properties;
 
   if (!parent_key_system.empty()) {
     DCHECK(!IsConcreteSupportedKeySystem(parent_key_system))
         << "Parent '" << parent_key_system << "' already registered concrete";
     DCHECK(parent_key_system_map_.find(parent_key_system) ==
            parent_key_system_map_.end())
         << "Parent '" << parent_key_system << "' already registered";
     parent_key_system_map_[parent_key_system] = concrete_key_system;
   }
 }
 
 bool KeySystems::IsConcreteSupportedKeySystem(const std::string& key_system) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   return concrete_key_system_map_.find(key_system) !=
       concrete_key_system_map_.end();
 }
 
 bool KeySystems::IsSupportedContainer(
     const std::string& container,
     SupportedCodecs key_system_supported_codecs) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!container.empty());
 
   // When checking container support for EME, "audio/foo" should be treated the
   // same as "video/foo". Convert the |container| to achieve this.
   // TODO(xhwang): Replace this with real checks against supported initDataTypes
   // combined with supported demuxers.
   std::string canonical_container = container;
   if (container.find("audio/") == 0)
     canonical_container.replace(0, 6, "video/");
 
   CodecMaskMap::const_iterator container_iter =
       container_codec_masks_.find(canonical_container);
   // Unrecognized container.
   if (container_iter == container_codec_masks_.end())
     return false;
 
   EmeCodec container_codec_mask = container_iter->second;
   // A container is supported iif at least one codec in that container is
   // supported.
   return (container_codec_mask & key_system_supported_codecs) != 0;
 }
 
 bool KeySystems::IsSupportedContainerAndCodecs(
     const std::string& container,
     const std::vector<std::string>& codecs,
     SupportedCodecs key_system_supported_codecs) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!container.empty());
   DCHECK(!codecs.empty());
   DCHECK(IsSupportedContainer(container, key_system_supported_codecs));
 
   CodecMaskMap::const_iterator container_iter =
       container_codec_masks_.find(container);
   EmeCodec container_codec_mask = container_iter->second;
 
   for (size_t i = 0; i < codecs.size(); ++i) {
     const std::string& codec = codecs[i];
@@ skipping 12 matching lines @@
       return false;
   }
 
   return true;
 }
 
 bool KeySystems::IsSupportedKeySystemWithMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs,
     const std::string& key_system) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   // If |key_system| is a parent key_system, use its concrete child.
   // Otherwise, use |key_system|.
   std::string concrete_key_system;
   ParentKeySystemMap::iterator parent_key_system_iter =
       parent_key_system_map_.find(key_system);
   if (parent_key_system_iter != parent_key_system_map_.end())
     concrete_key_system = parent_key_system_iter->second;
   else
     concrete_key_system = key_system;
 
@@ skipping 24 matching lines @@
       !IsSupportedContainerAndCodecs(
           mime_type, codecs, key_system_supported_codecs)) {
     return false;
   }
 
   key_systems_support_uma_.ReportKeySystemSupport(key_system, true);
   return true;
 }
 
 bool KeySystems::UseAesDecryptor(const std::string& concrete_key_system) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   KeySystemPropertiesMap::iterator key_system_iter =
       concrete_key_system_map_.find(concrete_key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
       DLOG(FATAL) << concrete_key_system << " is not a known concrete system";
       return false;
   }
 
   return key_system_iter->second.use_aes_decryptor;
 }
 
 #if defined(ENABLE_PEPPER_CDMS)
 std::string KeySystems::GetPepperType(const std::string& concrete_key_system) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   KeySystemPropertiesMap::iterator key_system_iter =
       concrete_key_system_map_.find(concrete_key_system);
   if (key_system_iter == concrete_key_system_map_.end()) {
       DLOG(FATAL) << concrete_key_system << " is not a known concrete system";
       return std::string();
   }
 
   const std::string& type = key_system_iter->second.pepper_type;
   DLOG_IF(FATAL, type.empty()) << concrete_key_system << " is not Pepper-based";
   return type;
 }
 #endif
 
 void KeySystems::AddContainerMask(const std::string& container, uint32 mask) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(container_codec_masks_.find(container) ==
          container_codec_masks_.end());
+
   container_codec_masks_[container] = static_cast<EmeCodec>(mask);
 }
 
 void KeySystems::AddCodecMask(const std::string& codec, uint32 mask) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(codec_masks_.find(codec) == codec_masks_.end());
+
   codec_masks_[codec] = static_cast<EmeCodec>(mask);
 }
 
 //------------------------------------------------------------------------------
 
 std::string GetUnprefixedKeySystemName(const std::string& key_system) {
   if (key_system == kClearKeyKeySystem)
     return kUnsupportedClearKeyKeySystem;
 
   if (key_system == kPrefixedClearKeyKeySystem)
@@ skipping 52 matching lines @@
 CONTENT_EXPORT void AddContainerMask(const std::string& container,
                                      uint32 mask) {
   KeySystems::GetInstance().AddContainerMask(container, mask);
 }
 
 CONTENT_EXPORT void AddCodecMask(const std::string& codec, uint32 mask) {
   KeySystems::GetInstance().AddCodecMask(codec, mask);
 }
 
 }  // namespace content