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

remoting/host/desktop_session_agent.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/desktop_session_agent.h"
 
 #include "base/logging.h"
 #include "ipc/ipc_channel_proxy.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_message_macros.h"
+#include "media/video/capture/screen/screen_capture_data.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/base/constants.h"
 #include "remoting/base/util.h"
-#include "remoting/capturer/capture_data.h"
 #include "remoting/host/audio_capturer.h"
 #include "remoting/host/chromoting_messages.h"
 #include "remoting/host/disconnect_window.h"
 #include "remoting/host/event_executor.h"
 #include "remoting/host/local_input_monitor.h"
 #include "remoting/host/remote_input_filter.h"
 #include "remoting/proto/audio.pb.h"
 #include "remoting/proto/control.pb.h"
 #include "remoting/proto/event.pb.h"
 #include "remoting/protocol/clipboard_stub.h"
@@ skipping 105 matching lines @@
   if (delegate_.get())
     delegate_->OnNetworkProcessDisconnected();
 }
 
 void DesktopSessionAgent::OnLocalMouseMoved(const SkIPoint& new_pos) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
   remote_input_filter_->LocalMouseMoved(new_pos);
 }
 
-scoped_refptr<SharedBuffer> DesktopSessionAgent::CreateSharedBuffer(
+scoped_refptr<media::SharedBuffer> DesktopSessionAgent::CreateSharedBuffer(
     uint32 size) {
   DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
 
-  scoped_refptr<SharedBuffer> buffer = new SharedBuffer(size);
+  scoped_refptr<media::SharedBuffer> buffer = new media::SharedBuffer(size);
   if (buffer->ptr() != NULL) {
     buffer->set_id(next_shared_buffer_id_);
     shared_buffers_.push_back(buffer);
 
     // |next_shared_buffer_id_| starts from 1 and incrementing it by 2 makes
     // sure it is always odd and therefore zero is never used as a valid buffer
     // ID.
     //
     // It is very unlikely (though theoretically possible) to allocate the same
     // ID for two different buffers due to integer overflow. It should take
     // about a year of allocating 100 new buffers every second. Practically
     // speaking it never happens.
     next_shared_buffer_id_ += 2;
 
     SendToNetwork(new ChromotingDesktopNetworkMsg_CreateSharedBuffer(
         buffer->id(), buffer->handle(), buffer->size()));
   }
 
   return buffer;
 }
 
 void DesktopSessionAgent::ReleaseSharedBuffer(
-    scoped_refptr<SharedBuffer> buffer) {
+    scoped_refptr<media::SharedBuffer> buffer) {
   DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
   DCHECK(buffer->id() != 0);
 
   SendToNetwork(
       new ChromotingDesktopNetworkMsg_ReleaseSharedBuffer(buffer->id()));
 }
 
 void DesktopSessionAgent::OnStartSessionAgent(
     const std::string& authenticated_jid) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
@@ skipping 29 matching lines @@
   // Start the audio capturer.
   audio_capture_task_runner()->PostTask(
       FROM_HERE, base::Bind(&DesktopSessionAgent::StartAudioCapturer, this));
 
   // Start the video capturer.
   video_capture_task_runner()->PostTask(
       FROM_HERE, base::Bind(&DesktopSessionAgent::StartVideoCapturer, this));
 }
 
 void DesktopSessionAgent::OnCaptureCompleted(
-    scoped_refptr<CaptureData> capture_data) {
+    scoped_refptr<media::ScreenCaptureData> capture_data) {
   DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
 
   current_size_ = capture_data->size();
 
-  // Serialize CaptureData
+  // Serialize media::ScreenCaptureData
   SerializedCapturedData serialized_data;
   serialized_data.shared_buffer_id = capture_data->shared_buffer()->id();
   serialized_data.bytes_per_row = capture_data->stride();
   serialized_data.dimensions = capture_data->size();
   serialized_data.capture_time_ms = capture_data->capture_time_ms();
   serialized_data.client_sequence_number =
       capture_data->client_sequence_number();
   serialized_data.dpi = capture_data->dpi();
   for (SkRegion::Iterator i(capture_data->dirty_region()); !i.done(); i.next())
     serialized_data.dirty_region.push_back(i.rect());
 
   SendToNetwork(
       new ChromotingDesktopNetworkMsg_CaptureCompleted(serialized_data));
 }
 
 void DesktopSessionAgent::OnCursorShapeChanged(
-    scoped_ptr<MouseCursorShape> cursor_shape) {
+    scoped_ptr<media::MouseCursorShape> cursor_shape) {
   DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
 
   SendToNetwork(new ChromotingDesktopNetworkMsg_CursorShapeChanged(
       *cursor_shape));
 }
 
 void DesktopSessionAgent::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
   DCHECK(caller_task_runner()->BelongsToCurrentThread());
 
@@ skipping 68 matching lines @@
 }
 
 void DesktopSessionAgent::OnCaptureFrame() {
   if (!video_capture_task_runner()->BelongsToCurrentThread()) {
     video_capture_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&DesktopSessionAgent::OnCaptureFrame, this));
     return;
   }
 
-  // VideoFrameCapturer supports a very few (currently 2) outstanding capture
+  // media::ScreenCapturer supports a very few (currently 2) outstanding capture
   // requests. The requests are serialized on |video_capture_task_runner()| task
   // runner. If the client issues more requests, pixel data in captured frames
-  // will likely be corrupted but stability of VideoFrameCapturer will not be
+  // will likely be corrupted but stability of media::ScreenCapturer will not be
   // affected.
   video_capturer_->CaptureFrame();
 }
 
 void DesktopSessionAgent::OnInvalidateRegion(
     const std::vector<SkIRect>& invalid_rects) {
   if (!video_capture_task_runner()->BelongsToCurrentThread()) {
     video_capture_task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&DesktopSessionAgent::OnInvalidateRegion, this,
@@ skipping 137 matching lines @@
 
 void DesktopSessionAgent::StopAudioCapturer() {
   DCHECK(audio_capture_task_runner()->BelongsToCurrentThread());
 
   audio_capturer_.reset();
 }
 
 void DesktopSessionAgent::StartVideoCapturer() {
   DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
 
-  video_capturer_ = VideoFrameCapturer::CreateWithFactory(this);
+  video_capturer_ = media::ScreenCapturer::CreateWithFactory(this);
   if (video_capturer_)
     video_capturer_->Start(this);
 }
 
 void DesktopSessionAgent::StopVideoCapturer() {
   DCHECK(video_capture_task_runner()->BelongsToCurrentThread());
 
   if (video_capturer_) {
     video_capturer_->Stop();
     video_capturer_.reset();
@@ skipping 14 matching lines @@
       input_task_runner_(input_task_runner),
       io_task_runner_(io_task_runner),
       video_capture_task_runner_(video_capture_task_runner),
       current_size_(SkISize::Make(0, 0)),
       next_shared_buffer_id_(1),
       started_(false) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 }
 
 }  // namespace remoting