Adding VideoCaptureDevice for Mac.

media/video/capture/video_capture_device_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.
 
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/thread.h"
 #include "media/video/capture/fake_video_capture_device.h"
 #include "media/video/capture/video_capture_device.h"
@@ skipping 44 matching lines @@
 
   virtual void TearDown() {
   }
 
   base::WaitableEvent wait_event_;
   scoped_ptr<MockFrameObserver> frame_observer_;
   VideoCaptureDevice::Names names_;
 };
 
 TEST_F(VideoCaptureDeviceTest, OpenInvalidDevice) {
+#if defined(OS_MACOSX)

[scherkus (not reviewing), 2011/10/07 17:17:55]

will these tests ever be supported?

if so you should consider using DISABLED instead

the convention we use for disabling certain tests on certain platforms is to
prefix all tests with MAYBE_ and the put and #if/#end block at the top of the
file

i.e., 

#if defined(OS_MACOSX)
#define MAYBE_OpenInvalidDevice DISABLED_OpenInvalidDevice
...
#else
#define MAYBE_OpenInvalidDevice OpenInvalidDevice
#endif

Check out chrome/browser/extensions/extension_tabs_apitest.cc for an example

The advantages of using DISABLED is that it still lets developers run the tests
by overriding via command line flag

[mflodman_chromium_OOO, 2011/10/10 12:56:52]

Thanks, changed!

Yes, the plan is to support them, but it will require some rewriting of the
tests.

[dmac, 2011/10/11 00:25:47]

Not to be annoying, but wouldn't it be better to write the tests now while
things are fresh in your mind? I think it's a fari assumption to say if they
aren't done now, that they are probably never going to get done....

+  // Test not supported for Mac.
+  return;
+#endif
   VideoCaptureDevice::Name device_name;
   device_name.device_name = "jibberish";
   device_name.unique_id = "jibberish";
   VideoCaptureDevice* device = VideoCaptureDevice::Create(device_name);
   EXPECT_TRUE(device == NULL);
 }
 
 TEST_F(VideoCaptureDeviceTest, CaptureVGA) {
+#if defined(OS_MACOSX)
+  // Test not supported for Mac.
+  return;
+#endif
   VideoCaptureDevice::GetDeviceNames(&names_);
   if (!names_.size()) {
     LOG(WARNING) << "No camera available. Exiting test.";
     return;
   }
 
   scoped_ptr<VideoCaptureDevice> device(
       VideoCaptureDevice::Create(names_.front()));
   ASSERT_FALSE(device.get() == NULL);
 
   // Get info about the new resolution.
   EXPECT_CALL(*frame_observer_, OnFrameInfo(640, 480, 30))
       .Times(1);
 
   EXPECT_CALL(*frame_observer_, OnErr())
       .Times(0);
 
   device->Allocate(640, 480, 30, frame_observer_.get());
   device->Start();
   // Wait for 3s or for captured frame.
   EXPECT_TRUE(wait_event_.TimedWait(base::TimeDelta::FromMilliseconds(
       TestTimeouts::action_max_timeout_ms())));
   device->Stop();
   device->DeAllocate();
 }
 
 TEST_F(VideoCaptureDeviceTest, Capture720p) {
+#if defined(OS_MACOSX)
+  // Test not supported for Mac.
+  return;
+#endif
   VideoCaptureDevice::GetDeviceNames(&names_);
   if (!names_.size()) {
     LOG(WARNING) << "No camera available. Exiting test.";
     return;
   }
 
   scoped_ptr<VideoCaptureDevice> device(
       VideoCaptureDevice::Create(names_.front()));
   ASSERT_FALSE(device.get() == NULL);
 
   // Get info about the new resolution.
   // We don't care about the resulting resolution or frame rate as it might
   // be different from one machine to the next.
   EXPECT_CALL(*frame_observer_, OnFrameInfo(_, _, _))
       .Times(1);
 
   EXPECT_CALL(*frame_observer_, OnErr())
       .Times(0);
 
   device->Allocate(1280, 720, 30, frame_observer_.get());
   device->Start();
   // Get captured video frames.
   EXPECT_TRUE(wait_event_.TimedWait(base::TimeDelta::FromMilliseconds(
       TestTimeouts::action_max_timeout_ms())));
   device->Stop();
   device->DeAllocate();
 }
 
 TEST_F(VideoCaptureDeviceTest, AllocateSameCameraTwice) {
+#if defined(OS_MACOSX)
+  // Test not supported for Mac.
+  return;
+#endif
   VideoCaptureDevice::GetDeviceNames(&names_);
   if (!names_.size()) {
     LOG(WARNING) << "No camera available. Exiting test.";
     return;
   }
   scoped_ptr<VideoCaptureDevice> device1(
       VideoCaptureDevice::Create(names_.front()));
   ASSERT_TRUE(device1.get() != NULL);
 
   scoped_ptr<VideoCaptureDevice> device2(
       VideoCaptureDevice::Create(names_.front()));
   ASSERT_TRUE(device2.get() != NULL);
 
   // 1. Get info about the new resolution on the first allocated camera
   EXPECT_CALL(*frame_observer_, OnFrameInfo(640, 480, 30));
 
   device1->Allocate(640, 480, 30, frame_observer_.get());
 
   // 2. Error when trying to allocate the same camera again.
   EXPECT_CALL(*frame_observer_, OnErr());
   device2->Allocate(640, 480, 30, frame_observer_.get());
 
   device1->DeAllocate();
   device2->DeAllocate();
 }
 
 TEST_F(VideoCaptureDeviceTest, AllocateBadSize) {
+#if defined(OS_MACOSX)
+  // Test not supported for Mac.
+  return;
+#endif
   VideoCaptureDevice::GetDeviceNames(&names_);
   if (!names_.size()) {
     LOG(WARNING) << "No camera available. Exiting test.";
     return;
   }
   scoped_ptr<VideoCaptureDevice> device(
       VideoCaptureDevice::Create(names_.front()));
   ASSERT_TRUE(device.get() != NULL);
 
   EXPECT_CALL(*frame_observer_, OnErr())
       .Times(0);
 
   // get info about the new resolution
   EXPECT_CALL(*frame_observer_, OnFrameInfo(640, 480 , _))
       .Times(AtLeast(1));
 
   device->Allocate(637, 472, 35, frame_observer_.get());
   device->DeAllocate();
 }
 
 TEST_F(VideoCaptureDeviceTest, ReAllocateCamera) {
+#if defined(OS_MACOSX)
+  // Test not supported for Mac.
+  return;
+#endif
   VideoCaptureDevice::GetDeviceNames(&names_);
   if (!names_.size()) {
     LOG(WARNING) << "No camera available. Exiting test.";
     return;
   }
   scoped_ptr<VideoCaptureDevice> device(
       VideoCaptureDevice::Create(names_.front()));
   ASSERT_TRUE(device.get() != NULL);
   EXPECT_CALL(*frame_observer_, OnErr())
       .Times(0);
@@ skipping 12 matching lines @@
 
   device->Start();
   // Get captured video frames.
   EXPECT_TRUE(wait_event_.TimedWait(base::TimeDelta::FromMilliseconds(
       TestTimeouts::action_max_timeout_ms())));
   device->Stop();
   device->DeAllocate();
 }
 
 TEST_F(VideoCaptureDeviceTest, DeAllocateCameraWhileRunning) {
+#if defined(OS_MACOSX)
+  // Test not supported for Mac.
+  return;
+#endif
   VideoCaptureDevice::GetDeviceNames(&names_);
   if (!names_.size()) {
     LOG(WARNING) << "No camera available. Exiting test.";
     return;
   }
   scoped_ptr<VideoCaptureDevice> device(
       VideoCaptureDevice::Create(names_.front()));
   ASSERT_TRUE(device.get() != NULL);
 
   EXPECT_CALL(*frame_observer_, OnErr())
       .Times(0);
   // Get info about the new resolution.
   EXPECT_CALL(*frame_observer_, OnFrameInfo(640, 480, 30));
 
   device->Allocate(640, 480, 30, frame_observer_.get());
 
   device->Start();
   // Get captured video frames.
   EXPECT_TRUE(wait_event_.TimedWait(base::TimeDelta::FromMilliseconds(
       TestTimeouts::action_max_timeout_ms())));
   device->DeAllocate();
 }
 
 TEST_F(VideoCaptureDeviceTest, TestFakeCapture) {
+#if defined(OS_MACOSX)
+  // Test not supported for Mac.
+  return;
+#endif
   VideoCaptureDevice::Names names;
 
   FakeVideoCaptureDevice::GetDeviceNames(&names);
 
   ASSERT_GT(static_cast<int>(names.size()), 0);
 
   scoped_ptr<VideoCaptureDevice> device(
       FakeVideoCaptureDevice::Create(names.front()));
   ASSERT_TRUE(device.get() != NULL);
 
   // Get info about the new resolution.
   EXPECT_CALL(*frame_observer_, OnFrameInfo(640, 480, 30))
       .Times(1);
 
   EXPECT_CALL(*frame_observer_, OnErr())
       .Times(0);
 
   device->Allocate(640, 480, 30, frame_observer_.get());
 
   device->Start();
   EXPECT_TRUE(wait_event_.TimedWait(base::TimeDelta::FromMilliseconds(
       TestTimeouts::action_max_timeout_ms())));
   device->Stop();
   device->DeAllocate();
 }
 
 };  // namespace media