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

remoting/host/capturer_linux.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 <X11/Xlib.h>
 #include <X11/Xutil.h>
 #include <X11/extensions/Xdamage.h>
 
@@ skipping 23 matching lines @@
  public:
   VideoFrameBuffer() : bytes_per_row_(0), needs_update_(true) {}
 
   void Update(Display* display, Window root_window) {
     if (needs_update_) {
       needs_update_ = false;
       XWindowAttributes root_attr;
       XGetWindowAttributes(display, root_window, &root_attr);
       if (root_attr.width != size_.width() ||
           root_attr.height != size_.height()) {
-        size_.SetSize(root_attr.width, root_attr.height);
+        size_.set(root_attr.width, root_attr.height);
         bytes_per_row_ = size_.width() * kBytesPerPixel;
         size_t buffer_size = size_.width() * size_.height() * kBytesPerPixel;
         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 Linux.
 class CapturerLinux : public Capturer {
  public:
   CapturerLinux();
   virtual ~CapturerLinux();
 
   bool Init();  // TODO(ajwong): Do we really want this to be synchronous?
 
   // 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 InitXDamage();
 
   // Read and handle all currently-pending XEvents.
   // In the DAMAGE case, process the XDamage events and store the resulting
   // damage rectangles in the CapturerHelper.
   // In all cases, call ScreenConfigurationChanged() in response to any
   // ConfigNotify events.
   void ProcessPendingXEvents();
@@ skipping 152 matching lines @@
 }
 
 void CapturerLinux::ClearInvalidRegion() {
   helper_.ClearInvalidRegion();
 }
 
 void CapturerLinux::InvalidateRegion(const SkRegion& invalid_region) {
   helper_.InvalidateRegion(invalid_region);
 }
 
-void CapturerLinux::InvalidateScreen(const gfx::Size& size) {
+void CapturerLinux::InvalidateScreen(const SkISize& size) {
   helper_.InvalidateScreen(size);
 }
 
 void CapturerLinux::InvalidateFullScreen() {
   helper_.InvalidateFullScreen();
   last_buffer_ = NULL;
 }
 
 void CapturerLinux::CaptureInvalidRegion(
     CaptureCompletedCallback* callback) {
@@ skipping 224 matching lines @@
       uint32_t b = (((pixel & blue_mask) >> blue_shift) * 255) / max_blue;
       uint32_t g = (((pixel & green_mask) >> green_shift) * 255) / max_green;
       // Write as 32-bit RGB.
       dst_pos_32[x] = r << 16 | g << 8 | b;
     }
     dst_pos += dst_stride;
     src_pos += src_stride;
   }
 }
 
-const gfx::Size& CapturerLinux::size_most_recent() const {
+const SkISize& CapturerLinux::size_most_recent() const {
   return helper_.size_most_recent();
 }
 
 }  // namespace
 
 // static
 Capturer* Capturer::Create() {
   CapturerLinux* capturer = new CapturerLinux();
   if (!capturer->Init()) {
     delete capturer;
     capturer = NULL;
   }
   return capturer;
 }
 
 }  // namespace remoting