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

remoting/host/capturer_mac.cc

 // Copyright (c) 2011 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/capturer.h"
 
 #include <ApplicationServices/ApplicationServices.h>
 #include <OpenGL/CGLMacro.h>
 #include <OpenGL/OpenGL.h>
 
@@ skipping 84 matching lines @@
   // If the buffer is marked as needing to be updated (for example after the
   // screen mode changes) and is the wrong size, then release the old buffer
   // and create a new one.
   void Update() {
     if (needs_update_) {
       needs_update_ = false;
       CGDirectDisplayID mainDevice = CGMainDisplayID();
       int width = CGDisplayPixelsWide(mainDevice);
       int height = CGDisplayPixelsHigh(mainDevice);
       if (width != size_.width() || height != size_.height()) {
-        size_.SetSize(width, height);
+        size_.set(width, height);
         bytes_per_row_ = width * sizeof(uint32_t);
         size_t buffer_size = width * height * sizeof(uint32_t);
         ptr_.reset(new uint8[buffer_size]);
       }
     }
   }
 
-  gfx::Size size() const { return size_; }
+  SkISize size() const { return size_; }
   int bytes_per_row() const { return bytes_per_row_; }
   uint8* ptr() const { return ptr_.get(); }
 
   void set_needs_update() { needs_update_ = true; }
 
  private:
-  gfx::Size size_;
+  SkISize size_;
   int bytes_per_row_;
   scoped_array<uint8> ptr_;
   bool needs_update_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameBuffer);
 };
 
 // A class to perform capturing for mac.
 class CapturerMac : public Capturer {
  public:
   CapturerMac();
   virtual ~CapturerMac();
 
   bool Init();
 
   // Capturer interface.
   virtual void ScreenConfigurationChanged() OVERRIDE;
   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:
   void GlBlitFast(const VideoFrameBuffer& buffer, const SkRegion& region);
   void GlBlitSlow(const VideoFrameBuffer& buffer);
   void CgBlit(const VideoFrameBuffer& buffer, const SkRegion& region);
   void CaptureRegion(const SkRegion& region,
                      CaptureCompletedCallback* callback);
 
   void ScreenRefresh(CGRectCount count, const CGRect *rect_array);
   void ScreenUpdateMove(CGScreenUpdateMoveDelta delta,
@@ skipping 99 matching lines @@
 }
 
 void CapturerMac::ScreenConfigurationChanged() {
   ReleaseBuffers();
   helper_.ClearInvalidRegion();
   last_buffer_ = NULL;
 
   CGDirectDisplayID mainDevice = CGMainDisplayID();
   int width = CGDisplayPixelsWide(mainDevice);
   int height = CGDisplayPixelsHigh(mainDevice);
-  InvalidateScreen(gfx::Size(width, height));
+  InvalidateScreen(SkISize::Make(width, height));
 
   if (!CGDisplayUsesOpenGLAcceleration(mainDevice)) {
     VLOG(3) << "OpenGL support not available.";
     return;
   }
 
   CGLPixelFormatAttribute attributes[] = {
     kCGLPFAFullScreen,
     kCGLPFADisplayMask,
     (CGLPixelFormatAttribute)CGDisplayIDToOpenGLDisplayMask(mainDevice),
@@ skipping 20 matching lines @@
 }
 
 void CapturerMac::ClearInvalidRegion() {
   helper_.ClearInvalidRegion();
 }
 
 void CapturerMac::InvalidateRegion(const SkRegion& invalid_region) {
   helper_.InvalidateRegion(invalid_region);
 }
 
-void CapturerMac::InvalidateScreen(const gfx::Size& size) {
+void CapturerMac::InvalidateScreen(const SkISize& size) {
   helper_.InvalidateScreen(size);
 }
 
 void CapturerMac::InvalidateFullScreen() {
   helper_.InvalidateFullScreen();
 }
 
 void CapturerMac::CaptureInvalidRegion(CaptureCompletedCallback* callback) {
   // Only allow captures when the display configuration is not occurring.
   scoped_refptr<CaptureData> data;
@@ skipping 22 matching lines @@
 
   DataPlanes planes;
   planes.data[0] = current_buffer.ptr();
   planes.strides[0] = current_buffer.bytes_per_row();
   if (flip) {
     planes.strides[0] = -planes.strides[0];
     planes.data[0] +=
         (current_buffer.size().height() - 1) * current_buffer.bytes_per_row();
   }
 
-  data = new CaptureData(planes, gfx::Size(current_buffer.size()),
-                         pixel_format());
+  data = new CaptureData(planes, current_buffer.size(), pixel_format());
   data->mutable_dirty_region() = region;
 
   current_buffer_ = (current_buffer_ + 1) % kNumBuffers;
   helper_.set_size_most_recent(data->size());
   display_configuration_capture_event_.Signal();
 
   callback->Run(data);
   delete callback;
 }
 
@@ skipping 105 matching lines @@
       CopyRect(display_base_address,
                src_bytes_per_row,
                buffer.ptr(),
                buffer.bytes_per_row(),
                src_bytes_per_pixel,
                copy_rect);
     }
   }
 }
 
-const gfx::Size& CapturerMac::size_most_recent() const {
+const SkISize& CapturerMac::size_most_recent() const {
   return helper_.size_most_recent();
 }
 
 void CapturerMac::ScreenRefresh(CGRectCount count, const CGRect *rect_array) {
   SkIRect skirect_array[count];
   for (CGRectCount i = 0; i < count; ++i) {
     skirect_array[i] = gfx::CGRectToSkIRect(rect_array[i]);
   }
   SkRegion region;
   region.setRects(skirect_array, count);
@@ skipping 61 matching lines @@
 Capturer* Capturer::Create() {
   CapturerMac* capturer = new CapturerMac();
   if (!capturer->Init()) {
     delete capturer;
     capturer = NULL;
   }
   return capturer;
 }
 
 }  // namespace remoting