Add histogram WebRTC.UserMediaRequest.Events to allow to track getUserMedia failures and hangs.

content/renderer/media/media_stream_impl.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 "content/renderer/media/media_stream_impl.h"
 
 #include <utility>
 
 #include "base/hash.h"
 #include "base/logging.h"
@@ skipping 162 matching lines @@
   WebRtcLogMessage(base::StringPrintf(
       "MSI::requestUserMedia. request_id=%d"
       ", audio source id=%s mandatory= %s "
       ", video source id=%s mandatory= %s",
       request_id,
       audio_device_id.c_str(),
       mandatory_audio ? "true":"false",
       video_device_id.c_str(),
       mandatory_video ? "true":"false"));
 
+  LogUserMediaRequestEvent(USERMEDIAREQUEST_CREATED);
   user_media_requests_.push_back(
       new UserMediaRequestInfo(request_id, user_media_request,
                                enable_automatic_output_device_selection));
 
   media_stream_dispatcher_->GenerateStream(
       request_id,
       weak_factory_.GetWeakPtr(),
       options,
       security_origin);
 }
 
 void MediaStreamImpl::cancelUserMediaRequest(
     const blink::WebUserMediaRequest& user_media_request) {
   DCHECK(CalledOnValidThread());
   UserMediaRequestInfo* request = FindUserMediaRequestInfo(user_media_request);
   if (request) {
     // We can't abort the stream generation process.
     // Instead, erase the request. Once the stream is generated we will stop the
     // stream if the request does not exist.
+    LogUserMediaRequestEvent(USERMEDIAREQUEST_CANCELLED);
     DeleteUserMediaRequestInfo(request);
   }
 }
 
 void MediaStreamImpl::requestMediaDevices(
     const blink::WebMediaDevicesRequest& media_devices_request) {
   UpdateWebRTCMethodCount(WEBKIT_GET_MEDIA_DEVICES);
   DCHECK(CalledOnValidThread());
 
   int audio_input_request_id = g_next_request_id++;
@@ skipping 130 matching lines @@
            << request_id << ")";
   UserMediaRequestInfo* request_info = FindUserMediaRequestInfo(request_id);
   if (!request_info) {
     // This can happen if the request is canceled or the frame reloads while
     // MediaStreamDispatcher is processing the request.
     DVLOG(1) << "Request ID not found";
     return;
   }
 
   GetUserMediaRequestFailed(&request_info->request, result);
+  LogUserMediaRequestResult(result);
   DeleteUserMediaRequestInfo(request_info);
 }
 
 // Callback from MediaStreamDispatcher.
 // The browser process has stopped a device used by a MediaStream.
 void MediaStreamImpl::OnDeviceStopped(
     const std::string& label,
     const StreamDeviceInfo& device_info) {
   DCHECK(CalledOnValidThread());
   DVLOG(1) << "MediaStreamImpl::OnDeviceStopped("
@@ skipping 134 matching lines @@
     UserMediaRequestInfo* request,
     content::MediaStreamRequestResult result) {
   DVLOG(1) << "MediaStreamImpl::OnCreateNativeTracksComplete("
            << "{request_id = " << request->request_id << "} "
            << "{result = " << result << "})";
   if (result == content::MEDIA_DEVICE_OK)
     GetUserMediaRequestSucceeded(request->web_stream, &request->request);
   else
     GetUserMediaRequestFailed(&request->request, result);
 
+  LogUserMediaRequestResult(result);
   DeleteUserMediaRequestInfo(request);
 }
 
 void MediaStreamImpl::OnDevicesEnumerated(
     int request_id,
     const StreamDeviceInfoArray& device_array) {
   DVLOG(1) << "MediaStreamImpl::OnDevicesEnumerated(" << request_id << ")";
 
   MediaDevicesRequestInfo* request = FindMediaDevicesRequestInfo(request_id);
   DCHECK(request);
@@ skipping 235 matching lines @@
     DVLOG(1) << "MediaStreamImpl@" << this << "::FrameWillClose: "
              << "Cancel user media request " << (*request_it)->request_id;
     // If the request is not generated, it means that a request
     // has been sent to the MediaStreamDispatcher to generate a stream
     // but MediaStreamDispatcher has not yet responded and we need to cancel
     // the request.
     if (!(*request_it)->generated) {
       media_stream_dispatcher_->CancelGenerateStream(
           (*request_it)->request_id, weak_factory_.GetWeakPtr());
     }
+    LogUserMediaRequestEvent(USERMEDIAREQUEST_NO_RESPONSE);

[vrk (LEFT CHROMIUM), 2014/08/04 18:22:17]

There are a few different "no response" events that we want to be able to
distinguish:
- gUM is called, and the user never clicks allow/deny
- gUM is called, user clicks allow, and the success callback never returns
- gUM is called, user clicks deny, and the failure callback never returns

I think this would lump the above scenarios into one category. How hard would it
be to separate out these scenarios? If it's difficult, I'm fine with the current
behavior and we can discuss adding this distinction later.

     request_it = user_media_requests_.erase(request_it);
   }
 
   // Loop through all current local sources and stop the sources.
   LocalStreamSources::iterator sources_it = local_sources_.begin();
   while (sources_it != local_sources_.end()) {
     StopLocalSource(*sources_it, true);
     sources_it = local_sources_.erase(sources_it);
   }
 }
@@ skipping 131 matching lines @@
            sources_.begin();
        it != sources_.end(); ++it) {
     if (source.id() == it->id()) {
       sources_.erase(it);
       return;
     }
   }
 }
 
 }  // namespace content