This is the VideoCaptureDevice implementation for windows.

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/threading/thread.h"
+#include "base/synchronization/waitable_event.h"
+
+

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

remove extra empty line.

[Per K, 2011/06/27 11:47:50]

Done.

+#include "media/video/capture/fake_video_capture_device.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::Return;
+using ::testing::AtLeast;
+
+namespace media {
+
+class MockFrameObserver: public media::VideoCaptureDevice::EventHandler {

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

space before :

Can you run gcl lint on the cl and fix all the lint issues?
I'll ignore things for now that lint should catch until you upload an update.

[Per K, 2011/06/27 11:47:50]

Done.

+ public:
+  MOCK_METHOD0(OnErr, void());
+  MOCK_METHOD3(OnFrameInfo, void(int width, int height, int frame_rate));
+
+  explicit MockFrameObserver(base::WaitableEvent* wait_event)
+     : frame_received_(false),
+       wait_event_(wait_event) {}
+
+  virtual void OnError() {

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

for virtual methods Chromium has started to use the OVERRIDE macro/compiler
feature.  So this should be:
virtual void OnError() OVERRIDE {

same for other virtual methods.

[Per K, 2011/06/27 11:47:50]

Done.

+    OnErr();
+  }
+  void OnFrameInfo(const VideoCaptureDevice::Capability& info) {

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

should this be virtual?
also add an empty line between functions when they have an implementation.

[Per K, 2011/06/27 11:47:50]

Done.

+    OnFrameInfo(info.width, info.height, info.frame_rate);
+  }
+  virtual void OnIncomingCapturedFrame(const uint8* data, int length,
+                                       base::Time timestamp) {
+    wait_event_->Signal();
+  }
+
+  bool frame_received_;

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

private/protected?

[Per K, 2011/06/27 11:47:50]

Done.

+  base::WaitableEvent* wait_event_;
+};
+
+class VideoCaptureDeviceTest : public testing::Test {
+ public:
+  VideoCaptureDeviceTest(): wait_event_(false, false) { }
+
+ protected:
+  virtual void SetUp() {
+    frame_observer_.reset(new MockFrameObserver(&wait_event_));
+
+    VideoCaptureDevice::GetDeviceNames(&names_);
+    // Make sure there are more than 0 cameras.
+    ASSERT_GT(static_cast<int>(names_.size()), 0);

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

instead of using static_cast<int>(), just do:
ASSERT_GT(names_.size(), 0U);

Actually, when we're not using the dummy implementation but actually require a
camera to be present in order to run the test, I think we should not assert
here.
The bots are not going to have a camera (at least not all) and there's no need
to break the build in that case.  Instead, we should log (either vlog(1) or
warning level) that the test will not run due to missing hardware.

if (names_.empty()) {
  LOG(WARNING) << "No camera available. "
               << "This test will be skipped.";
  skip_test_ = true;  <- initialized to false.
}

and in the tests themselves:

if (skip_test_)
  return;

[Per K, 2011/06/27 11:47:50]

Done - kind of.

On 2011/06/23 14:05:56, tommi wrote:

+  }
+
+  virtual void TearDown() {
+  }
+
+  base::WaitableEvent wait_event_;
+  scoped_ptr<MockFrameObserver> frame_observer_;
+  VideoCaptureDevice::Names names_;
+};
+
+TEST_F(VideoCaptureDeviceTest, OpenInvalidDevice) {
+  VideoCaptureDevice::Name device_name;
+  device_name.device_name = "jibberish";
+  device_name.unique_id = "jibberish";
+  VideoCaptureDevice* device = VideoCaptureDevice::Create(device_name);
+  EXPECT_TRUE(device == NULL);

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

fyi - I'm sure lint will tell you to use EXPECT_EQ. If you do, you'll need to
cast the NULL to the proper type:

EXPECT_EQ(device, static_cast<VideoCaptureDevice*>(NULL));

I think it's worth it just to keep lint happy and the code consistent.

[Per K, 2011/06/27 11:47:50]

Lint don't complain about this.

On 2011/06/23 14:05:56, tommi wrote:

+}
+
+TEST_F(VideoCaptureDeviceTest, CaptureVGA) {
+  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))

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

is there a chance that allocate succeeds but the frame rate is not what we asked
for?  On my laptop the Capture720p test succeeds but the frame rate I get is 15
although we're asking for 30.

[Per K, 2011/06/27 11:47:50]

Almost all cameras can do VGA 30fps. But whenever a resolution is not supported
the callback will give you the nearest possible resolution.

+      .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(3000)));

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

