Implement screen capturer for MediaStream API.

content/browser/renderer_host/media/screen_capturer_unittest.cc

Index: content/browser/renderer_host/media/screen_capturer_unittest.cc
diff --git a/content/browser/renderer_host/media/screen_capturer_unittest.cc b/content/browser/renderer_host/media/screen_capturer_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..3e48b9fff0e6f4d6fe3804c5f03d374f27f82102
--- /dev/null
+++ b/content/browser/renderer_host/media/screen_capturer_unittest.cc
@@ -0,0 +1,167 @@
+// Copyright (c) 2012 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/screen_capturer.h"
+
+#include "base/basictypes.h"
+#include "base/sequenced_task_runner.h"
+#include "base/synchronization/waitable_event.h"
+#include "base/threading/sequenced_worker_pool.h"
+#include "base/test/test_timeouts.h"
+#include "base/time.h"
+#include "remoting/capturer/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 content {
+
+namespace {
+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 media::VideoCaptureDevice::EventHandler {
+ public:
+  MOCK_METHOD0(OnError, void());
+  MOCK_METHOD1(OnFrameInfo, void(const media::VideoCaptureCapability& info));
+  MOCK_METHOD3(OnIncomingCapturedFrame, void(const uint8* data, int length,
+                                             base::Time timestamp));
+};
+
+}  // namespace
+
+class FakeVideoFrameCapturer : public remoting::VideoFrameCapturer {
+ public:
+  FakeVideoFrameCapturer()
+      : delegate_(NULL),
+        frame_index_(0) {
+    buffer_.reset(new uint8[kBufferSize]);
+    frames_[0] = new remoting::CaptureData(
+        buffer_.get(), kTestFrameWidth1 * remoting::CaptureData::kBytesPerPixel,
+        SkISize::Make(kTestFrameWidth1, kTestFrameHeight1));
+    frames_[1] = new remoting::CaptureData(
+        buffer_.get(), kTestFrameWidth2 * remoting::CaptureData::kBytesPerPixel,
+        SkISize::Make(kTestFrameWidth2, kTestFrameHeight2));
+  }
+  virtual ~FakeVideoFrameCapturer() {}
+
+  // VideoFrameCapturer interface.
+  virtual void Start(Delegate* delegate) OVERRIDE {
+    delegate_ = delegate;
+  }
+  virtual void Stop() OVERRIDE {
+    DCHECK(delegate_);
+    delegate_ = NULL;
+  }
+  virtual void InvalidateRegion(const SkRegion& invalid_region) OVERRIDE {
+    NOTIMPLEMENTED();
+  }
+  virtual void CaptureFrame() OVERRIDE {
+    scoped_refptr<remoting::CaptureData> frame =
+        frames_[frame_index_ % arraysize(frames_)];
+    frame_index_++;
+    delegate_->OnCaptureCompleted(frame);
+  }
+
+ private:
+  Delegate* delegate_;
+  scoped_array<uint8> buffer_;
+  scoped_refptr<remoting::CaptureData> frames_[2];
+  int frame_index_;
+};
+
+
+class ScreenCaptureTest : public testing::Test {
+ public:
+  virtual void SetUp() OVERRIDE {
+    worker_pool_ = new base::SequencedWorkerPool(3, "TestCaptureThread");
+  }
+
+ protected:
+  scoped_refptr<base::SequencedWorkerPool> worker_pool_;
+};
+
+TEST_F(ScreenCaptureTest, Capture) {
+  ScreenCapturer capturer(
+      worker_pool_->GetSequencedTaskRunner(worker_pool_->GetSequenceToken()));
+  media::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)));
+
+  capturer.Allocate(640, 480, kFrameRate, &frame_observer);
+  capturer.Start();
+  EXPECT_TRUE(done_event.TimedWait(TestTimeouts::action_max_timeout()));
+  capturer.Stop();
+  capturer.DeAllocate();
+
+  EXPECT_GT(caps.width, 0);
+  EXPECT_GT(caps.height, 0);
+  EXPECT_EQ(kFrameRate, caps.frame_rate);
+  EXPECT_EQ(media::VideoCaptureCapability::kARGB, caps.color);
+  EXPECT_EQ(false, caps.interlaced);
+
+  EXPECT_EQ(caps.width * caps.height * 4, frame_size);
+}
+
+TEST_F(ScreenCaptureTest, ScreenResolutionChange) {
+  FakeVideoFrameCapturer* mock_capturer = new FakeVideoFrameCapturer();
+
+  ScreenCapturer capturer(
+      worker_pool_->GetSequencedTaskRunner(worker_pool_->GetSequenceToken()));
+  capturer.set_test_frame_capturer(
+      scoped_ptr<remoting::VideoFrameCapturer>(mock_capturer));
+
+  media::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)));
+
+  capturer.Allocate(640, 480, kFrameRate, &frame_observer);
+  capturer.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()));
+  capturer.Stop();
+  capturer.DeAllocate();
+
+  EXPECT_EQ(kTestFrameWidth1, caps.width);
+  EXPECT_EQ(kTestFrameHeight1, caps.height);
+  EXPECT_EQ(kFrameRate, caps.frame_rate);
+  EXPECT_EQ(media::VideoCaptureCapability::kARGB, caps.color);
+  EXPECT_EQ(false, caps.interlaced);
+
+  EXPECT_EQ(caps.width * caps.height * 4, frame_size);
+}
+
+}  // namespace content