CdmAdapter: Report size of the file read by CDM via FileIO.

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/base/limits.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 {
 
+// Constants for UMA reporting of file size (in KB) via HistogramCustomCounts().
+// Note that the histogram is log-scaled (rather than linear).
+const uint32_t kSizeKBMin = 1;

[ddorwin, 2014/09/12 02:26:28]

What about 0? There can be empty files. Or maybe we should exclude those because
they are non-interesting. Well, we can always do that manually in the viewer.

[xhwang, 2014/09/12 04:30:12]

https://code.google.com/p/chromium/codesearch#chromium/src/base/metrics/histo...

The minimum allowed "min" is 1. Zero will be implicitly added as the first
range.

+const uint32_t kSizeKBMax = 512 * 1024;  // 512MB
+const uint32_t kSizeKBBuckets = 100;
+
 #if !defined(NDEBUG)
   #define DLOG_TO_CONSOLE(message) LogToConsole(message);
 #else
   #define DLOG_TO_CONSOLE(message) (void)(message);
 #endif
 
 bool IsMainThread() {
   return pp::Module::Get()->core()->IsMainThread();
 }
 
@@ skipping 228 matching lines @@
       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) {
+      deferred_video_decoder_config_id_(0),
+      last_read_file_size_kb_(0),
+      file_size_uma_reported_(false) {
   callback_factory_.Initialize(this);
 }
 
 CdmAdapter::~CdmAdapter() {}
 
 bool CdmAdapter::CreateCdmInstance(const std::string& key_system) {
   PP_DCHECK(!cdm_);
   cdm_ = make_linked_ptr(CdmWrapper::Create(
       key_system.data(), key_system.size(), GetCdmHost, this));
   bool success = cdm_ != NULL;
@@ skipping 471 matching lines @@
       &CdmAdapter::SendPromiseResolvedWithUsableKeyIdsInternal,
       promise_id,
       key_ids));
 }
 
 void CdmAdapter::OnRejectPromise(uint32_t promise_id,
                                  cdm::Error error,
                                  uint32_t system_code,
                                  const char* error_message,
                                  uint32_t error_message_length) {
+  // UMA to investigate http://crbug.com/410630
+  // TODO(xhwang): Remove after bug is fixed.
+  if (system_code == 0x27) {
+    pp::UMAPrivate uma_interface(this);
+    uma_interface.HistogramCustomCounts("Media.EME.CdmFileIO.FileSizeKBOnError",
+                                        last_read_file_size_kb_,
+                                        kSizeKBMin,
+                                        kSizeKBMax,
+                                        kSizeKBBuckets);
+  }
+
   RejectPromise(promise_id,
                 error,
                 system_code,
                 std::string(error_message, error_message_length));
 }
 
 void CdmAdapter::RejectPromise(uint32_t promise_id,
                                cdm::Error error,
                                uint32_t system_code,
                                const std::string& error_message) {
@@ skipping 303 matching lines @@
         static_cast<cdm::VideoFrame::VideoPlane>(i);
     if (ppb_buffer->Size() < video_frame->PlaneOffset(plane) +
                              plane_height * video_frame->Stride(plane)) {
       return false;
     }
   }
 
   return true;
 }
 
+void CdmAdapter::OnFileRead(int32_t file_size_bytes) {
+  PP_DCHECK(IsMainThread());
+  PP_DCHECK(file_size_bytes >= 0);
+
+  last_read_file_size_kb_ = file_size_bytes / 1000;

[ddorwin, 2014/09/12 02:26:28]

Why 1000 instead of 1024?  Your max above would be 512 * 1024 * 1000 bytes.

[xhwang, 2014/09/12 04:30:12]

lol, good catch! Fixed.

+
+  if (file_size_uma_reported_)
+    return;
+
+  pp::UMAPrivate uma_interface(this);
+  uma_interface.HistogramCustomCounts(
+      "Media.EME.CdmFileIO.FileSizeKBOnFirstRead",
+      last_read_file_size_kb_,
+      kSizeKBMin,
+      kSizeKBMax,
+      kSizeKBBuckets);
+  file_size_uma_reported_ = true;
+}
+
 #if !defined(NDEBUG)
 void CdmAdapter::LogToConsole(const pp::Var& value) {
   PP_DCHECK(IsMainThread());
   const PPB_Console* console = reinterpret_cast<const PPB_Console*>(
       pp::Module::Get()->GetBrowserInterface(PPB_CONSOLE_INTERFACE));
   console->Log(pp_instance(), PP_LOGLEVEL_LOG, value.pp_var());
 }
 #endif  // !defined(NDEBUG)
 
 void CdmAdapter::SendPlatformChallenge(
@@ skipping 87 matching lines @@
                                         deferred_video_decoder_config_id_,
                                         decoder_status == cdm::kSuccess));
       deferred_initialize_video_decoder_ = false;
       deferred_video_decoder_config_id_ = 0;
       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());
+  return new CdmFileIOImpl(
+      client,
+      pp_instance(),
+      callback_factory_.NewCallback(&CdmAdapter::OnFileRead));
 }
 
 #if defined(OS_CHROMEOS)
 void CdmAdapter::ReportOutputProtectionUMA(OutputProtectionStatus status) {
   pp::UMAPrivate uma_interface_(this);
   uma_interface_.HistogramEnumeration(
       "Media.EME.OutputProtection", status, OUTPUT_PROTECTION_MAX);
 }
 
 void CdmAdapter::ReportOutputProtectionQuery() {
@@ skipping 155 matching lines @@
 }  // namespace media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new media::CdmAdapterModule();
 }
 
 }  // namespace pp