Move us fully from gfx:: over to skia types for consistency.

remoting/host/capturer_win.cc

Index: remoting/host/capturer_win.cc
diff --git a/remoting/host/capturer_win.cc b/remoting/host/capturer_win.cc
index b8c46e6ba1005f8ffab117406b6270d876dcc073..b92459fe1db331877195829c02c8a00ccee94282 100644
--- a/remoting/host/capturer_win.cc
+++ b/remoting/host/capturer_win.cc
@@ -28,37 +28,37 @@ class CapturerGdi : public Capturer {
   virtual media::VideoFrame::Format pixel_format() const OVERRIDE;
   virtual void ClearInvalidRegion() OVERRIDE;
   virtual void InvalidateRegion(const SkRegion& invalid_region) OVERRIDE;
-  virtual void InvalidateScreen(const gfx::Size& size) OVERRIDE;
+  virtual void InvalidateScreen(const SkISize& size) OVERRIDE;
   virtual void InvalidateFullScreen() OVERRIDE;
   virtual void CaptureInvalidRegion(CaptureCompletedCallback* callback)
       OVERRIDE;
-  virtual const gfx::Size& size_most_recent() const OVERRIDE;
+  virtual const SkISize& size_most_recent() const OVERRIDE;
 
  private:
   struct VideoFrameBuffer {
-    VideoFrameBuffer(void* data, const gfx::Size& size, int bytes_per_pixel,
+    VideoFrameBuffer(void* data, const SkISize& size, int bytes_per_pixel,
                      int bytes_per_row)
       : data(data), size(size), bytes_per_pixel(bytes_per_pixel),
         bytes_per_row(bytes_per_row) {
     }
     VideoFrameBuffer() {
       data = 0;
-      size = gfx::Size(0, 0);
+      size = SkISize::Make(0, 0);
       bytes_per_pixel = 0;
       bytes_per_row = 0;
     }
     void* data;
-    gfx::Size size;
+    SkISize size;
     int bytes_per_pixel;
     int bytes_per_row;
   };
 
   // Make sure that the current buffer has the same size as the screen.
-  void UpdateBufferCapture(const gfx::Size& size);
+  void UpdateBufferCapture(const SkISize& size);
 
   // Allocate memory for a buffer of a given size, freeing any memory previously
   // allocated for that buffer.
-  void ReallocateBuffer(int buffer_index, const gfx::Size& size);
+  void ReallocateBuffer(int buffer_index, const SkISize& size);
 
   void CalculateInvalidRegion();
   void CaptureRegion(const SkRegion& region,
@@ -73,7 +73,7 @@ class CapturerGdi : public Capturer {
   void MaybeChangeScreenConfiguration();
 
   // Gets the screen size.
-  gfx::Size GetScreenSize();
+  SkISize GetScreenSize();
 
   // A thread-safe list of invalid rectangles, and the size of the most
   // recently captured screen.
@@ -90,7 +90,7 @@ class CapturerGdi : public Capturer {
 
   // The screen size attached to the device contexts through which the screen
   // is captured.
-  gfx::Size dc_size_;
+  SkISize dc_size_;
 
   // The current buffer with valid data for reading.
   int current_buffer_;
@@ -112,7 +112,7 @@ static const int kBytesPerPixel = 4;
 CapturerGdi::CapturerGdi()
     : desktop_dc_(NULL),
       memory_dc_(NULL),
-      dc_size_(0, 0),
+      dc_size_(SkISize::Make(0, 0)),
       current_buffer_(0),
       pixel_format_(media::VideoFrame::RGB32) {
   memset(target_bitmap_, 0, sizeof(target_bitmap_));
@@ -136,7 +136,7 @@ void CapturerGdi::InvalidateRegion(const SkRegion& invalid_region) {
   helper_.InvalidateRegion(invalid_region);
 }
 
-void CapturerGdi::InvalidateScreen(const gfx::Size& size) {
+void CapturerGdi::InvalidateScreen(const SkISize& size) {
   helper_.InvalidateScreen(size);
 }
 
@@ -151,7 +151,7 @@ void CapturerGdi::CaptureInvalidRegion(CaptureCompletedCallback* callback) {
   CaptureRegion(invalid_region, callback);
 }
 
-const gfx::Size& CapturerGdi::size_most_recent() const {
+const SkISize& CapturerGdi::size_most_recent() const {
   return helper_.size_most_recent();
 }
 
@@ -178,7 +178,7 @@ void CapturerGdi::ScreenConfigurationChanged() {
   // We poll for screen configuration changes, so ignore notifications.
 }
 
-void CapturerGdi::UpdateBufferCapture(const gfx::Size& size) {
+void CapturerGdi::UpdateBufferCapture(const SkISize& size) {
   // Make sure the DCs have the correct dimensions.
   if (size != dc_size_) {
     // TODO(simonmorris): screen dimensions changing isn't equivalent to needing
@@ -197,7 +197,7 @@ void CapturerGdi::UpdateBufferCapture(const gfx::Size& size) {
   }
 }
 
-void CapturerGdi::ReallocateBuffer(int buffer_index, const gfx::Size& size) {
+void CapturerGdi::ReallocateBuffer(int buffer_index, const SkISize& size) {
   // Delete any previously constructed bitmap.
   if (target_bitmap_[buffer_index]) {
     DeleteObject(target_bitmap_[buffer_index]);
@@ -232,8 +232,8 @@ void CapturerGdi::ReallocateBuffer(int buffer_index, const gfx::Size& size) {
       CreateDIBSection(desktop_dc_, &bmi, DIB_RGB_COLORS,
                        static_cast<void**>(&buffers_[buffer_index].data),
                        NULL, 0);
-  buffers_[buffer_index].size = gfx::Size(bmi.bmiHeader.biWidth,
-                                          std::abs(bmi.bmiHeader.biHeight));
+  buffers_[buffer_index].size = SkISize::Make(bmi.bmiHeader.biWidth,
+                                              std::abs(bmi.bmiHeader.biHeight));
   buffers_[buffer_index].bytes_per_pixel = bmi.bmiHeader.biBitCount / 8;
   buffers_[buffer_index].bytes_per_row =
       bmi.bmiHeader.biSizeImage / std::abs(bmi.bmiHeader.biHeight);
@@ -310,9 +310,9 @@ void CapturerGdi::CaptureImage() {
       SRCCOPY | CAPTUREBLT);
 }
 
-gfx::Size CapturerGdi::GetScreenSize() {
-  return gfx::Size(GetSystemMetrics(SM_CXSCREEN),
-                   GetSystemMetrics(SM_CYSCREEN));
+SkISize CapturerGdi::GetScreenSize() {
+  return SkISize::Make(GetSystemMetrics(SM_CXSCREEN),
+                       GetSystemMetrics(SM_CYSCREEN));
 }
 
 }  // namespace