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

remoting/host/video_scheduler.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 <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop_proxy.h"
 #include "base/stl_util.h"
 #include "base/sys_info.h"
 #include "base/time.h"
-#include "remoting/capturer/capture_data.h"
-#include "remoting/capturer/mouse_cursor_shape.h"
-#include "remoting/capturer/video_frame_capturer.h"
+#include "media/video/capture/screen/mouse_cursor_shape.h"
+#include "media/video/capture/screen/screen_capture_data.h"
+#include "media/video/capture/screen/screen_capturer.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/internal.pb.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/cursor_shape_stub.h"
 #include "remoting/protocol/message_decoder.h"
 #include "remoting/protocol/video_stub.h"
 #include "remoting/protocol/util.h"
 
 namespace remoting {
 
 // Maximum number of frames that can be processed simultaneously.
 // TODO(hclam): Move this value to CaptureScheduler.
 static const int kMaxPendingCaptures = 2;
 
 // static
 scoped_refptr<VideoScheduler> VideoScheduler::Create(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
-    scoped_ptr<VideoFrameCapturer> capturer,
+    scoped_ptr<media::ScreenCapturer> capturer,
     scoped_ptr<VideoEncoder> encoder,
     protocol::CursorShapeStub* cursor_stub,
     protocol::VideoStub* video_stub) {
   DCHECK(network_task_runner->BelongsToCurrentThread());
   DCHECK(capturer);
   DCHECK(encoder);
   DCHECK(cursor_stub);
   DCHECK(video_stub);
 
   scoped_refptr<VideoScheduler> scheduler = new VideoScheduler(
       capture_task_runner, encode_task_runner, network_task_runner,
       capturer.Pass(), encoder.Pass(), cursor_stub, video_stub);
   capture_task_runner->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::StartOnCaptureThread, scheduler));
 
   return scheduler;
 }
 
 // Public methods --------------------------------------------------------------
 
 void VideoScheduler::OnCaptureCompleted(
-    scoped_refptr<CaptureData> capture_data) {
+    scoped_refptr<media::ScreenCaptureData> capture_data) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   if (capture_data) {
     scheduler_.RecordCaptureTime(
         base::TimeDelta::FromMilliseconds(capture_data->capture_time_ms()));
 
     // The best way to get this value is by binding the sequence number to
     // the callback when calling CaptureInvalidRects(). However the callback
     // system doesn't allow this. Reading from the member variable is
     // accurate as long as capture is synchronous as the following statement
     // will obtain the most recent sequence number received.
     capture_data->set_client_sequence_number(sequence_number_);
   }
 
   encode_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::EncodeFrame, this, capture_data));
 }
 
 void VideoScheduler::OnCursorShapeChanged(
-    scoped_ptr<MouseCursorShape> cursor_shape) {
+    scoped_ptr<media::MouseCursorShape> cursor_shape) {
   DCHECK(capture_task_runner_->BelongsToCurrentThread());
 
   scoped_ptr<protocol::CursorShapeInfo> cursor_proto(
       new protocol::CursorShapeInfo());
   cursor_proto->set_width(cursor_shape->size.width());
   cursor_proto->set_height(cursor_shape->size.height());
   cursor_proto->set_hotspot_x(cursor_shape->hotspot.x());
   cursor_proto->set_hotspot_y(cursor_shape->hotspot.y());
   cursor_proto->set_data(cursor_shape->data);
 
@@ skipping 41 matching lines @@
 
   sequence_number_ = sequence_number;
 }
 
 // Private methods -----------------------------------------------------------
 
 VideoScheduler::VideoScheduler(
     scoped_refptr<base::SingleThreadTaskRunner> capture_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> encode_task_runner,
     scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
-    scoped_ptr<VideoFrameCapturer> capturer,
+    scoped_ptr<media::ScreenCapturer> capturer,
     scoped_ptr<VideoEncoder> encoder,
     protocol::CursorShapeStub* cursor_stub,
     protocol::VideoStub* video_stub)
     : capture_task_runner_(capture_task_runner),
       encode_task_runner_(encode_task_runner),
       network_task_runner_(network_task_runner),
       capturer_(capturer.Pass()),
       encoder_(encoder.Pass()),
       cursor_stub_(cursor_stub),
       video_stub_(video_stub),
@@ skipping 118 matching lines @@
     scoped_ptr<protocol::CursorShapeInfo> cursor_shape) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   if (!cursor_stub_)
     return;
 
   cursor_stub_->SetCursorShape(*cursor_shape);
 }
 
 void VideoScheduler::StopOnNetworkThread(
-    scoped_ptr<VideoFrameCapturer> capturer) {
+    scoped_ptr<media::ScreenCapturer> capturer) {
   DCHECK(network_task_runner_->BelongsToCurrentThread());
 
   // This is posted by StopOnEncodeThread meaning that both capture and encode
   // threads are stopped now and it is safe to delete |capturer|.
 }
 
 // Encoder thread --------------------------------------------------------------
 
 void VideoScheduler::EncodeFrame(
-    scoped_refptr<CaptureData> capture_data) {
+    scoped_refptr<media::ScreenCaptureData> capture_data) {
   DCHECK(encode_task_runner_->BelongsToCurrentThread());
 
   // If there is nothing to encode then send an empty keep-alive packet.
   if (!capture_data || capture_data->dirty_region().isEmpty()) {
     scoped_ptr<VideoPacket> packet(new VideoPacket());
     packet->set_flags(VideoPacket::LAST_PARTITION);
     network_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
                               base::Passed(&packet)));
     return;
@@ skipping 13 matching lines @@
     scheduler_.RecordEncodeTime(
         base::TimeDelta::FromMilliseconds(packet->encode_time_ms()));
   }
 
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::SendVideoPacket, this,
                             base::Passed(&packet)));
 }
 
 void VideoScheduler::StopOnEncodeThread(
-    scoped_ptr<VideoFrameCapturer> capturer) {
+    scoped_ptr<media::ScreenCapturer> capturer) {
   DCHECK(encode_task_runner_->BelongsToCurrentThread());
 
   // This is posted by StopOnCaptureThread, so we know that by the time we
   // process it there are no more encode tasks queued. Pass |capturer_| for
   // deletion on the thread that created it.
   network_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoScheduler::StopOnNetworkThread, this,
                             base::Passed(&capturer)));
 }
 
 }  // namespace remoting