Switch DesktopEnvironment to return a DesktopCapturer.

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/message_loop.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "remoting/base/auto_thread.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/codec/video_encoder_verbatim.h"
+#include "remoting/host/fake_desktop_capturer.h"
 #include "remoting/host/fake_mouse_cursor_monitor.h"
-#include "remoting/host/fake_screen_capturer.h"
 #include "remoting/host/host_mock_objects.h"
 #include "remoting/proto/control.pb.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"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 #include "third_party/webrtc/modules/desktop_capture/mouse_cursor.h"
 #include "third_party/webrtc/modules/desktop_capture/screen_capturer_mock_objects.h"
 
@@ skipping 58 matching lines @@
   virtual ~ThreadCheckVideoEncoder() {
     EXPECT_TRUE(task_runner_->BelongsToCurrentThread());
   }
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadCheckVideoEncoder);
 };
 
-class ThreadCheckScreenCapturer : public FakeScreenCapturer {
+class ThreadCheckDesktopCapturer : public FakeDesktopCapturer {
  public:
-  ThreadCheckScreenCapturer(
+  ThreadCheckDesktopCapturer(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner)
       : task_runner_(task_runner) {
   }
-  virtual ~ThreadCheckScreenCapturer() {
+  virtual ~ThreadCheckDesktopCapturer() {
     EXPECT_TRUE(task_runner_->BelongsToCurrentThread());
   }
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
-  DISALLOW_COPY_AND_ASSIGN(ThreadCheckScreenCapturer);
+  DISALLOW_COPY_AND_ASSIGN(ThreadCheckDesktopCapturer);
 };
 
 class ThreadCheckMouseCursorMonitor : public FakeMouseCursorMonitor {
  public:
   ThreadCheckMouseCursorMonitor(
       scoped_refptr<base::SingleThreadTaskRunner> task_runner)
       : task_runner_(task_runner) {
   }
   virtual ~ThreadCheckMouseCursorMonitor() {
     EXPECT_TRUE(task_runner_->BelongsToCurrentThread());
   }
 
  private:
   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(ThreadCheckMouseCursorMonitor);
 };
 
 class VideoSchedulerTest : public testing::Test {
  public:
   VideoSchedulerTest();
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   void StartVideoScheduler(
-      scoped_ptr<webrtc::ScreenCapturer> capturer,
+      scoped_ptr<webrtc::DesktopCapturer> capturer,
       scoped_ptr<VideoEncoder> encoder,
       scoped_ptr<webrtc::MouseCursorMonitor> mouse_monitor);
   void StopVideoScheduler();
 
-  // webrtc::ScreenCapturer mocks.
-  void OnCapturerStart(webrtc::ScreenCapturer::Callback* callback);
+  // webrtc::DesktopCapturer mocks.
+  void OnCapturerStart(webrtc::DesktopCapturer::Callback* callback);
   void OnCaptureFrame(const webrtc::DesktopRegion& region);
+
+  // webrtc::MouseCursorMonitor mocks.
   void OnMouseCursorMonitorInit(
       webrtc::MouseCursorMonitor::Callback* callback,
       webrtc::MouseCursorMonitor::Mode mode);
   void OnCaptureMouse();
   void SetCursorShape(const protocol::CursorShapeInfo& cursor_shape);
 
  protected:
   base::MessageLoop message_loop_;
   base::RunLoop run_loop_;
   scoped_refptr<AutoThreadTaskRunner> capture_task_runner_;
   scoped_refptr<AutoThreadTaskRunner> encode_task_runner_;
   scoped_refptr<AutoThreadTaskRunner> main_task_runner_;
   scoped_refptr<VideoScheduler> scheduler_;
 
   MockClientStub client_stub_;
   MockVideoStub video_stub_;
 
-  // Points to the callback passed to webrtc::ScreenCapturer::Start().
-  webrtc::ScreenCapturer::Callback* capturer_callback_;
+  // Points to the callback passed to webrtc::DesktopCapturer::Start().
+  webrtc::DesktopCapturer::Callback* capturer_callback_;
 
   // Points to the callback passed to webrtc::MouseCursor::Init().
   webrtc::MouseCursorMonitor::Callback* mouse_monitor_callback_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(VideoSchedulerTest);
 };
 
 VideoSchedulerTest::VideoSchedulerTest()
     : capturer_callback_(NULL),
@@ skipping 11 matching lines @@
   // Release the task runners, so that the test can quit.
   capture_task_runner_ = NULL;
   encode_task_runner_ = NULL;
   main_task_runner_ = NULL;
 
   // Run the MessageLoop until everything has torn down.
   run_loop_.Run();
 }
 
 void VideoSchedulerTest::StartVideoScheduler(
-    scoped_ptr<webrtc::ScreenCapturer> capturer,
+    scoped_ptr<webrtc::DesktopCapturer> capturer,
     scoped_ptr<VideoEncoder> encoder,
     scoped_ptr<webrtc::MouseCursorMonitor> mouse_monitor) {
   scheduler_ = new VideoScheduler(
       capture_task_runner_,
       encode_task_runner_,
       main_task_runner_,
       capturer.Pass(),
       mouse_monitor.Pass(),
       encoder.Pass(),
       &client_stub_,
       &video_stub_);
   scheduler_->Start();
 }
 
 void VideoSchedulerTest::StopVideoScheduler() {
   scheduler_->Stop();
   scheduler_ = NULL;
 }
 
 void VideoSchedulerTest::OnCapturerStart(
-    webrtc::ScreenCapturer::Callback* callback) {
+    webrtc::DesktopCapturer::Callback* callback) {
   EXPECT_FALSE(capturer_callback_);
   EXPECT_TRUE(callback);
 
   capturer_callback_ = callback;
 }
 
 void VideoSchedulerTest::OnCaptureFrame(const webrtc::DesktopRegion& region) {
   scoped_ptr<webrtc::DesktopFrame> frame(
       new webrtc::BasicDesktopFrame(webrtc::DesktopSize(kWidth, kHeight)));
   frame->mutable_updated_region()->SetRect(
@@ skipping 83 matching lines @@
           FinishSend(),
           InvokeWithoutArgs(this, &VideoSchedulerTest::StopVideoScheduler)))
       .RetiresOnSaturation();
 
   EXPECT_CALL(client_stub_, SetCursorShape(_))
       .WillOnce(Invoke(this, &VideoSchedulerTest::SetCursorShape));
 
   // Start video frame capture.
   scoped_ptr<webrtc::MouseCursorMonitor> mouse_cursor_monitor(
       new FakeMouseCursorMonitor());
-  StartVideoScheduler(capturer.PassAs<webrtc::ScreenCapturer>(),
+  StartVideoScheduler(capturer.PassAs<webrtc::DesktopCapturer>(),
                       encoder.PassAs<VideoEncoder>(),
                       cursor_monitor.PassAs<webrtc::MouseCursorMonitor>());
 
   // Run until there are no more pending tasks from the VideoScheduler.
   // Otherwise, a lingering frame capture might attempt to trigger a capturer
   // expectation action and crash.
   base::RunLoop().RunUntilIdle();
 }
 
 // Verify that the capturer, encoder and mouse monitor are torn down on the
 // correct threads.
 TEST_F(VideoSchedulerTest, DeleteOnThreads) {
   capture_task_runner_ = AutoThread::Create("capture", main_task_runner_);
   encode_task_runner_ = AutoThread::Create("encode", main_task_runner_);
 
-  scoped_ptr<webrtc::ScreenCapturer> capturer(
-      new ThreadCheckScreenCapturer(capture_task_runner_));
+  scoped_ptr<webrtc::DesktopCapturer> capturer(
+      new ThreadCheckDesktopCapturer(capture_task_runner_));
   scoped_ptr<VideoEncoder> encoder(
       new ThreadCheckVideoEncoder(encode_task_runner_));
   scoped_ptr<webrtc::MouseCursorMonitor> mouse_cursor_monitor(
       new ThreadCheckMouseCursorMonitor(capture_task_runner_));
 
   // Start and stop the scheduler, so it will tear down the screen capturer,
   // video encoder and mouse monitor.
   StartVideoScheduler(capturer.Pass(), encoder.Pass(),
                       mouse_cursor_monitor.Pass());
   StopVideoScheduler();
 }
 
 }  // namespace remoting