Simplify/Cleanup MediaClient

media/blink/webencryptedmediaclient_impl.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 "media/blink/webencryptedmediaclient_impl.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "media/base/key_systems.h"
-#include "media/base/media_client.h"
+#include "media/base/media_log.h"
 #include "media/base/media_permission.h"
 #include "media/blink/webcontentdecryptionmodule_impl.h"
 #include "media/blink/webcontentdecryptionmoduleaccess_impl.h"
 #include "third_party/WebKit/public/platform/URLConversion.h"
 #include "third_party/WebKit/public/platform/WebContentDecryptionModuleResult.h"
 #include "third_party/WebKit/public/platform/WebEncryptedMediaRequest.h"
 #include "third_party/WebKit/public/platform/WebMediaKeySystemConfiguration.h"
 #include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "url/gurl.h"
@@ skipping 55 matching lines @@
   }
 
   const std::string uma_name_;
   bool is_request_reported_;
   bool is_support_reported_;
 };
 
 WebEncryptedMediaClientImpl::WebEncryptedMediaClientImpl(
     base::Callback<bool(void)> are_secure_codecs_supported_cb,
     CdmFactory* cdm_factory,
-    MediaPermission* media_permission)
+    MediaPermission* media_permission,
+    const scoped_refptr<MediaLog>& media_log)
     : are_secure_codecs_supported_cb_(are_secure_codecs_supported_cb),
       cdm_factory_(cdm_factory),
       key_system_config_selector_(KeySystems::GetInstance(), media_permission),
+      media_log_(media_log),
       weak_factory_(this) {
   DCHECK(cdm_factory_);
 }
 
 WebEncryptedMediaClientImpl::~WebEncryptedMediaClientImpl() {
 }
 
 void WebEncryptedMediaClientImpl::requestMediaKeySystemAccess(
     blink::WebEncryptedMediaRequest request) {
   GetReporter(request.keySystem())->ReportRequested();
 
-  if (GetMediaClient()) {
-    GURL security_origin(url::Origin(request.getSecurityOrigin()).GetURL());
-
-    GetMediaClient()->RecordRapporURL("Media.OriginUrl.EME", security_origin);
-
-    if (!request.getSecurityOrigin().isPotentiallyTrustworthy()) {
-      GetMediaClient()->RecordRapporURL("Media.OriginUrl.EME.Insecure",
-                                        security_origin);
-    }
+  media_log_->RecordRapporWithSecurityOrigin("Media.OriginUrl.EME");
+  if (!request.getSecurityOrigin().isPotentiallyTrustworthy()) {
+    media_log_->RecordRapporWithSecurityOrigin("Media.OriginUrl.EME.Insecure");
   }
 
   key_system_config_selector_.SelectConfig(
       request.keySystem(), request.supportedConfigurations(),
       request.getSecurityOrigin(), are_secure_codecs_supported_cb_.Run(),
       base::Bind(&WebEncryptedMediaClientImpl::OnRequestSucceeded,
                  weak_factory_.GetWeakPtr(), request),
       base::Bind(&WebEncryptedMediaClientImpl::OnRequestNotSupported,
                  weak_factory_.GetWeakPtr(), request));
 }
@@ skipping 48 matching lines @@
 
   // Return a per-frame singleton so that UMA reports will be once-per-frame.
   std::string uma_name = GetKeySystemNameForUMA(key_system_ascii);
   std::unique_ptr<Reporter>& reporter = reporters_[uma_name];
   if (!reporter)
     reporter = base::MakeUnique<Reporter>(uma_name);
   return reporter.get();
 }
 
 }  // namespace media