Simplify/Cleanup MediaClient

media/blink/webmediaplayer_util.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 "media/blink/webmediaplayer_util.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <string>
 #include <utility>
 
 #include "base/metrics/histogram_macros.h"
 #include "media/base/bind_to_current_loop.h"
-#include "media/base/media_client.h"
+#include "media/base/media_log.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerEncryptedMediaClient.h"
 
 namespace media {
 
 blink::WebTimeRanges ConvertToWebTimeRanges(
     const Ranges<base::TimeDelta>& ranges) {
   blink::WebTimeRanges result(ranges.size());
   for (size_t i = 0; i < ranges.size(); ++i) {
     result[i].start = ranges.start(i).InSecondsF();
@@ skipping 77 matching lines @@
   }
 
   NOTREACHED();
   return "Unknown";
 }
 
 }  // namespace
 
 void ReportMetrics(blink::WebMediaPlayer::LoadType load_type,
                    const GURL& url,
-                   const blink::WebSecurityOrigin& security_origin) {
+                   const blink::WebSecurityOrigin& security_origin,
+                   scoped_refptr<MediaLog> media_log) {
+  DCHECK(media_log);
+
   // Report URL scheme, such as http, https, file, blob etc.
   UMA_HISTOGRAM_ENUMERATION("Media.URLScheme", URLScheme(url),
                             kMaxURLScheme + 1);
 
   // Report load type, such as URL, MediaSource or MediaStream.
   UMA_HISTOGRAM_ENUMERATION("Media.LoadType", load_type,
                             blink::WebMediaPlayer::LoadTypeMax + 1);
 
   // Report the origin from where the media player is created.
-  if (GetMediaClient()) {
-    GURL security_origin_url(url::Origin(security_origin).GetURL());
+  GURL security_origin_url(url::Origin(security_origin).GetURL());
+  media_log->RecordRapporWithURL(
+      "Media.OriginUrl." + LoadTypeToString(load_type), security_origin_url);
 
-    GetMediaClient()->RecordRapporURL(
-        "Media.OriginUrl." + LoadTypeToString(load_type), security_origin_url);
-
-    // For MSE, also report usage by secure/insecure origin.
-    if (load_type == blink::WebMediaPlayer::LoadTypeMediaSource) {
-      if (security_origin.isPotentiallyTrustworthy()) {
-        GetMediaClient()->RecordRapporURL("Media.OriginUrl.MSE.Secure",
-                                          security_origin_url);
-      } else {
-        GetMediaClient()->RecordRapporURL("Media.OriginUrl.MSE.Insecure",
-                                          security_origin_url);
-      }
+  // For MSE, also report usage by secure/insecure origin.
+  if (load_type == blink::WebMediaPlayer::LoadTypeMediaSource) {
+    if (security_origin.isPotentiallyTrustworthy()) {
+      media_log->RecordRapporWithURL("Media.OriginUrl.MSE.Secure",
+                                     security_origin_url);
+    } else {
+      media_log->RecordRapporWithURL("Media.OriginUrl.MSE.Insecure",
+                                     security_origin_url);
     }
   }
 }
 
 void ReportPipelineError(blink::WebMediaPlayer::LoadType load_type,
                          const blink::WebSecurityOrigin& security_origin,
-                         PipelineStatus error) {
+                         PipelineStatus error,
+                         scoped_refptr<MediaLog> media_log) {
   DCHECK_NE(PIPELINE_OK, error);
 
   // Report the origin from where the media player is created.
-  if (!GetMediaClient())
-    return;
-
-  GetMediaClient()->RecordRapporURL(
+  media_log->RecordRapporWithURL(
       "Media.OriginUrl." + LoadTypeToString(load_type) + ".PipelineError",
       url::Origin(security_origin).GetURL());
 }
 
-void RecordOriginOfHLSPlayback(const GURL& origin_url) {
-  if (media::GetMediaClient())
-    GetMediaClient()->RecordRapporURL("Media.OriginUrl.HLS", origin_url);
-}
-
 EmeInitDataType ConvertToEmeInitDataType(
     blink::WebEncryptedMediaInitDataType init_data_type) {
   switch (init_data_type) {
     case blink::WebEncryptedMediaInitDataType::Webm:
       return EmeInitDataType::WEBM;
     case blink::WebEncryptedMediaInitDataType::Cenc:
       return EmeInitDataType::CENC;
     case blink::WebEncryptedMediaInitDataType::Keyids:
       return EmeInitDataType::KEYIDS;
     case blink::WebEncryptedMediaInitDataType::Unknown:
@@ skipping 78 matching lines @@
 
 }  // namespace
 
 OutputDeviceStatusCB ConvertToOutputDeviceStatusCB(
     blink::WebSetSinkIdCallbacks* web_callbacks) {
   return media::BindToCurrentLoop(
       base::Bind(RunSetSinkIdCallback, SetSinkIdCallback(web_callbacks)));
 }
 
 }  // namespace media