Home | History | Annotate | Download | only in crypto 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "content/renderer/media/crypto/key_systems_support_uma.h"
      6 
      7 #include <string>
      8 
      9 #include "content/public/renderer/render_thread.h"
     10 #include "content/renderer/media/crypto/key_systems.h"
     11 
     12 namespace content {
     13 
     14 namespace {
     15 
     16 const char kKeySystemSupportActionPrefix[] = "KeySystemSupport.";
     17 
     18 // Reports an event only once.
     19 class OneTimeReporter {
     20  public:
     21   OneTimeReporter(const std::string& key_system,
     22                   bool has_type,
     23                   const std::string& event);
     24   ~OneTimeReporter();
     25 
     26   void Report();
     27 
     28  private:
     29   bool is_reported_;
     30   std::string action_;
     31 };
     32 
     33 OneTimeReporter::OneTimeReporter(const std::string& key_system,
     34                                  bool has_type,
     35                                  const std::string& event)
     36     : is_reported_(false) {
     37   action_ = kKeySystemSupportActionPrefix + KeySystemNameForUMA(key_system);
     38   if (has_type)
     39     action_ += "WithType";
     40   action_ += '.' + event;
     41 }
     42 
     43 OneTimeReporter::~OneTimeReporter() {}
     44 
     45 void OneTimeReporter::Report() {
     46   if (is_reported_)
     47     return;
     48   RenderThread::Get()->RecordComputedAction(action_);
     49   is_reported_ = true;
     50 }
     51 
     52 }  // namespace
     53 
     54 class KeySystemsSupportUMA::Reporter {
     55  public:
     56   explicit Reporter(const std::string& key_system);
     57   ~Reporter();
     58 
     59   void Report(bool has_type, bool is_supported);
     60 
     61  private:
     62   const std::string key_system_;
     63 
     64   OneTimeReporter call_reporter_;
     65   OneTimeReporter call_with_type_reporter_;
     66   OneTimeReporter support_reporter_;
     67   OneTimeReporter support_with_type_reporter_;
     68 };
     69 
     70 KeySystemsSupportUMA::Reporter::Reporter(const std::string& key_system)
     71     : key_system_(key_system),
     72       call_reporter_(key_system, false, "Queried"),
     73       call_with_type_reporter_(key_system, true, "Queried"),
     74       support_reporter_(key_system, false, "Supported"),
     75       support_with_type_reporter_(key_system, true, "Supported") {}
     76 
     77 KeySystemsSupportUMA::Reporter::~Reporter() {}
     78 
     79 void KeySystemsSupportUMA::Reporter::Report(bool has_type, bool is_supported) {
     80   call_reporter_.Report();
     81   if (has_type)
     82     call_with_type_reporter_.Report();
     83 
     84   if (!is_supported)
     85     return;
     86 
     87   support_reporter_.Report();
     88   if (has_type)
     89     support_with_type_reporter_.Report();
     90 }
     91 
     92 KeySystemsSupportUMA::KeySystemsSupportUMA() {}
     93 
     94 KeySystemsSupportUMA::~KeySystemsSupportUMA() {}
     95 
     96 void KeySystemsSupportUMA::AddKeySystemToReport(const std::string& key_system) {
     97   DCHECK(!GetReporter(key_system));
     98   reporters_.set(key_system, scoped_ptr<Reporter>(new Reporter(key_system)));
     99 }
    100 
    101 void KeySystemsSupportUMA::ReportKeySystemQuery(const std::string& key_system,
    102                                                 bool has_type) {
    103   Reporter* reporter = GetReporter(key_system);
    104   if (!reporter)
    105     return;
    106   reporter->Report(has_type, false);
    107 }
    108 
    109 void KeySystemsSupportUMA::ReportKeySystemSupport(const std::string& key_system,
    110                                                   bool has_type) {
    111   Reporter* reporter = GetReporter(key_system);
    112   if (!reporter)
    113     return;
    114   reporter->Report(has_type, true);
    115 }
    116 
    117 KeySystemsSupportUMA::Reporter* KeySystemsSupportUMA::GetReporter(
    118     const std::string& key_system) {
    119   Reporters::iterator reporter = reporters_.find(key_system);
    120   if (reporter == reporters_.end())
    121     return NULL;
    122   return reporter->second;
    123 }
    124 
    125 }  // namespace content
    126