Move screen capturers to remoting/capturer.

remoting/capturer/video_frame_capturer_win.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 <windows.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/scoped_native_library.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_hdc.h"
-#include "remoting/base/capture_data.h"
-#include "remoting/base/shared_buffer_factory.h"
-#include "remoting/host/differ.h"
-#include "remoting/host/video_frame.h"
-#include "remoting/host/video_frame_capturer_helper.h"
-#include "remoting/host/video_frame_queue.h"
-#include "remoting/host/win/desktop.h"
-#include "remoting/host/win/scoped_thread_desktop.h"
+#include "remoting/capturer/capture_data.h"
+#include "remoting/capturer/differ.h"
+#include "remoting/capturer/mouse_cursor_shape.h"
+#include "remoting/capturer/shared_buffer_factory.h"
+#include "remoting/capturer/video_frame.h"
+#include "remoting/capturer/video_frame_capturer_helper.h"
+#include "remoting/capturer/video_frame_queue.h"
+#include "remoting/capturer/win/desktop.h"
+#include "remoting/capturer/win/scoped_thread_desktop.h"
 #include "remoting/proto/control.pb.h"
 #include "third_party/skia/include/core/SkColorPriv.h"
 
 namespace remoting {
 
 namespace {
 
 // Constants from dwmapi.h.
 const UINT DWM_EC_DISABLECOMPOSITION = 0;
 const UINT DWM_EC_ENABLECOMPOSITION = 1;
@@ skipping 75 matching lines @@
 
   Delegate* delegate_;
 
   // A thread-safe list of invalid rectangles, and the size of the most
   // recently captured screen.
   VideoFrameCapturerHelper helper_;
 
   // Snapshot of the last cursor bitmap we sent to the client. This is used
   // to diff against the current cursor so we only send a cursor-change
   // message when the shape has changed.
-  scoped_array<uint8> last_cursor_;
-  SkISize last_cursor_size_;
+  MouseCursorShape last_cursor_;
 
   ScopedThreadDesktop desktop_;
 
   // GDI resources used for screen capture.
   scoped_ptr<base::win::ScopedGetDC> desktop_dc_;
   base::win::ScopedCreateDC memory_dc_;
 
   // Queue of the frames buffers.
   VideoFrameQueue queue_;
 
@@ skipping 73 matching lines @@
   set_pixels(reinterpret_cast<uint8*>(data));
   set_dimensions(SkISize::Make(bmi.bmiHeader.biWidth,
                                std::abs(bmi.bmiHeader.biHeight)));
   set_bytes_per_row(
       bmi.bmiHeader.biSizeImage / std::abs(bmi.bmiHeader.biHeight));
 }
 
 VideoFrameCapturerWin::VideoFrameCapturerWin()
     : shared_buffer_factory_(NULL),
       delegate_(NULL),
-      last_cursor_size_(SkISize::Make(0, 0)),
       desktop_dc_rect_(SkIRect::MakeEmpty()),
       pixel_format_(media::VideoFrame::RGB32),
       composition_func_(NULL) {
 }
 
 VideoFrameCapturerWin::VideoFrameCapturerWin(
     SharedBufferFactory* shared_buffer_factory)
     : shared_buffer_factory_(shared_buffer_factory),
       delegate_(NULL),
-      last_cursor_size_(SkISize::Make(0, 0)),
       desktop_dc_rect_(SkIRect::MakeEmpty()),
       pixel_format_(media::VideoFrame::RGB32),
       composition_func_(NULL) {
 }
 
 VideoFrameCapturerWin::~VideoFrameCapturerWin() {
 }
 
 media::VideoFrame::Format VideoFrameCapturerWin::pixel_format() const {
   return pixel_format_;
@@ skipping 260 matching lines @@
   int width = bitmap.bmWidth;
   int height = bitmap.bmHeight;
   // For non-color cursors, the mask contains both an AND and an XOR mask and
   // the height includes both. Thus, the width is correct, but we need to
   // divide by 2 to get the correct mask height.
   if (!color_bitmap) {
     height /= 2;
   }
   int data_size = height * width * kBytesPerPixel;
 
-  scoped_ptr<protocol::CursorShapeInfo> cursor_proto(
-      new protocol::CursorShapeInfo());
-  cursor_proto->mutable_data()->resize(data_size);
-  uint8* cursor_dst_data = const_cast<uint8*>(reinterpret_cast<const uint8*>(
-      cursor_proto->mutable_data()->data()));
+  scoped_ptr<MouseCursorShape> cursor;
+  cursor->data.resize(data_size);
+  uint8* cursor_dst_data =
+      reinterpret_cast<uint8*>(string_as_array(&cursor->data));
 
   // Copy/convert cursor bitmap into format needed by chromotocol.
   int row_bytes = bitmap.bmWidthBytes;
   if (color_bitmap) {
     if (bitmap.bmPlanes != 1 || bitmap.bmBitsPixel != 32) {
       VLOG(3) << "Unsupported color cursor format. Error = " << GetLastError();
       return;
     }
 
     // Copy across colour cursor imagery.
-    // CursorShapeInfo stores imagery top-down, and premultiplied
+    // MouseCursorShape stores imagery top-down, and premultiplied
     // by the alpha channel, whereas windows stores them bottom-up
     // and not premultiplied.
     uint8* cursor_src_data = reinterpret_cast<uint8*>(bitmap.bmBits);
     uint8* src = cursor_src_data + ((height - 1) * row_bytes);
     uint8* dst = cursor_dst_data;
     for (int row = 0; row < height; ++row) {
       for (int column = 0; column < width; ++column) {
         dst[0] = SkAlphaMul(src[0], src[3]);
         dst[1] = SkAlphaMul(src[1], src[3]);
         dst[2] = SkAlphaMul(src[2], src[3]);
@@ skipping 46 matching lines @@
           add_outline = true;
         }
       }
     }
     if (add_outline) {
       AddCursorOutline(width, height,
                        reinterpret_cast<uint32*>(cursor_dst_data));
     }
   }
 
+  cursor->size.set(width, height);
+  cursor->hotspot.set(hotspot_x, hotspot_y);
+
   // Compare the current cursor with the last one we sent to the client. If
   // they're the same, then don't bother sending the cursor again.
-  if (last_cursor_size_.equals(width, height) &&
-      memcmp(last_cursor_.get(), cursor_dst_data, data_size) == 0) {
+  if (last_cursor_ == *cursor) {
     return;
   }
 
   VLOG(3) << "Sending updated cursor: " << width << "x" << height;
 
-  cursor_proto->set_width(width);
-  cursor_proto->set_height(height);
-  cursor_proto->set_hotspot_x(hotspot_x);
-  cursor_proto->set_hotspot_y(hotspot_y);
+  // Record the last cursor image that we sent to the client.
+  last_cursor_ = *cursor;
 
-  // Record the last cursor image that we sent to the client.
-  last_cursor_.reset(new uint8[data_size]);
-  memcpy(last_cursor_.get(), cursor_dst_data, data_size);
-  last_cursor_size_ = SkISize::Make(width, height);
-
-  delegate_->OnCursorShapeChanged(cursor_proto.Pass());
+  delegate_->OnCursorShapeChanged(cursor.Pass());
 }
 
 }  // namespace
 
 // static
 scoped_ptr<VideoFrameCapturer> VideoFrameCapturer::Create() {
   return scoped_ptr<VideoFrameCapturer>(new VideoFrameCapturerWin());
 }
 
 // static
 scoped_ptr<VideoFrameCapturer> VideoFrameCapturer::CreateWithFactory(
     SharedBufferFactory* shared_buffer_factory) {
   scoped_ptr<VideoFrameCapturerWin> capturer(
       new VideoFrameCapturerWin(shared_buffer_factory));
   return capturer.PassAs<VideoFrameCapturer>();
 }
 
 }  // namespace remoting