Add different error codes for getUserMedia.

chrome/browser/media/media_stream_devices_controller.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 "chrome/browser/media/media_stream_devices_controller.h"
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
@@ skipping 113 matching lines @@
           content::MEDIA_DEVICE_VIDEO_CAPTURE,
           MediaStreamTypeSettings(MEDIA_ALLOWED,
                                   request.requested_video_device_id)));
     }
   }
 }
 
 MediaStreamDevicesController::~MediaStreamDevicesController() {
   if (!callback_.is_null()) {
     callback_.Run(content::MediaStreamDevices(),
+                  content::MEDIA_DEVICE_INVALID_STATE,
                   scoped_ptr<content::MediaStreamUI>());
   }
 }
 
 // static
 void MediaStreamDevicesController::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* prefs) {
   prefs->RegisterBooleanPref(prefs::kVideoCaptureAllowed,
                              true,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterBooleanPref(prefs::kAudioCaptureAllowed,
                              true,
                              user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kVideoCaptureAllowedUrls,
                           user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
   prefs->RegisterListPref(prefs::kAudioCaptureAllowedUrls,
                           user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 // TODO(gbillock): rename? doesn't actually dismiss. More of a 'check profile
 // and system for compatibility' thing.
 bool MediaStreamDevicesController::DismissInfoBarAndTakeActionOnSettings() {
   // Tab capture is allowed for extensions only and infobar is not shown for
   // extensions.
   if (request_.audio_type == content::MEDIA_TAB_AUDIO_CAPTURE ||
       request_.video_type == content::MEDIA_TAB_VIDEO_CAPTURE) {
-    Deny(false);
+    Deny(false, content::MEDIA_DEVICE_INVALID_STATE);
     return true;
   }
 
   // Deny the request if the security origin is empty, this happens with
   // file access without |--allow-file-access-from-files| flag.
   if (request_.security_origin.is_empty()) {
-    Deny(false);
+    Deny(false, content::MEDIA_DEVICE_INVALID_SECURITY_ORIGIN);
     return true;
   }
 
   // Deny the request if there is no device attached to the OS.
   if (!HasAnyAvailableDevice()) {
-    Deny(false);
+    Deny(false, content::MEDIA_DEVICE_NO_HARDWARE);
     return true;
   }
 
   // Check if any allow exception has been made for this request.
   if (IsRequestAllowedByDefault()) {
     Accept(false);
     return true;
   }
 
   // Filter any parts of the request that have been blocked by default and deny
   // it if nothing is left to accept.
   if (FilterBlockedByDefaultDevices() == 0) {
-    Deny(false);
+    Deny(false, content::MEDIA_DEVICE_PERMISSION_DENIED);
     return true;
   }
 
   // Check if the media default setting is set to block.
   if (IsDefaultMediaAccessBlocked()) {
-    Deny(false);
+    Deny(false, content::MEDIA_DEVICE_PERMISSION_DENIED);
     return true;
   }
 
   if (request_.request_type == content::MEDIA_OPEN_DEVICE) {
     bool no_matched_audio_device =
         (request_.audio_type == content::MEDIA_DEVICE_AUDIO_CAPTURE &&
          !request_.requested_audio_device_id.empty() &&
          MediaCaptureDevicesDispatcher::GetInstance()->GetRequestedAudioDevice(
              request_.requested_audio_device_id) == NULL);
     bool no_matched_video_device =
         (request_.video_type == content::MEDIA_DEVICE_VIDEO_CAPTURE &&
          !request_.requested_video_device_id.empty() &&
          MediaCaptureDevicesDispatcher::GetInstance()->GetRequestedVideoDevice(
              request_.requested_video_device_id) == NULL);
     if (no_matched_audio_device || no_matched_video_device) {
-      Deny(false);
+      Deny(false, content::MEDIA_DEVICE_PERMISSION_DENIED);
       return true;
     }
   }
 
   // Show the infobar.
   return false;
 }
 
 bool MediaStreamDevicesController::HasAudio() const {
   return IsDeviceAudioCaptureRequestedAndAllowed();
@@ skipping 109 matching lines @@
   }
 
   scoped_ptr<content::MediaStreamUI> ui;
   if (!devices.empty()) {
     ui = MediaCaptureDevicesDispatcher::GetInstance()->
         GetMediaStreamCaptureIndicator()->RegisterMediaStream(
             web_contents_, devices);
   }
   content::MediaResponseCallback cb = callback_;
   callback_.Reset();
-  cb.Run(devices, ui.Pass());
+  cb.Run(devices, content::MEDIA_DEVICE_OK, ui.Pass());
 }
 
-void MediaStreamDevicesController::Deny(bool update_content_setting) {
+void MediaStreamDevicesController::Deny(
+    bool update_content_setting,
+    content::MediaStreamRequestResult result) {
+  DLOG(WARNING) << "MediaStreamDevicesController::Deny: " << result;
   NotifyUIRequestDenied();
 
   if (update_content_setting)
     SetPermission(false);
 
   content::MediaResponseCallback cb = callback_;
   callback_.Reset();
-  cb.Run(content::MediaStreamDevices(), scoped_ptr<content::MediaStreamUI>());
+  cb.Run(content::MediaStreamDevices(),
+         result,
+         scoped_ptr<content::MediaStreamUI>());
 }
 
 int MediaStreamDevicesController::GetIconID() const {
   if (HasVideo())
     return IDR_INFOBAR_MEDIA_STREAM_CAMERA;
 
   return IDR_INFOBAR_MEDIA_STREAM_MIC;
 }
 
 base::string16 MediaStreamDevicesController::GetMessageText() const {
@@ skipping 32 matching lines @@
   } else {
     UMA_HISTOGRAM_ENUMERATION("Media.DevicePermissionActions",
                               kAllowHttp, kPermissionActionsMax);
   }
   Accept(true);
 }
 
 void MediaStreamDevicesController::PermissionDenied() {
   UMA_HISTOGRAM_ENUMERATION("Media.DevicePermissionActions",
                             kDeny, kPermissionActionsMax);
-  Deny(true);
+  Deny(true, content::MEDIA_DEVICE_PERMISSION_DENIED);
 }
 
 void MediaStreamDevicesController::Cancelled() {
   UMA_HISTOGRAM_ENUMERATION("Media.DevicePermissionActions",
                             kCancel, kPermissionActionsMax);
-  Deny(true);
+  Deny(true, content::MEDIA_DEVICE_PERMISSION_DISMISSED);
 }
 
 void MediaStreamDevicesController::RequestFinished() {
   delete this;
 }
 
 MediaStreamDevicesController::DevicePolicy
 MediaStreamDevicesController::GetDevicePolicy(
     const char* policy_name,
     const char* whitelist_policy_name) const {
@@ skipping 207 matching lines @@
           it->second.permission == MEDIA_ALLOWED);
 }
 
 bool MediaStreamDevicesController::IsDeviceVideoCaptureRequestedAndAllowed()
     const {
   MediaStreamTypeSettingsMap::const_iterator it =
       request_permissions_.find(content::MEDIA_DEVICE_VIDEO_CAPTURE);
   return (it != request_permissions_.end() &&
           it->second.permission == MEDIA_ALLOWED);
 }