UMA stats for AudioRendererSinkCache utilization.

content/renderer/media/audio_renderer_sink_cache_impl.cc

 // Copyright 2016 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 <algorithm>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "content/renderer/media/audio_device_factory.h"
 #include "content/renderer/media/audio_renderer_sink_cache_impl.h"
 #include "media/audio/audio_device_description.h"
 #include "media/base/audio_renderer_sink.h"
 #include "url/origin.h"
 
 namespace content {
 
 constexpr int kDeleteTimeoutMs = 5000;
 
+namespace {
+
+enum GetOutputDeviceInfoCacheUtilization {
+  // No cached sink found.
+  SINK_CACHE_MISS_NO_SINK = 0,
+
+  // If session id is used to specify a device, we always have to create and
+  // cache a new sink.
+  SINK_CACHE_MISS_CANNOT_LOOKUP_BY_SESSION_ID = 1,
+
+  // Output parmeters for an already-cached sink are requested.
+  SINK_CACHE_HIT = 2,
+
+  // For UMA.
+  SINK_CACHE_LAST_ENTRY
+};
+
+}  // namespace
+
 // Cached sink data.
 struct AudioRendererSinkCacheImpl::CacheEntry {
   int source_render_frame_id;
   std::string device_id;
   url::Origin security_origin;
   scoped_refptr<media::AudioRendererSink> sink;  // Sink instance
   bool used;                                     // True if in use by a client.
 };
 
 // static
@@ skipping 35 matching lines @@
     cache_entry.sink = create_sink_cb_.Run(source_render_frame_id, session_id,
                                            device_id, security_origin);
     cache_entry.device_id = cache_entry.sink->GetOutputDeviceInfo().device_id();
 
     DVLOG(1) << "GetSinkInfo: address: " << cache_entry.sink.get()
              << " - used session to create new sink.";
 
     // Cache a newly-created sink.
     base::AutoLock auto_lock(cache_lock_);
     cache_.push_back(cache_entry);
+    UMA_HISTOGRAM_ENUMERATION(
+        "Media.Audio.Render.SinkCache.GetOutputDeviceInfoCacheUtilization",
+        SINK_CACHE_MISS_CANNOT_LOOKUP_BY_SESSION_ID, SINK_CACHE_LAST_ENTRY);
 
   } else {
     // Ignore session id.
     base::AutoLock auto_lock(cache_lock_);
 
     auto cache_iter =
         FindCacheEntry_Locked(source_render_frame_id, device_id,
                               security_origin, false /* unused_only */);
 
     if (cache_iter != cache_.end()) {
       // A matching cached sink is found.
       DVLOG(1) << "GetSinkInfo: address: " << cache_iter->sink.get()
                << " - reused a cached sink.";
 
+      UMA_HISTOGRAM_ENUMERATION(
+          "Media.Audio.Render.SinkCache.GetOutputDeviceInfoCacheUtilization",
+          SINK_CACHE_HIT, SINK_CACHE_LAST_ENTRY);
       return cache_iter->sink->GetOutputDeviceInfo();
     }
 
     // No matching sink found, create a new one.
     cache_entry.device_id = device_id;
     cache_entry.sink = create_sink_cb_.Run(
         source_render_frame_id, 0 /* session_id */, device_id, security_origin);
 
     DVLOG(1) << "GetSinkInfo: address: " << cache_entry.sink.get()
              << " - no matching cached sink found, created a new one.";
 
     // Cache a newly-created sink.
     cache_.push_back(cache_entry);
+    UMA_HISTOGRAM_ENUMERATION(
+        "Media.Audio.Render.SinkCache.GetOutputDeviceInfoCacheUtilization",
+        SINK_CACHE_MISS_NO_SINK, SINK_CACHE_LAST_ENTRY);
   }
 
   // Schedule it for deletion.
   DeleteLaterIfUnused(cache_entry.sink.get());
 
   DVLOG(1) << "GetSinkInfo: address: " << cache_entry.sink.get()
            << " created. source_render_frame_id: " << source_render_frame_id
            << " session_id: " << session_id << " device_id: " << device_id
            << " security_origin: " << security_origin;
 
   return cache_entry.sink->GetOutputDeviceInfo();
 }
 
 scoped_refptr<media::AudioRendererSink> AudioRendererSinkCacheImpl::GetSink(
     int source_render_frame_id,
     const std::string& device_id,
     const url::Origin& security_origin) {
+  UMA_HISTOGRAM_BOOLEAN("Media.Audio.Render.SinkCache.UsedForSinkCreation",
+                        true);
+
   base::AutoLock auto_lock(cache_lock_);
 
   auto cache_iter =
       FindCacheEntry_Locked(source_render_frame_id, device_id, security_origin,
                             true /* unused_only */);
 
   if (cache_iter != cache_.end()) {
     // Found unused sink; mark it as used and return.
     DVLOG(1) << "GetSink: address: " << cache_iter->sink.get()
              << " - found unused cached sink, reusing it.";
 
     cache_iter->used = true;
+    UMA_HISTOGRAM_BOOLEAN(
+        "Media.Audio.Renderer.SinkCache.InfoSinkReusedForOutput", true);
     return cache_iter->sink;
   }
 
   // No unused sink is found, create one, mark it used, cache it and return.
   CacheEntry cache_entry = {
       source_render_frame_id, device_id, security_origin,
       create_sink_cb_.Run(source_render_frame_id, 0 /* session_id */, device_id,
                           security_origin),
       true /* used */};
 
@@ skipping 55 matching lines @@
         << "Attempt to delete a non-aquired sink.";
 
     if (!force_delete_used && cache_iter->used) {
       DVLOG(1) << "DeleteSink: address: " << sink_ptr
                << " sink in use, skipping deletion.";
       return;
     }
 
     // To stop the sink before deletion if it's not used, we need to hold
     // a ref to it.
-    if (!cache_iter->used)
+    if (!cache_iter->used) {
       sink_to_stop = cache_iter->sink;
+      UMA_HISTOGRAM_BOOLEAN(
+          "Media.Audio.Renderer.SinkCache.InfoSinkReusedForOutput", false);
+    }
 
     cache_.erase(cache_iter);
     DVLOG(1) << "DeleteSink: address: " << sink_ptr;
   }  // Lock scope;
 
   // Stop the sink out of the lock scope.
   if (sink_to_stop.get()) {
     DCHECK_EQ(sink_ptr, sink_to_stop.get());
     sink_to_stop->Stop();
     DVLOG(1) << "DeleteSink: address: " << sink_ptr << " stopped.";
@@ skipping 24 matching lines @@
         return val.device_id == device_id &&
                val.security_origin == security_origin;
       });
 };
 
 int AudioRendererSinkCacheImpl::GetCacheSizeForTesting() {
   return cache_.size();
 }
 
 }  // namespace content