Add different error codes for getUserMedia.

content/browser/renderer_host/media/media_stream_ui_proxy.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 "content/browser/renderer_host/media/media_stream_ui_proxy.h"
 
 #include "content/browser/renderer_host/render_view_host_delegate.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/public/browser/browser_thread.h"
 #include "media/video/capture/fake_video_capture_device.h"
 
 namespace content {
 
 class MediaStreamUIProxy::Core {
  public:
   explicit Core(const base::WeakPtr<MediaStreamUIProxy>& proxy,
                 RenderViewHostDelegate* test_render_delegate);
   ~Core();
 
   void RequestAccess(const MediaStreamRequest& request);
   void OnStarted();
 
  private:
   void ProcessAccessRequestResponse(const MediaStreamDevices& devices,
+                                    content::MediaStreamRequestResult result,
                                     scoped_ptr<MediaStreamUI> stream_ui);
   void ProcessStopRequestFromUI();
 
   base::WeakPtr<MediaStreamUIProxy> proxy_;
   scoped_ptr<MediaStreamUI> ui_;
 
   RenderViewHostDelegate* const test_render_delegate_;
 
   // WeakPtr<> is used to RequestMediaAccessPermission() because there is no way
   // cancel media requests.
@@ skipping 21 matching lines @@
 
   if (test_render_delegate_) {
     render_delegate = test_render_delegate_;
   } else {
     RenderViewHostImpl* host = RenderViewHostImpl::FromID(
         request.render_process_id, request.render_view_id);
 
     // Tab may have gone away.
     if (!host || !host->GetDelegate()) {
       ProcessAccessRequestResponse(
-          MediaStreamDevices(), scoped_ptr<MediaStreamUI>());
+          MediaStreamDevices(),
+          MEDIA_DEVICE_INVALID_STATE,
+          scoped_ptr<MediaStreamUI>());
       return;
     }
 
     render_delegate = host->GetDelegate();
   }
 
   render_delegate->RequestMediaAccessPermission(
       request, base::Bind(&Core::ProcessAccessRequestResponse,
                           weak_factory_.GetWeakPtr()));
 }
 
 void MediaStreamUIProxy::Core::OnStarted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (ui_) {
     ui_->OnStarted(base::Bind(&Core::ProcessStopRequestFromUI,
                               base::Unretained(this)));
   }
 }
 
 void MediaStreamUIProxy::Core::ProcessAccessRequestResponse(
     const MediaStreamDevices& devices,
+    content::MediaStreamRequestResult result,
     scoped_ptr<MediaStreamUI> stream_ui) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   ui_ = stream_ui.Pass();
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamUIProxy::ProcessAccessRequestResponse,
-                 proxy_, devices));
+                 proxy_, devices, result));
 }
 
 void MediaStreamUIProxy::Core::ProcessStopRequestFromUI() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamUIProxy::ProcessStopRequestFromUI, proxy_));
 }
 
@@ skipping 35 matching lines @@
 void MediaStreamUIProxy::OnStarted(const base::Closure& stop_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
   stop_callback_ = stop_callback;
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&Core::OnStarted, base::Unretained(core_.get())));
 }
 
 void MediaStreamUIProxy::ProcessAccessRequestResponse(
-    const MediaStreamDevices& devices) {
+    const MediaStreamDevices& devices,
+    content::MediaStreamRequestResult result) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!response_callback_.is_null());
 
   ResponseCallback cb = response_callback_;
   response_callback_.Reset();
-  cb.Run(devices);
+  cb.Run(devices, result);
 }
 
 void MediaStreamUIProxy::ProcessStopRequestFromUI() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!stop_callback_.is_null());
 
   base::Closure cb = stop_callback_;
   stop_callback_.Reset();
   cb.Run();
 }
@@ skipping 36 matching lines @@
                (request.requested_video_device_id.empty() ||
                 request.requested_video_device_id == it->id)) {
       devices_to_use.push_back(*it);
       accepted_video = true;
     }
   }
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&MediaStreamUIProxy::ProcessAccessRequestResponse,
-                 weak_factory_.GetWeakPtr(), devices_to_use));
+                 weak_factory_.GetWeakPtr(),
+                 devices_to_use,
+                 devices_to_use.empty() ?
+                    MEDIA_DEVICE_NO_HARDWARE :

[perkj_chrome, 2014/03/07 12:46:22]

4-space indentation

[Tommy Widenflycht, 2014/03/07 14:37:09]

Done.

+                    MEDIA_DEVICE_OK));
 }
 
 void FakeMediaStreamUIProxy::OnStarted(const base::Closure& stop_callback) {
 }
 
 }  // namespace content