Move screen capturers to remoting/capturer.

remoting/capturer/video_frame_capturer_linux.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_frame_capturer.h"
+#include "remoting/capturer/video_frame_capturer.h"
 
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xdamage.h>
 #include <X11/extensions/Xfixes.h>
 
 #include <set>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/stl_util.h"
 #include "base/time.h"
-#include "remoting/base/capture_data.h"
-#include "remoting/host/differ.h"
-#include "remoting/host/linux/x_server_pixel_buffer.h"
-#include "remoting/host/video_frame.h"
-#include "remoting/host/video_frame_capturer_helper.h"
-#include "remoting/host/video_frame_queue.h"
-#include "remoting/proto/control.pb.h"
+#include "remoting/capturer/capture_data.h"
+#include "remoting/capturer/differ.h"
+#include "remoting/capturer/linux/x_server_pixel_buffer.h"
+#include "remoting/capturer/mouse_cursor_shape.h"
+#include "remoting/capturer/video_frame.h"
+#include "remoting/capturer/video_frame_capturer_helper.h"
+#include "remoting/capturer/video_frame_queue.h"
 
 namespace remoting {
 
 namespace {
 
 static const int kBytesPerPixel = 4;
 
 // Default to false, since many systems have broken XDamage support - see
 // http://crbug.com/73423.
 static bool g_should_use_x_damage = false;
@@ skipping 332 matching lines @@
 }
 
 void VideoFrameCapturerLinux::CaptureCursor() {
   DCHECK(has_xfixes_);
 
   XFixesCursorImage* img = XFixesGetCursorImage(display_);
   if (!img) {
     return;
   }
 
-  int width = img->width;
-  int height = img->height;
-  int total_bytes = width * height * kBytesPerPixel;
+  MouseCursorShape cursor;
+  cursor.width = img->width;
+  cursor.height = img->height;
+  cursor.hotspot_x = img->xhot;
+  cursor.hotspot_y = img->yhot;
 
-  scoped_ptr<protocol::CursorShapeInfo> cursor_proto(
-      new protocol::CursorShapeInfo());
-  cursor_proto->set_width(width);
-  cursor_proto->set_height(height);
-  cursor_proto->set_hotspot_x(img->xhot);
-  cursor_proto->set_hotspot_y(img->yhot);
-
-  cursor_proto->mutable_data()->resize(total_bytes);
-  uint8* proto_data = const_cast<uint8*>(reinterpret_cast<const uint8*>(
-      cursor_proto->mutable_data()->data()));
+  int total_bytes = cursor.width * cursor.height * kBytesPerPixel;
+  cursor.data.resize(total_bytes);
 
   // Xlib stores 32-bit data in longs, even if longs are 64-bits long.
   unsigned long* src = img->pixels;
-  uint32* dst = reinterpret_cast<uint32*>(proto_data);
-  uint32* dst_end = dst + (width * height);
+  uint32* dst = reinterpret_cast<uint32*>(string_as_array(&cursor.data));
+  uint32* dst_end = dst + (img->width * img->height);
   while (dst < dst_end) {
     *dst++ = static_cast<uint32>(*src++);
   }
   XFree(img);
 
-  delegate_->OnCursorShapeChanged(cursor_proto.Pass());
+  delegate_->OnCursorShapeChanged(cursor);

[Wez, 2012/12/11 05:23:18]

We deliberately had the recipient own the cursor, so that it can be passed
around if necessary, e.g. to another thread for encoding to write to the wire.

[Sergey Ulanov, 2012/12/12 18:31:12]

Changed it to passing pointers, though I don't think it matters much. Cursor
objects are small and it's even less of a problem given that many STL
implementations use ref-counting for std::string.

 }
 
 CaptureData* VideoFrameCapturerLinux::CaptureScreen() {
   VideoFrame* current = queue_.current_frame();
   DataPlanes planes;
   planes.data[0] = current->pixels();
   planes.strides[0] = current->bytes_per_row();
 
   CaptureData* capture_data = new CaptureData(planes, current->dimensions(),
                                               media::VideoFrame::RGB32);
@@ skipping 222 matching lines @@
   NOTIMPLEMENTED();
   return scoped_ptr<VideoFrameCapturer>();
 }
 
 // static
 void VideoFrameCapturer::EnableXDamage(bool enable) {
   g_should_use_x_damage = enable;
 }
 
 }  // namespace remoting