Wire up uma histograms with webrtc.

third_party/libjingle/overrides/init_webrtc.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 "init_webrtc.h"
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/metrics/field_trial.h"
+#include "base/metrics/histogram.h"
 #include "base/native_library.h"
 #include "base/path_service.h"
 #include "webrtc/base/basictypes.h"
 #include "webrtc/base/logging.h"
 
 const unsigned char* GetCategoryGroupEnabled(const char* category_group) {
   return TRACE_EVENT_API_GET_CATEGORY_GROUP_ENABLED(category_group);
 }
 
 void AddTraceEvent(char phase,
                    const unsigned char* category_group_enabled,
                    const char* name,
                    unsigned long long id,
                    int num_args,
                    const char** arg_names,
                    const unsigned char* arg_types,
                    const unsigned long long* arg_values,
                    unsigned char flags) {
   TRACE_EVENT_API_ADD_TRACE_EVENT(phase, category_group_enabled, name, id,
                                   num_args, arg_names, arg_types, arg_values,
                                   NULL, flags);
 }
 
-// Define webrtc:field_trial::FindFullName to provide webrtc with a field trial
+namespace webrtc {
+// Define webrtc::field_trial::FindFullName to provide webrtc with a field trial
 // implementation.
-namespace webrtc {
 namespace field_trial {
 std::string FindFullName(const std::string& trial_name) {
   return base::FieldTrialList::FindFullName(trial_name);
 }
 }  // namespace field_trial
+
+// Define webrtc::metrics functions to provide webrtc with implementations.
+namespace metrics {
+Histogram* HistogramFactoryGetCounts(
+    const std::string& name, int min, int max, int bucket_count) {
+  return reinterpret_cast<Histogram*>(
+      base::Histogram::FactoryGet(name, min, max, bucket_count,
+          base::HistogramBase::kUmaTargetedHistogramFlag));
+}
+
+Histogram* HistogramFactoryGetEnumeration(
+    const std::string& name, int boundary) {
+  return reinterpret_cast<Histogram*>(
+      base::LinearHistogram::FactoryGet(name, 1, boundary, boundary + 1,
+          base::HistogramBase::kUmaTargetedHistogramFlag));
+}
+
+void HistogramAdd(
+    Histogram* histogram_pointer, const std::string& name, int sample) {
+  base::HistogramBase* ptr =
+      reinterpret_cast<base::HistogramBase*>(histogram_pointer);
+  // The name should not vary.
+  DCHECK(ptr->histogram_name() == name);
+  ptr->Add(sample);
+}
+}  // namespace metrics
 }  // namespace webrtc
 
 #if defined(LIBPEERCONNECTION_LIB)
 
 // libpeerconnection is being compiled as a static lib.  In this case
 // we don't need to do any initializing but to keep things simple we
 // provide an empty intialization routine so that this #ifdef doesn't
 // have to be in other places.
 bool InitializeWebRtcModule() {
   webrtc::SetupEventTracer(&GetCategoryGroupEnabled, &AddTraceEvent);
@@ skipping 66 matching lines @@
 
   // Initialize the proxy by supplying it with a pointer to our
   // allocator/deallocator routines.
   // On mac we use malloc zones, which are global, so we provide NULLs for
   // the alloc/dealloc functions.
   // PS: This function is actually implemented in allocator_proxy.cc with the
   // new/delete overrides.
   InitDiagnosticLoggingDelegateFunctionFunction init_diagnostic_logging = NULL;
   bool init_ok = initialize_module(*CommandLine::ForCurrentProcess(),
 #if !defined(OS_MACOSX) && !defined(OS_ANDROID)
-                                   &Allocate,
-                                   &Dellocate,
+      &Allocate,
+      &Dellocate,
 #endif
-                                   &webrtc::field_trial::FindFullName,
-                                   logging::GetLogMessageHandler(),
-                                   &GetCategoryGroupEnabled,
-                                   &AddTraceEvent,
-                                   &g_create_webrtc_media_engine,
-                                   &g_destroy_webrtc_media_engine,
-                                   &init_diagnostic_logging);
+      &webrtc::field_trial::FindFullName,
+      &webrtc::metrics::HistogramFactoryGetCounts,
+      &webrtc::metrics::HistogramFactoryGetEnumeration,
+      &webrtc::metrics::HistogramAdd,
+      logging::GetLogMessageHandler(),
+      &GetCategoryGroupEnabled,
+      &AddTraceEvent,
+      &g_create_webrtc_media_engine,
+      &g_destroy_webrtc_media_engine,
+      &init_diagnostic_logging);
 
   if (init_ok)
     rtc::SetExtraLoggingInit(init_diagnostic_logging);
   return init_ok;
 }
 
 cricket::MediaEngineInterface* CreateWebRtcMediaEngine(
     webrtc::AudioDeviceModule* adm,
     webrtc::AudioDeviceModule* adm_sc,
     cricket::WebRtcVideoEncoderFactory* encoder_factory,
     cricket::WebRtcVideoDecoderFactory* decoder_factory) {
   // For convenience of tests etc, we call InitializeWebRtcModule here.
   // For Chrome however, InitializeWebRtcModule must be called
   // explicitly before the sandbox is initialized.  In that case, this call is
   // effectively a noop.
   InitializeWebRtcModule();
   return g_create_webrtc_media_engine(adm, adm_sc, encoder_factory,
       decoder_factory);
 }
 
 void DestroyWebRtcMediaEngine(cricket::MediaEngineInterface* media_engine) {
   g_destroy_webrtc_media_engine(media_engine);
 }
 
 #endif  // LIBPEERCONNECTION_LIB