Add additional UMAs to keep track of unprefixed EME promise results

media/blink/webcontentdecryptionmodulesession_impl.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 "webcontentdecryptionmodulesession_impl.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/cdm_promise.h"
 #include "media/base/media_keys.h"
 #include "media/blink/cdm_result_promise.h"
 #include "media/blink/cdm_session_adapter.h"
 #include "media/blink/new_session_cdm_result_promise.h"
 #include "third_party/WebKit/public/platform/WebData.h"
 #include "third_party/WebKit/public/platform/WebEncryptedMediaKeyInformation.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/platform/WebVector.h"
 
 namespace media {
 
-const char kCreateSessionUMAName[] = "CreateSession";
+const char kCloseSessionUMAName[] = "CloseSession";
+const char kGenerateRequestUMAName[] = "GenerateRequest";
 const char kLoadSessionUMAName[] = "LoadSession";
+const char kRemoveSessionUMAName[] = "RemoveSession";
+const char kUpdateSessionUMAName[] = "UpdateSession";
 
 // TODO(jrummell): Pass an enum from blink. http://crbug.com/418239.
 const char kTemporarySessionType[] = "temporary";
 const char kPersistentLicenseSessionType[] = "persistent-license";
 const char kPersistentReleaseMessageSessionType[] =
     "persistent-release-message";
 
 static blink::WebContentDecryptionModuleSession::Client::MessageType
 convertMessageType(MediaKeys::MessageType message_type) {
   switch (message_type) {
@@ skipping 102 matching lines @@
     session_type_enum = MediaKeys::PERSISTENT_RELEASE_MESSAGE_SESSION;
   } else {
     DCHECK(session_type == kTemporarySessionType);
     session_type_enum = MediaKeys::TEMPORARY_SESSION;
   }
 
   adapter_->InitializeNewSession(
       init_data_type_as_ascii, init_data,
       base::saturated_cast<int>(init_data_length), session_type_enum,
       scoped_ptr<NewSessionCdmPromise>(new NewSessionCdmResultPromise(
-          result, adapter_->GetKeySystemUMAPrefix() + kCreateSessionUMAName,
+          result, adapter_->GetKeySystemUMAPrefix() + kGenerateRequestUMAName,
           base::Bind(
               &WebContentDecryptionModuleSessionImpl::OnSessionInitialized,
               base::Unretained(this)))));
 }
 
 void WebContentDecryptionModuleSessionImpl::load(
     const blink::WebString& session_id,
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(!session_id.isEmpty());
   DCHECK(session_id_.empty());
 
   // TODO(jrummell): Now that there are 2 types of persistent sessions, the
   // session type should be passed from blink. Type should also be passed in the
   // constructor (and removed from initializeNewSession()).
   adapter_->LoadSession(
       MediaKeys::PERSISTENT_LICENSE_SESSION, base::UTF16ToASCII(session_id),
       scoped_ptr<NewSessionCdmPromise>(new NewSessionCdmResultPromise(
           result, adapter_->GetKeySystemUMAPrefix() + kLoadSessionUMAName,
           base::Bind(
               &WebContentDecryptionModuleSessionImpl::OnSessionInitialized,
               base::Unretained(this)))));
 }
 
 void WebContentDecryptionModuleSessionImpl::update(
     const uint8* response,
     size_t response_length,
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(response);
   DCHECK(!session_id_.empty());
-  adapter_->UpdateSession(session_id_, response,
-                          base::saturated_cast<int>(response_length),
-                          scoped_ptr<SimpleCdmPromise>(
-                              new CdmResultPromise<>(result, std::string())));
+  adapter_->UpdateSession(
+      session_id_, response, base::saturated_cast<int>(response_length),
+      scoped_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
+          result, adapter_->GetKeySystemUMAPrefix() + kUpdateSessionUMAName)));
 }
 
 void WebContentDecryptionModuleSessionImpl::close(
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(!session_id_.empty());
-  adapter_->CloseSession(session_id_,
-                         scoped_ptr<SimpleCdmPromise>(
-                             new CdmResultPromise<>(result, std::string())));
+  adapter_->CloseSession(
+      session_id_,
+      scoped_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
+          result, adapter_->GetKeySystemUMAPrefix() + kCloseSessionUMAName)));
 }
 
 void WebContentDecryptionModuleSessionImpl::remove(
     blink::WebContentDecryptionModuleResult result) {
   DCHECK(!session_id_.empty());
-  adapter_->RemoveSession(session_id_,
-                          scoped_ptr<SimpleCdmPromise>(
-                              new CdmResultPromise<>(result, std::string())));
+  adapter_->RemoveSession(
+      session_id_,
+      scoped_ptr<SimpleCdmPromise>(new CdmResultPromise<>(
+          result, adapter_->GetKeySystemUMAPrefix() + kRemoveSessionUMAName)));
 }
 
 void WebContentDecryptionModuleSessionImpl::release(
     blink::WebContentDecryptionModuleResult result) {
   close(result);
 }
 
 void WebContentDecryptionModuleSessionImpl::OnSessionMessage(
     MediaKeys::MessageType message_type,
     const std::vector<uint8>& message) {
@@ skipping 40 matching lines @@
     return blink::WebContentDecryptionModuleResult::SessionNotFound;
 
   DCHECK(session_id_.empty()) << "Session ID may not be changed once set.";
   session_id_ = session_id;
   return adapter_->RegisterSession(session_id_, weak_ptr_factory_.GetWeakPtr())
              ? blink::WebContentDecryptionModuleResult::NewSession
              : blink::WebContentDecryptionModuleResult::SessionAlreadyExists;
 }
 
 }  // namespace media