Implement screen capturer for MediaStream API.

media/video/capture/screen/screen_capture_device_unittest.cc

+// Copyright (c) 2012 The Chromium Authors. All rights reserved.

[Wez, 2013/01/31 00:15:29]

Drop (c), change to 2013.

[Sergey Ulanov, 2013/01/31 02:05:43]

same as in the other two files.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "media/video/capture/screen/screen_capture_device.h"
+
+#include "base/basictypes.h"
+#include "base/sequenced_task_runner.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/test/test_timeouts.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "base/time.h"
+#include "media/video/capture/screen/screen_capture_data.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::_;
+using ::testing::DoAll;
+using ::testing::InvokeWithoutArgs;
+using ::testing::SaveArg;
+
+namespace media {
+
+namespace {

[Wez, 2013/01/31 00:15:29]

nit: Blank line after namespace, for consistency :)

[Sergey Ulanov, 2013/01/31 02:05:43]

Done.

+const int kTestFrameWidth1 = 100;
+const int kTestFrameHeight1 = 100;
+const int kTestFrameWidth2 = 200;
+const int kTestFrameHeight2 = 150;
+const int kBufferSize = kTestFrameWidth2 * kTestFrameHeight2 * 4;
+
+const int kFrameRate = 30;
+
+class MockFrameObserver : public VideoCaptureDevice::EventHandler {

[Wez, 2013/01/31 00:15:29]

Is there really no other test that ever needs to mock this interface?

[Sergey Ulanov, 2013/01/31 02:05:43]

There is one in media/video/capture/video_capture_device_unittest.cc, but it's
different.

+ public:
+  MOCK_METHOD0(OnError, void());
+  MOCK_METHOD1(OnFrameInfo, void(const VideoCaptureCapability& info));
+  MOCK_METHOD3(OnIncomingCapturedFrame, void(const uint8* data, int length,
+                                             base::Time timestamp));
+};
+
+}  // namespace
+
+class FakeScreenCapturer : public ScreenCapturer {

[Wez, 2013/01/31 00:15:29]

We used to have a FakeScreenCapturer in remoting/host/ to use for tests, but it
got removed because no tests were making use of it; with this test and the ones
alexeypa@ is working on, perhaps it's better to move this out to be more
re-usable in a follow-up CL?

[Wez, 2013/01/31 00:15:29]

If this class stays here it should live in the anonymous namespace, too.

[Sergey Ulanov, 2013/01/31 02:05:43]

Added TODO.

[Sergey Ulanov, 2013/01/31 02:05:43]

Done.

+ public:
+  FakeScreenCapturer()
+      : delegate_(NULL),
+        frame_index_(0) {
+    buffer_.reset(new uint8[kBufferSize]);
+    frames_[0] = new ScreenCaptureData(
+        buffer_.get(), kTestFrameWidth1 * ScreenCaptureData::kBytesPerPixel,
+        SkISize::Make(kTestFrameWidth1, kTestFrameHeight1));
+    frames_[1] = new ScreenCaptureData(
+        buffer_.get(), kTestFrameWidth2 * ScreenCaptureData::kBytesPerPixel,
+        SkISize::Make(kTestFrameWidth2, kTestFrameHeight2));
+  }
+  virtual ~FakeScreenCapturer() {}
+
+  // VideoFrameCapturer interface.
+  virtual void Start(Delegate* delegate) OVERRIDE {
+    delegate_ = delegate;
+  }
+  virtual void Stop() OVERRIDE {
+    delegate_ = NULL;
+  }
+  virtual void InvalidateRegion(const SkRegion& invalid_region) OVERRIDE {
+    NOTIMPLEMENTED();
+  }
+  virtual void CaptureFrame() OVERRIDE {
+    scoped_refptr<ScreenCaptureData> frame =
+        frames_[frame_index_ % arraysize(frames_)];
+    frame_index_++;
+    delegate_->OnCaptureCompleted(frame);
+  }
+
+ private:
+  Delegate* delegate_;
+  scoped_array<uint8> buffer_;
+  scoped_refptr<ScreenCaptureData> frames_[2];
+  int frame_index_;
+};
+
+

[Wez, 2013/01/31 00:15:29]

nit: Spurious blank line!

[Sergey Ulanov, 2013/01/31 02:05:43]

Done.

