Simplify/Cleanup MediaClient

content/renderer/media/render_media_client.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 "content/renderer/media/render_media_client.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/time/default_tick_clock.h"
 #include "content/public/common/content_client.h"
 #include "content/public/renderer/content_renderer_client.h"
 #include "media/base/media_switches.h"
 #include "media/base/video_color_space.h"
 #include "ui/display/display_switches.h"
 
 namespace content {
 
 void RenderMediaClient::Initialize() {
-  GetInstance();
+  static RenderMediaClient* client = new RenderMediaClient();
+  media::SetMediaClient(client);
 }
 
-RenderMediaClient::RenderMediaClient()
-    : has_updated_(false),
-      is_update_needed_(true),
-      tick_clock_(new base::DefaultTickClock()) {
-  media::SetMediaClient(this);
-}
+RenderMediaClient::RenderMediaClient() {}
 
 RenderMediaClient::~RenderMediaClient() {
 }
 
-void RenderMediaClient::AddKeySystemsInfoForUMA(
-    std::vector<media::KeySystemInfoForUMA>* key_systems_info_for_uma) {
-  DVLOG(2) << __func__;
-#if defined(WIDEVINE_CDM_AVAILABLE)
-  key_systems_info_for_uma->push_back(media::KeySystemInfoForUMA(
-      kWidevineKeySystem, kWidevineKeySystemNameForUMA));
-#endif  // WIDEVINE_CDM_AVAILABLE
+void RenderMediaClient::AddSupportedKeySystems(
+    std::vector<std::unique_ptr<media::KeySystemProperties>>* key_systems) {
+  GetContentClient()->renderer()->AddSupportedKeySystems(key_systems);
 }
 
 bool RenderMediaClient::IsKeySystemsUpdateNeeded() {
-  DVLOG(2) << __func__;
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  // Always needs update if we have never updated, regardless the
-  // |last_update_time_ticks_|'s initial value.
-  if (!has_updated_) {
-    DCHECK(is_update_needed_);
-    return true;
-  }
-
-  if (!is_update_needed_)
-    return false;
-
-  // The update could be expensive. For example, it could involve a sync IPC to
-  // the browser process. Use a minimum update interval to avoid unnecessarily
-  // frequent update.
-  static const int kMinUpdateIntervalInMilliseconds = 1000;
-  if ((tick_clock_->NowTicks() - last_update_time_ticks_).InMilliseconds() <
-      kMinUpdateIntervalInMilliseconds) {
-    return false;
-  }
-
-  return true;
-}
-
-void RenderMediaClient::AddSupportedKeySystems(
-    std::vector<std::unique_ptr<media::KeySystemProperties>>*
-        key_systems_properties) {
-  DVLOG(2) << __func__;
-  DCHECK(thread_checker_.CalledOnValidThread());
-
-  GetContentClient()->renderer()->AddSupportedKeySystems(
-      key_systems_properties);
-
-  has_updated_ = true;
-  last_update_time_ticks_ = tick_clock_->NowTicks();
-
-  // Check whether all potentially supported key systems are supported. If so,
-  // no need to update again.
-#if defined(WIDEVINE_CDM_AVAILABLE) && defined(WIDEVINE_CDM_IS_COMPONENT)
-  for (const auto& properties : *key_systems_properties) {
-    if (properties->GetKeySystemName() == kWidevineKeySystem)
-      is_update_needed_ = false;
-  }
-#else
-  is_update_needed_ = false;
-#endif
-}
-
-void RenderMediaClient::RecordRapporURL(const std::string& metric,
-                                        const GURL& url) {
-  GetContentClient()->renderer()->RecordRapporURL(metric, url);
+  return GetContentClient()->renderer()->IsKeySystemsUpdateNeeded();

[xhwang, 2017/04/03 17:47:13]

I am not seeing ChromeContentRendererClient implementing
IsKeySystemsUpdateNeeded() in this CL. What's the plan here?

[chcunningham, 2017/04/03 18:47:38]

Chrome inherits the behavior from public/renderer/content_renderer_client.cc
(return false).

While some embedders may need the update behavior, my understanding is Chrome is
not needing it. 

Down the road I will refactor this further with a proper observer/notifier
pattern. P3. 

[xhwang, 2017/04/03 18:55:18]

Sorry I wasn't super clear on this.

chrome/ is actually used by chromium and all chromium-based browsers. What makes
Google Chrome special is the "is_chrome_branded" gn flag. But even though
chromium-based browsers don't use this gn flag, they still use chrome/ and hence
ChromeContentRendererClient. So always returning false will break their CDM
update logic.

[chcunningham, 2017/04/04 23:44:30]

Fixed!

 }
 
 bool RenderMediaClient::IsSupportedAudioConfig(
     const media::AudioConfig& config) {
-  // Render media client does not customize decoder support. Defer to media/.
-  return ::media::IsSupportedAudioConfig(config);
+  return GetContentClient()->renderer()->IsSupportedAudioConfig(config);
 }
 
 bool RenderMediaClient::IsSupportedVideoConfig(
     const media::VideoConfig& config) {
-  // Render media client does not customize decoder support. Defer to media/.
-  return ::media::IsSupportedVideoConfig(config);
-}
-
-void RenderMediaClient::SetTickClockForTesting(
-    std::unique_ptr<base::TickClock> tick_clock) {
-  tick_clock_.swap(tick_clock);
-}
-
-// static
-RenderMediaClient* RenderMediaClient::GetInstance() {
-  static RenderMediaClient* client = new RenderMediaClient();
-  return client;
+  return GetContentClient()->renderer()->IsSupportedVideoConfig(config);
 }
 
 }  // namespace content