CdmAdapter: Add UMA for output protection queries and results.

media/cdm/ppapi/cdm_adapter.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/cdm/ppapi/cdm_adapter.h"
 
 #include "media/cdm/ppapi/cdm_file_io_impl.h"
 #include "media/cdm/ppapi/cdm_helpers.h"
 #include "media/cdm/ppapi/cdm_logging.h"
 #include "media/cdm/ppapi/supported_cdm_versions.h"
 #include "ppapi/c/ppb_console.h"
+#include "ppapi/cpp/private/uma_private.h"
 
 #if defined(CHECK_DOCUMENT_URL)
 #include "ppapi/cpp/dev/url_util_dev.h"
 #include "ppapi/cpp/instance_handle.h"
 #endif  // defined(CHECK_DOCUMENT_URL)
 
 namespace {
 
 #if !defined(NDEBUG)
   #define DLOG_TO_CONSOLE(message) LogToConsole(message);
@@ skipping 195 matching lines @@
 CdmAdapter::CdmAdapter(PP_Instance instance, pp::Module* module)
     : pp::Instance(instance),
       pp::ContentDecryptor_Private(this),
 #if defined(OS_CHROMEOS)
       output_protection_(this),
       platform_verification_(this),
       challenge_in_progress_(false),
       output_link_mask_(0),
       output_protection_mask_(0),
       query_output_protection_in_progress_(false),
+      uma_for_output_protection_query_reported_(false),
+      uma_for_output_protection_positive_result_reported_(false),
 #endif
       allocator_(this),
       cdm_(NULL),
       deferred_initialize_audio_decoder_(false),
       deferred_audio_decoder_config_id_(0),
       deferred_initialize_video_decoder_(false),
       deferred_video_decoder_config_id_(0) {
   callback_factory_.Initialize(this);
 }
 
@@ skipping 597 matching lines @@
   PP_DCHECK(!query_output_protection_in_progress_);
 
   output_link_mask_ = output_protection_mask_ = 0;
   const int32_t result = output_protection_.QueryStatus(
       &output_link_mask_,
       &output_protection_mask_,
       callback_factory_.NewCallback(
           &CdmAdapter::QueryOutputProtectionStatusDone));
   if (result == PP_OK_COMPLETIONPENDING) {
     query_output_protection_in_progress_ = true;
+    if (!uma_for_output_protection_query_reported_) {

[ddorwin, 2014/04/30 23:13:35]

Why not handle this logic inside the Report function. This isolates the details
from the rest of the code and is consistent with the other Report function.

Oh, because we reuse that function. hmm.

[xhwang, 2014/04/30 23:48:16]

Added a helper function to do this.

+      ReportOutputProtectionStatus(OUTPUT_PROTECTION_QUERIED);
+      uma_for_output_protection_query_reported_ = true;
+    }
+
     return;
   }
 
   // Fall through on error and issue an empty OnQueryOutputProtectionStatus().
   PP_DCHECK(result != PP_OK);
 #endif
 
   cdm_->OnQueryOutputProtectionStatus(0, 0);
 }
 
@@ skipping 22 matching lines @@
       break;
   }
 }
 
 // The CDM owns the returned object and must call FileIO::Close() to release it.
 cdm::FileIO* CdmAdapter::CreateFileIO(cdm::FileIOClient* client) {
   return new CdmFileIOImpl(client, pp_instance());
 }
 
 #if defined(OS_CHROMEOS)
+void CdmAdapter::ReportOutputProtectionStatus(OutputProtectionStatus status) {
+  pp::UMAPrivate uma_interface_(this);
+  std::string uma_name = "Media.EME.OutputProtection";
+  uma_interface_.HistogramEnumeration(uma_name, status, OUTPUT_PROTECTION_MAX);
+}
+
+void CdmAdapter::ReportOutputProtectionQueryResult(int32_t result) {
+  if (uma_for_output_protection_positive_result_reported_)
+    return;
+
+  uma_for_output_protection_positive_result_reported_ = true;

[ddorwin, 2014/04/30 23:13:35]

A bit weird, but okay. Hmm, maybe we can handle this in
ReportOutputProtectionStatus too based on the status.

[xhwang, 2014/04/30 23:48:16]

Done.

+
+  if (result != PP_OK) {
+    ReportOutputProtectionStatus(OUTPUT_PROTECTION_QUERY_ERROR);
+    return;
+  }
+
+  // Report UMAs for output protection query result.
+  uint32_t external_links = (output_link_mask_ & ~cdm::kLinkTypeInternal);
+
+  if (!external_links) {
+    ReportOutputProtectionStatus(OUTPUT_PROTECTION_NO_EXTERNAL_LINK);
+    return;
+  }
+
+  if ((output_protection_mask_ & external_links) == external_links) {
+    ReportOutputProtectionStatus(
+        OUTPUT_PROTECTION_ALL_EXTERNAL_LINKS_PROTECTED);
+    return;
+  }
+
+  // Do not report a negative result because it could be a false negative.
+  // Instead, we will calculate number of negatives using the totally number of
+  // queries and success results.
+  uma_for_output_protection_positive_result_reported_ = false;
+}
+
 void CdmAdapter::SendPlatformChallengeDone(int32_t result) {
   challenge_in_progress_ = false;
 
   if (result != PP_OK) {
     CDM_DLOG() << __FUNCTION__ << ": Platform challenge failed!";
     cdm::PlatformChallengeResponse response = {};
     cdm_->OnPlatformChallengeResponse(response);
     return;
   }
 
@@ skipping 25 matching lines @@
 }
 
 void CdmAdapter::QueryOutputProtectionStatusDone(int32_t result) {
   PP_DCHECK(query_output_protection_in_progress_);
   query_output_protection_in_progress_ = false;
 
   // Return a protection status of none on error.
   if (result != PP_OK)
     output_link_mask_ = output_protection_mask_ = 0;
 
+  ReportOutputProtectionQueryResult(result);
+
   cdm_->OnQueryOutputProtectionStatus(output_link_mask_,
                                       output_protection_mask_);
 }
 #endif
 
 void* GetCdmHost(int host_interface_version, void* user_data) {
   if (!host_interface_version || !user_data)
     return NULL;
 
   COMPILE_ASSERT(
@@ skipping 51 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmAdapterModule();
 }
 
 }  // namespace pp