AudioOutputDevice authorization timeout UMA histograms

media/audio/audio_output_device.cc

 // Copyright (c) 2012 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/audio/audio_output_device.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <cmath>
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/threading/thread_restrictions.h"
-#include "base/time/time.h"
+#include "base/timer/elapsed_timer.h"
 #include "base/timer/timer.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/audio/audio_device_description.h"
 #include "media/audio/audio_output_controller.h"
 #include "media/base/limits.h"
 
 namespace media {
 
 // Takes care of invoking the render callback on the audio thread.
@@ skipping 134 matching lines @@
   return audio_callback_->CurrentThreadIsAudioDeviceThread();
 }
 
 void AudioOutputDevice::RequestDeviceAuthorizationOnIOThread() {
   DCHECK(task_runner()->BelongsToCurrentThread());
   DCHECK_EQ(state_, IDLE);
   state_ = AUTHORIZING;
   ipc_->RequestDeviceAuthorization(this, session_id_, device_id_,
                                    security_origin_);
 
+  auth_timer_.reset(new base::ElapsedTimer());
   if (auth_timeout_ > base::TimeDelta()) {
     // Create the timer on the thread it's used on. It's guaranteed to be
     // deleted on the same thread since users must call Stop() before deleting
     // AudioOutputDevice; see ShutDownOnIOThread().
     auth_timeout_action_.reset(new base::OneShotTimer());
     auth_timeout_action_->Start(
         FROM_HERE, auth_timeout_,
         base::Bind(&AudioOutputDevice::OnDeviceAuthorized, this,
                    OUTPUT_DEVICE_STATUS_ERROR_TIMED_OUT,
                    media::AudioParameters(), std::string()));
@@ skipping 136 matching lines @@
 
   auth_timeout_action_.reset();
 
   // Do nothing if late authorization is received after timeout.
   if (state_ == IPC_CLOSED)
     return;
 
   UMA_HISTOGRAM_BOOLEAN("Media.Audio.Render.OutputDeviceAuthorizationTimedOut",
                         device_status == OUTPUT_DEVICE_STATUS_ERROR_TIMED_OUT);
 
+  DCHECK(auth_timer_);
+  UMA_HISTOGRAM_CUSTOM_TIMES("Media.Audio.Render.OutputDeviceAuthorizationTime",

[DaleCurtis, 2016/07/07 17:39:39]

This doesn't allow us to make adjustments without binary searching across the
domain. Ideally you want ignore the timed out status when reporting here. And
for timeouts report when the real status actually comes back (and is short
circuited by IPC_CLOSED above).

+                             auth_timer_->Elapsed(),
+                             base::TimeDelta::FromMilliseconds(1),
+                             base::TimeDelta::FromMilliseconds(5000), 100);
+  auth_timer_.reset();
+
   DCHECK_EQ(state_, AUTHORIZING);
 
   // It may happen that a second authorization is received as a result to a
   // call to Start() after Stop(). If the status for the second authorization
   // differs from the first, it will not be reflected in |device_status_|
   // to avoid a race.
   // This scenario is unlikely. If it occurs, the new value will be
   // different from OUTPUT_DEVICE_STATUS_OK, so the AudioOutputDevice
   // will enter the IPC_CLOSED state anyway, which is the safe thing to do.
   // This is preferable to holding a lock.
@@ skipping 154 matching lines @@
   render_callback_->Render(output_bus_.get(), std::round(frames_delayed),
                            frames_skipped);
 }
 
 bool AudioOutputDevice::AudioThreadCallback::
     CurrentThreadIsAudioDeviceThread() {
   return thread_checker_.CalledOnValidThread();
 }
 
 }  // namespace media