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/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 37 matching lines @@
 
   // 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_;
 
+  base::Time last_update_time_;
+
   DISALLOW_COPY_AND_ASSIGN(KeySystems);
 };
 
 static base::LazyInstance<KeySystems> g_key_systems = LAZY_INSTANCE_INITIALIZER;
 
 KeySystems& KeySystems::GetInstance() {
+  g_key_systems.Get().UpdateIfNeeded();

[ddorwin, 2014/07/18 19:57:21]

Get() is not "free":
https://code.google.com/p/chromium/codesearch#chromium/src/base/lazy_instance...

So, a local var may actually be a good idea here.

[xhwang, 2014/07/19 00:58:08]

Done.

   return g_key_systems.Get();
 }
 
 // Because we use a LazyInstance, the key systems info must be populated when
 // the instance is lazily initiated.
 KeySystems::KeySystems() {
   // 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)
+  if (IsConcreteSupportedKeySystem(kWidevineKeySystem))

[ddorwin, 2014/07/18 19:57:21]

Technically, we don't need to do this unless the request is for Widevine.
Practically, this has the desired behavior.

For this reason and because IsConcreteSupportedKeySystem() requires some amount
of CPU cycles, maybe we should instead have a member variable that tracks
whether all delay-installed CDMs are present. (This might not make sense if
there were multiple, but it is sufficient in practice.)

The member variable could be set in UpdateSupportedKeySystems() and checked
here.

[xhwang, 2014/07/19 00:58:08]

Done.

+    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();

[ddorwin, 2014/07/18 19:57:21]

How does this affect the UMAs?

[xhwang, 2014/07/19 00:58:08]

UMA is reported in IsSupportedKeySystemWithMediaMimeType(), which is orthogonal
to this CL. This CL makes the KeySystems info more up-to-date. It should also
make the UMA stats more accurate.

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

But we'll get a UMA for failed and later succeeded? I guess that's a function of
the update and could have happened in a separate tab already.

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

That's right. key_systems_support_uma_ could report false and true later.

+#endif
+}
+
+void KeySystems::UpdateSupportedKeySystems() {
+  DVLOG(2) << __FUNCTION__;
+  concrete_key_system_map_.clear();

[ddorwin, 2014/07/18 19:57:21]

Calling this function outside the constructor (as at l219) could cause a race
condition. LazyInstance ensures synchronized creation, which includes
initializing the object's values as we do at l198.

We probably need some type of read/write lock to prevent a conflict between use
and updating. Alternatively, maybe all these calls occur on the main renderer
thread. In that case, some DCHECKs would ensure we don't run into the race
condition.

[xhwang, 2014/07/19 00:58:08]

All KeySystems calls are made on the render main thread. I added a thread
checker to check this.

+  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);
+
+  last_update_time_ = base::Time::Now();
+}
+
 void KeySystems::AddConcreteSupportedKeySystems(
     const std::vector<KeySystemInfo>& concrete_key_systems) {
   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,
@@ skipping 244 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