+class ScreenCaptureDeviceTest : public testing::Test {
+ public:
+  virtual void SetUp() OVERRIDE {
+    worker_pool_ = new base::SequencedWorkerPool(3, "TestCaptureThread");
+  }
+
+ protected:
+  scoped_refptr<base::SequencedWorkerPool> worker_pool_;
+};
+
+TEST_F(ScreenCaptureDeviceTest, Capture) {
+  ScreenCaptureDevice capture_device(
+      worker_pool_->GetSequencedTaskRunner(worker_pool_->GetSequenceToken()));
+  VideoCaptureCapability caps;
+  base::WaitableEvent done_event(false, false);
+  int frame_size;
+
+  MockFrameObserver frame_observer;
+  EXPECT_CALL(frame_observer, OnFrameInfo(_))
+      .WillOnce(SaveArg<0>(&caps));
+  EXPECT_CALL(frame_observer, OnError())
+      .Times(0);
+  EXPECT_CALL(frame_observer, OnIncomingCapturedFrame(_, _, _))
+      .WillRepeatedly(DoAll(
+          SaveArg<1>(&frame_size),
+          InvokeWithoutArgs(&done_event, &base::WaitableEvent::Signal)));
+
+  capture_device.Allocate(640, 480, kFrameRate, &frame_observer);
+  capture_device.Start();
+  EXPECT_TRUE(done_event.TimedWait(TestTimeouts::action_max_timeout()));
+  capture_device.Stop();
+  capture_device.DeAllocate();
+
+  EXPECT_GT(caps.width, 0);
+  EXPECT_GT(caps.height, 0);
+  EXPECT_EQ(kFrameRate, caps.frame_rate);

[Wez, 2013/01/31 00:15:29]

That seems a peculiar guarantee; do we really intend to always match whatever
rate we're asked for?  What if it's insanely/infeasibly high?

[Sergey Ulanov, 2013/01/31 02:05:43]

Actual frame rate may be slower when CPU is slow or busy, but we have no way to
know it when OnFrameInfo() is called.

+  EXPECT_EQ(VideoCaptureCapability::kARGB, caps.color);
+  EXPECT_EQ(false, caps.interlaced);
+
+  EXPECT_EQ(caps.width * caps.height * 4, frame_size);

[Wez, 2013/01/31 00:15:29]

Is it required that VideoCapturer implementations have stride==width?

[Sergey Ulanov, 2013/01/31 02:05:43]

Yes.

+}
+
+TEST_F(ScreenCaptureDeviceTest, ScreenResolutionChange) {
+  FakeScreenCapturer* mock_capturer = new FakeScreenCapturer();
+
+  ScreenCaptureDevice capture_device(
+      worker_pool_->GetSequencedTaskRunner(worker_pool_->GetSequenceToken()));
+  capture_device.set_test_screen_capturer(
+      scoped_ptr<ScreenCapturer>(mock_capturer));
+
+  VideoCaptureCapability caps;
+  base::WaitableEvent done_event(false, false);
+  int frame_size;
+
+  MockFrameObserver frame_observer;
+  EXPECT_CALL(frame_observer, OnFrameInfo(_))
+      .WillOnce(SaveArg<0>(&caps));
+  EXPECT_CALL(frame_observer, OnError())
+      .Times(0);
+  EXPECT_CALL(frame_observer, OnIncomingCapturedFrame(_, _, _))
+      .WillRepeatedly(DoAll(
+          SaveArg<1>(&frame_size),
+          InvokeWithoutArgs(&done_event, &base::WaitableEvent::Signal)));
+
+  capture_device.Allocate(640, 480, kFrameRate, &frame_observer);
+  capture_device.Start();
+  // Capture first frame.
+  EXPECT_TRUE(done_event.TimedWait(TestTimeouts::action_max_timeout()));
+  done_event.Reset();
+  // Capture second frame.
+  EXPECT_TRUE(done_event.TimedWait(TestTimeouts::action_max_timeout()));
+  capture_device.Stop();
+  capture_device.DeAllocate();

[Wez, 2013/01/31 00:15:29]

It's not clear to me what property of the class this is testing?

[Sergey Ulanov, 2013/01/31 02:05:43]

That it doesn't crash when screen resolution changes.

+
+  EXPECT_EQ(kTestFrameWidth1, caps.width);
+  EXPECT_EQ(kTestFrameHeight1, caps.height);
+  EXPECT_EQ(kFrameRate, caps.frame_rate);
+  EXPECT_EQ(VideoCaptureCapability::kARGB, caps.color);
+  EXPECT_EQ(false, caps.interlaced);
+
+  EXPECT_EQ(caps.width * caps.height * 4, frame_size);
+}
+
+}  // namespace media