add a constant at the top of the file for the wait period.  If 3000 turns out to
be too short it'll be easier to change it.

[Per K, 2011/06/27 11:47:50]

Done.

+  device->Stop();
+  device->DeAllocate();
+}
+
+TEST_F(VideoCaptureDeviceTest, Capture720p) {
+  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(3000)));
+  device->Stop();
+  device->DeAllocate();
+}
+
+TEST_F(VideoCaptureDeviceTest, AllocateSameCameraTwice) {
+  scoped_ptr<VideoCaptureDevice> device1(
+      VideoCaptureDevice::Create(names_.front()));
+  ASSERT_FALSE(device1.get() == NULL);

[tommi (sloooow) - chröme, 2011/06/23 14:05:56]

nit: All the ASSERT_FALSE(ptr == NULL) checks read backwards to me.  I look at
the condition and I think "he expects the pointer to be NULL".  Then later I see
that pointer being used and go back to the assert. Only then do I actually
notice the ASSERT_*FALSE* bit :)
If this is the way you prefer to do the checks, then that's fine but if you
don't mind changing them to ASSERT_TRUE(ptr != NULL) then that would imho make
them more readable.

I guess my reasoning would be that for all conditional statements in C++ (if(),
while() do()) there is no if_not(), while_not(), do_not(), so we're accustomed
to look at the expression and evaluate whether it's true or not and not false or
not.

[Per K, 2011/06/27 11:47:50]

Done.

+
+  scoped_ptr<VideoCaptureDevice> device2(
+      VideoCaptureDevice::Create(names_.front()));
+  ASSERT_FALSE(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) {
+  scoped_ptr<VideoCaptureDevice> device(
+      VideoCaptureDevice::Create(names_.front()));
+  ASSERT_FALSE(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) {
+  scoped_ptr<VideoCaptureDevice> device(
+      VideoCaptureDevice::Create(names_.front()));
+  ASSERT_FALSE(device.get() == NULL);
+  EXPECT_CALL(*frame_observer_, OnErr())
+      .Times(0);
+  // get info about the new resolution
+  EXPECT_CALL(*frame_observer_, OnFrameInfo(640, 480, _));
+
+  EXPECT_CALL(*frame_observer_, OnFrameInfo(320, 240, _));
+
+  device->Allocate(640, 480, 30, frame_observer_.get());
+  device->Start();
+  // Nothing shall happen.
+  device->Allocate(1280, 1024, 30, frame_observer_.get());
+  device->DeAllocate();
+  // Allocate new size 320, 240
+  device->Allocate(320, 240, 30, frame_observer_.get());
+
+  device->Start();
+  // Get captured video frames.
+  EXPECT_TRUE(wait_event_.TimedWait(base::TimeDelta::FromMilliseconds(1000)));
+  device->Stop();
+  device->DeAllocate();
+}
+
+TEST_F(VideoCaptureDeviceTest, DeAllocateCameraWhileRunning) {
+  scoped_ptr<VideoCaptureDevice> device(
+      VideoCaptureDevice::Create(names_.front()));
+  ASSERT_FALSE(device.get() == NULL);
+
+  // 1. 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(1000)));
+  device->DeAllocate();
+}
+
+TEST_F(VideoCaptureDeviceTest, TestFakeCapture) {
+  VideoCaptureDevice::Names names;
+
+  FakeVideoCaptureDevice::GetDeviceNames(&names);
+
+  ASSERT_GT(static_cast<int>(names.size()), 0);
+
+  scoped_ptr<VideoCaptureDevice> device(
+      FakeVideoCaptureDevice::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();
+  EXPECT_TRUE(wait_event_.TimedWait(base::TimeDelta::FromMilliseconds(1000)));
+  device->Stop();
+  device->DeAllocate();
+}
+
+};  // namespace media