Adding error signalling from device to VideocaptureManager to relay up to MediaStream and WebKit.

content/browser/renderer_host/media/video_capture_manager_unittest.cc

 // Copyright (c) 2011 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.
 
 // Unit test for VideoCaptureManager
 
 #include <string>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/process_util.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/media/media_stream_provider.h"
 #include "content/browser/renderer_host/media/video_capture_manager.h"
+#include "content/common/media/media_stream_options.h"
 #include "media/video/capture/video_capture_device.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 using ::testing::AnyNumber;
 using ::testing::InSequence;
 using ::testing::Return;
 
 namespace media_stream {
 
 // Listener class used to track progress of VideoCaptureManager test
 class MockMediaStreamProviderListener : public MediaStreamProviderListener {
  public:
   MockMediaStreamProviderListener()
       : devices_() {
   }
   ~MockMediaStreamProviderListener() {}
 
-  MOCK_METHOD2(Opened, void(MediaStreamType, MediaCaptureSessionId));
-  MOCK_METHOD2(Closed, void(MediaStreamType, MediaCaptureSessionId));
-  MOCK_METHOD1(DevicesEnumerated, void(const MediaCaptureDevices&));
-  MOCK_METHOD3(Error, void(MediaStreamType, MediaCaptureSessionId,
+  MOCK_METHOD2(Opened, void(MediaStreamType, int));
+  MOCK_METHOD2(Closed, void(MediaStreamType, int));
+  MOCK_METHOD1(DevicesEnumerated, void(const StreamDeviceInfoArray&));
+  MOCK_METHOD3(Error, void(MediaStreamType, int,
                            MediaStreamProviderError));
 
   virtual void DevicesEnumerated(MediaStreamType stream_type,
-                                 const MediaCaptureDevices& devices) {
+                                 const StreamDeviceInfoArray& devices) {
     devices_.clear();
-    for (MediaCaptureDevices::const_iterator it = devices.begin();
+    for (StreamDeviceInfoArray::const_iterator it = devices.begin();
         it != devices.end();
         ++it) {
       devices_.push_back(*it);
     }
     DevicesEnumerated(devices);
   }
 
-  media_stream::MediaCaptureDevices devices_;
+  media_stream::StreamDeviceInfoArray devices_;
 };  // class MockMediaStreamProviderListener
 
 }  // namespace media_stream
 
 namespace {
 
 // Needed as an input argument to Start()
 class MockFrameObserver: public media::VideoCaptureDevice::EventHandler {
  public:
   virtual void OnError() {}
@@ skipping 143 matching lines @@
   media_stream::VideoCaptureManager* vcm =
       media_stream::VideoCaptureManager::Get();
   // Make sure fake devices are used
   vcm->UseFakeDevice();
   vcm->Register(listener_.get());
   vcm->EnumerateDevices();
 
   // Wait to get device callback...
   SyncWithVideoCaptureManagerThread();
 
-  media_stream::MediaCaptureDevices::iterator it =
+  media_stream::StreamDeviceInfoArray::iterator it =
       listener_->devices_.begin();
 
   int video_session_id_first = vcm->Open(*it);
 
   // This should trigger an error callback with error code 'kDeviceAlreadyInUse'
   ++it;
   int video_session_id_second = vcm->Open(*it);
 
   vcm->Close(video_session_id_first);
   vcm->Close(video_session_id_second);
@@ skipping 18 matching lines @@
   vcm->UseFakeDevice();
   vcm->Register(listener_.get());
   vcm->EnumerateDevices();
 
   // Wait to get device callback...
   SyncWithVideoCaptureManagerThread();
 
   media_stream::MediaStreamType stream_type = media_stream::kVideoCapture;
   std::string device_name("device_doesnt_exist");
   std::string device_id("id_doesnt_exist");
-  media_stream::MediaCaptureDeviceInfo dummy_device(stream_type, device_name,
-                                                    device_id, false);
+  media_stream::StreamDeviceInfo dummy_device(stream_type, device_name,
+                                              device_id, false);
 
   // This should fail with error code 'kDeviceNotAvailable'
   vcm->Open(dummy_device);
 
   // Wait to check callbacks before removing the listener
   SyncWithVideoCaptureManagerThread();
   vcm->Unregister();
 }
 
 // Start a device using "magic" id, i.e. call Start without calling Open.
@@ skipping 21 matching lines @@
 
   // Stop shall trigger the Close callback
   vcm->Stop(media_stream::VideoCaptureManager::kStartOpenSessionId, NULL);
 
   // Wait to check callbacks before removing the listener
   SyncWithVideoCaptureManagerThread();
   vcm->Unregister();
 }
 
 }  // namespace