Move screen capturers from remoting/capturer to media/video/capturer/screen

remoting/host/video_scheduler_unittest.cc

 // 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 "remoting/host/video_scheduler.h"
 
 #include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
+#include "media/video/capture/screen/screen_capture_data.h"
+#include "media/video/capture/screen/screen_capturer_mock_objects.h"
 #include "remoting/base/auto_thread_task_runner.h"
-#include "remoting/capturer/capture_data.h"
-#include "remoting/capturer/video_capturer_mock_objects.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using ::remoting::protocol::MockClientStub;
 using ::remoting::protocol::MockVideoStub;
 
 using ::testing::_;
@@ skipping 26 matching lines @@
 
 static const int kWidth = 640;
 static const int kHeight = 480;
 
 class MockVideoEncoder : public VideoEncoder {
  public:
   MockVideoEncoder();
   virtual ~MockVideoEncoder();
 
   MOCK_METHOD3(Encode, void(
-      scoped_refptr<CaptureData> capture_data,
+      scoped_refptr<media::ScreenCaptureData> capture_data,
       bool key_frame,
       const DataAvailableCallback& data_available_callback));
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockVideoEncoder);
 };
 
 MockVideoEncoder::MockVideoEncoder() {}
 
 MockVideoEncoder::~MockVideoEncoder() {}
 
 class VideoSchedulerTest : public testing::Test {
  public:
   VideoSchedulerTest() {
   }
 
   virtual void SetUp() OVERRIDE {
     task_runner_ = new AutoThreadTaskRunner(
         message_loop_.message_loop_proxy(), run_loop_.QuitClosure());
 
     encoder_ = new MockVideoEncoder();
   }
 
-  void StartVideoScheduler(scoped_ptr<VideoFrameCapturer> capturer) {
+  void StartVideoScheduler(scoped_ptr<media::ScreenCapturer> capturer) {
     scheduler_ = VideoScheduler::Create(
         task_runner_, // Capture
         task_runner_, // Encode
         task_runner_, // Network
         capturer.Pass(),
         scoped_ptr<VideoEncoder>(encoder_),
         &client_stub_,
         &video_stub_);
   }
 
   void GenerateOnCaptureCompleted();
 
   void StopVideoScheduler();
 
  protected:
   MessageLoop message_loop_;
   base::RunLoop run_loop_;
   scoped_refptr<AutoThreadTaskRunner> task_runner_;
   scoped_refptr<VideoScheduler> scheduler_;
 
   MockClientStub client_stub_;
   MockVideoStub video_stub_;
 
   // The following mock objects are owned by VideoScheduler.
   MockVideoEncoder* encoder_;
 
-  scoped_refptr<CaptureData> data_;
+  scoped_refptr<media::ScreenCaptureData> data_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoSchedulerTest);
 };
 
 void VideoSchedulerTest::GenerateOnCaptureCompleted() {
   SkRegion update_region(SkIRect::MakeXYWH(0, 0, 10, 10));
   data_->mutable_dirty_region().op(update_region, SkRegion::kUnion_Op);
 
   scheduler_->OnCaptureCompleted(data_);
 }
 
 void VideoSchedulerTest::StopVideoScheduler() {
   scheduler_->Stop();
   scheduler_ = NULL;
 }
 
 // This test mocks capturer, encoder and network layer to simulate one capture
 // cycle. When the first encoded packet is submitted to the network
 // VideoScheduler is instructed to come to a complete stop. We expect the stop
 // sequence to be executed successfully.
 TEST_F(VideoSchedulerTest, StartAndStop) {
-  scoped_ptr<MockVideoFrameCapturer> capturer_(new MockVideoFrameCapturer());
-  Expectation capturer_start = EXPECT_CALL(*capturer_, Start(_));
+  scoped_ptr<media::MockScreenCapturer> capturer(
+    new media::MockScreenCapturer());
+  Expectation capturer_start = EXPECT_CALL(*capturer, Start(_));
 
-  data_ = new CaptureData(NULL, kWidth * CaptureData::kBytesPerPixel,
-                          SkISize::Make(kWidth, kHeight));
+  data_ = new media::ScreenCaptureData(
+      NULL, kWidth * media::ScreenCaptureData::kBytesPerPixel,
+      SkISize::Make(kWidth, kHeight));
 
   // First the capturer is called.
-  Expectation capturer_capture = EXPECT_CALL(*capturer_, CaptureFrame())
+  Expectation capturer_capture = EXPECT_CALL(*capturer, CaptureFrame())
       .After(capturer_start)
       .WillRepeatedly(InvokeWithoutArgs(
           this, &VideoSchedulerTest::GenerateOnCaptureCompleted));
 
   // Expect the encoder be called.
   EXPECT_CALL(*encoder_, Encode(data_, false, _))
       .WillRepeatedly(FinishEncode());
 
   // By default delete the arguments when ProcessVideoPacket is received.
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
       .WillRepeatedly(FinishSend());
 
   // For the first time when ProcessVideoPacket is received we stop the
   // VideoScheduler.
   EXPECT_CALL(video_stub_, ProcessVideoPacketPtr(_, _))
       .WillOnce(DoAll(
           FinishSend(),
           InvokeWithoutArgs(this, &VideoSchedulerTest::StopVideoScheduler)))
       .RetiresOnSaturation();
 
-  EXPECT_CALL(*capturer_, Stop())
+  EXPECT_CALL(*capturer, Stop())
       .After(capturer_capture);
 
   // Start video frame capture.
-  StartVideoScheduler(capturer_.PassAs<VideoFrameCapturer>());
+  StartVideoScheduler(capturer.PassAs<media::ScreenCapturer>());
 
   task_runner_ = NULL;
   run_loop_.Run();
 }
 
 }  // namespace remoting