media: Add UMA and trace events for CDM creation.

media/blink/cdm_session_adapter.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/cdm_session_adapter.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/metrics/histogram.h"
 #include "base/stl_util.h"
+#include "base/trace_event/trace_event.h"
 #include "media/base/cdm_factory.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
 #include "media/base/key_systems.h"
 #include "media/blink/webcontentdecryptionmodule_impl.h"
 #include "media/blink/webcontentdecryptionmodulesession_impl.h"
 #include "url/gurl.h"
 
 namespace media {
 
 const char kMediaEME[] = "Media.EME.";
 const char kDot[] = ".";
+const char kCdmCreationTimeUMAName[] = "CreateCdm";

[ddorwin, 2015/07/20 21:35:21]

nit: CreateCdm seems very implementation-specific. What does it mean to "create
a CDM?" CdmCreationTime? Really it's the CdmInstantiationTime, but that's wordy.

Does "time" usually mean "duration" in UMAs?

[xhwang, 2015/07/20 22:11:56]

As discussed offline, we'll use "CreateCdmTime" in UMA name and
"TimeToCreateCdm" in code.

 
-CdmSessionAdapter::CdmSessionAdapter() : weak_ptr_factory_(this) {
-}
+CdmSessionAdapter::CdmSessionAdapter()
+    : trace_id_(0), weak_ptr_factory_(this) {}
 
 CdmSessionAdapter::~CdmSessionAdapter() {}
 
 void CdmSessionAdapter::CreateCdm(
     CdmFactory* cdm_factory,
     const std::string& key_system,
     const GURL& security_origin,
     const CdmConfig& cdm_config,
     blink::WebContentDecryptionModuleResult result) {
+  TRACE_EVENT_ASYNC_BEGIN0("media", "CdmSessionAdapter::CreateCdm",
+                           ++trace_id_);
+
+  base::TimeTicks start_time = base::TimeTicks::Now();
+
   // Note: WebContentDecryptionModuleImpl::Create() calls this method without
   // holding a reference to the CdmSessionAdapter. Bind OnCdmCreated() with
   // |this| instead of |weak_this| to prevent |this| from being destructed.
   base::WeakPtr<CdmSessionAdapter> weak_this = weak_ptr_factory_.GetWeakPtr();
   cdm_factory->Create(
       key_system, security_origin, cdm_config,
       base::Bind(&CdmSessionAdapter::OnSessionMessage, weak_this),
       base::Bind(&CdmSessionAdapter::OnSessionClosed, weak_this),
       base::Bind(&CdmSessionAdapter::OnLegacySessionError, weak_this),
       base::Bind(&CdmSessionAdapter::OnSessionKeysChange, weak_this),
       base::Bind(&CdmSessionAdapter::OnSessionExpirationUpdate, weak_this),
-      base::Bind(&CdmSessionAdapter::OnCdmCreated, this, key_system, result));
+      base::Bind(&CdmSessionAdapter::OnCdmCreated, this, key_system, start_time,
+                 result));
 }
 
 void CdmSessionAdapter::SetServerCertificate(
     const std::vector<uint8_t>& certificate,
     scoped_ptr<SimpleCdmPromise> promise) {
   cdm_->SetServerCertificate(certificate, promise.Pass());
 }
 
 WebContentDecryptionModuleSessionImpl* CdmSessionAdapter::CreateSession() {
   return new WebContentDecryptionModuleSessionImpl(this);
@@ skipping 48 matching lines @@
 
 CdmContext* CdmSessionAdapter::GetCdmContext() {
   return cdm_->GetCdmContext();
 }
 
 const std::string& CdmSessionAdapter::GetKeySystem() const {
   return key_system_;
 }
 
 const std::string& CdmSessionAdapter::GetKeySystemUMAPrefix() const {
+  DCHECK(!key_system_uma_prefix_.empty());
   return key_system_uma_prefix_;
 }
 
 void CdmSessionAdapter::OnCdmCreated(
     const std::string& key_system,
+    base::TimeTicks start_time,
     blink::WebContentDecryptionModuleResult result,
     scoped_ptr<MediaKeys> cdm,
     const std::string& error_message) {
   DVLOG(2) << __FUNCTION__;
+  DCHECK(!cdm_);
+
+  TRACE_EVENT_ASYNC_END2("media", "CdmSessionAdapter::CreateCdm", trace_id_,
+                         "success", (cdm ? "true" : "false"), "error_message",
+                         error_message);
+
   if (!cdm) {
     result.completeWithError(
         blink::WebContentDecryptionModuleExceptionNotSupportedError, 0,
         blink::WebString::fromUTF8(error_message));
     return;
   }
 
   key_system_ = key_system;
   key_system_uma_prefix_ =
       kMediaEME + GetKeySystemNameForUMA(key_system) + kDot;
+
+  // Only report time for successful CDM creation.
+  ReportCdmCreationTimeUMA(base::TimeTicks::Now() - start_time);
+
   cdm_ = cdm.Pass();
 
   result.completeWithContentDecryptionModule(
       new WebContentDecryptionModuleImpl(this));
 }
 
 void CdmSessionAdapter::OnSessionMessage(
     const std::string& session_id,
     MediaKeys::MessageType message_type,
     const std::vector<uint8_t>& message,
@@ skipping 45 matching lines @@
 
 WebContentDecryptionModuleSessionImpl* CdmSessionAdapter::GetSession(
     const std::string& session_id) {
   // Since session objects may get garbage collected, it is possible that there
   // are events coming back from the CDM and the session has been unregistered.
   // We can not tell if the CDM is firing events at sessions that never existed.
   SessionMap::iterator session = sessions_.find(session_id);
   return (session != sessions_.end()) ? session->second.get() : NULL;
 }
 
+void CdmSessionAdapter::ReportCdmCreationTimeUMA(
+    base::TimeDelta cdm_creation_time) {
+  // Note: This leaks memory, which is expected behavior.
+  base::HistogramBase* histogram = base::Histogram::FactoryTimeGet(
+      GetKeySystemUMAPrefix() + kCdmCreationTimeUMAName,
+      base::TimeDelta::FromMilliseconds(1), base::TimeDelta::FromSeconds(10),
+      50, base::HistogramBase::kUmaTargetedHistogramFlag);
+
+  histogram->AddTime(cdm_creation_time);
+}
+
 }  // namespace media