Move screen capturers to remoting/capturer.

remoting/capturer/video_frame_capturer_mac.mm

 // 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 <ApplicationServices/ApplicationServices.h>
 #include <Cocoa/Cocoa.h>
 #include <dlfcn.h>
 #include <IOKit/pwr_mgt/IOPMLib.h>
 #include <OpenGL/CGLMacro.h>
 #include <OpenGL/OpenGL.h>
 #include <set>
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "base/file_path.h"
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/scoped_native_library.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time.h"
-#include "remoting/base/capture_data.h"
-#include "remoting/base/util.h"
-#include "remoting/host/mac/scoped_pixel_buffer_object.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/mac/scoped_pixel_buffer_object.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 {
 
 // Definitions used to dynamic-link to deprecated OS 10.6 functions.
 const char* kApplicationServicesLibraryName =
     "/System/Library/Frameworks/ApplicationServices.framework/"
     "ApplicationServices";
 typedef void* (*CGDisplayBaseAddressFunc)(CGDirectDisplayID);
 typedef size_t (*CGDisplayBytesPerRowFunc)(CGDirectDisplayID);
 typedef size_t (*CGDisplayBitsPerPixelFunc)(CGDirectDisplayID);
 const char* kOpenGlLibraryName =
     "/System/Library/Frameworks/OpenGL.framework/OpenGL";
 typedef CGLError (*CGLSetFullScreenFunc)(CGLContextObj);
 
 // skia/ext/skia_utils_mac.h only defines CGRectToSkRect().
 SkIRect CGRectToSkIRect(const CGRect& rect) {
   SkIRect sk_rect = {
     SkScalarRound(rect.origin.x),
     SkScalarRound(rect.origin.y),
     SkScalarRound(rect.origin.x + rect.size.width),
     SkScalarRound(rect.origin.y + rect.size.height)
   };
   return sk_rect;
 }
 
+// Copy pixels in the |rect| from |src_place| to |dest_plane|.
+void CopyRect(const uint8* src_plane,
+              int src_plane_stride,
+              uint8* dest_plane,
+              int dest_plane_stride,
+              int bytes_per_pixel,
+              const SkIRect& rect) {
+  // Get the address of the starting point.
+  const int src_y_offset = src_plane_stride * rect.top();
+  const int dest_y_offset = dest_plane_stride * rect.top();
+  const int x_offset = bytes_per_pixel * rect.left();
+  src_plane += src_y_offset + x_offset;
+  dest_plane += dest_y_offset + x_offset;
+
+  // Copy pixels in the rectangle line by line.
+  const int bytes_per_line = bytes_per_pixel * rect.width();
+  const int height = rect.height();
+  for (int i = 0 ; i < height; ++i) {
+    memcpy(dest_plane, src_plane, bytes_per_line);
+    src_plane += src_plane_stride;
+    dest_plane += dest_plane_stride;
+  }
+}
+
 // The amount of time allowed for displays to reconfigure.
 const int64 kDisplayConfigurationEventTimeoutInSeconds = 10;
 
 // A class representing a full-frame pixel buffer.
 class VideoFrameMac : public VideoFrame {
  public:
   explicit VideoFrameMac(const SkISize& size);
   virtual ~VideoFrameMac();
 
   const SkIPoint& dpi() const { return dpi_; }
@@ skipping 346 matching lines @@
         CHECK(data_size == CFDataGetLength(data_ref_current));
         const uint8* data_new = CFDataGetBytePtr(data_ref_new);
         const uint8* data_current = CFDataGetBytePtr(data_ref_current);
         if (memcmp(data_new, data_current, data_size) == 0) {
           return;
         }
       }
     }
   }
 
+  // Record the last cursor image.
+  current_cursor_.reset(CGImageCreateCopy(image));
+
   VLOG(3) << "Sending cursor: " << size.width << "x" << size.height;
 
   CGDataProviderRef provider = CGImageGetDataProvider(image);
   base::mac::ScopedCFTypeRef<CFDataRef> image_data_ref(
       CGDataProviderCopyData(provider));
   if (image_data_ref.get() == NULL) {
     return;
   }
-  const uint8* cursor_src_data = CFDataGetBytePtr(image_data_ref);
+  const char* cursor_src_data =
+      reinterpret_cast<const char*>(CFDataGetBytePtr(image_data_ref));
   int data_size = CFDataGetLength(image_data_ref);
 
-  // Create a CursorShapeInfo proto that describes the cursor and pass it to
+  // Create a MouseCursorShape that describes the cursor and pass it to
   // the client.
-  scoped_ptr<protocol::CursorShapeInfo> cursor_proto(
-      new protocol::CursorShapeInfo());
-  cursor_proto->mutable_data()->resize(data_size);
-  uint8* cursor_tgt_data = const_cast<uint8*>(reinterpret_cast<const uint8*>(
-      cursor_proto->mutable_data()->data()));
+  scoped_ptr<MouseCursorShape> cursor_shape(new MouseCursorShape());
+  cursor_shape->size.set(size.width, size.height);
+  cursor_shape->hotspot.set(hotspot.x, hotspot.y);
+  cursor_shape->data.assign(cursor_src_data, cursor_src_data + data_size);
 
-  memcpy(cursor_tgt_data, cursor_src_data, data_size);
-
-  cursor_proto->set_width(size.width);
-  cursor_proto->set_height(size.height);
-  cursor_proto->set_hotspot_x(hotspot.x);
-  cursor_proto->set_hotspot_y(hotspot.y);
-  delegate_->OnCursorShapeChanged(cursor_proto.Pass());
-
-  // Record the last cursor image that we sent.
-  current_cursor_.reset(CGImageCreateCopy(image));
+  delegate_->OnCursorShapeChanged(cursor_shape.Pass());
 }
 
 void VideoFrameCapturerMac::GlBlitFast(const VideoFrame& buffer,
                                        const SkRegion& region) {
   const int buffer_height = buffer.dimensions().height();
   const int buffer_width = buffer.dimensions().width();
 
   // Clip to the size of our current screen.
   SkIRect clip_rect = SkIRect::MakeWH(buffer_width, buffer_height);
   if (queue_.previous_frame()) {
@@ skipping 385 matching lines @@
 }
 
 // static
 scoped_ptr<VideoFrameCapturer> VideoFrameCapturer::CreateWithFactory(
     SharedBufferFactory* shared_buffer_factory) {
   NOTIMPLEMENTED();
   return scoped_ptr<VideoFrameCapturer>();
 }
 
 }  // namespace remoting