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

remoting/host/capturer_fake.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_fake.h"
 
-#include "ui/gfx/rect.h"
-
 namespace remoting {
 
 // CapturerFake generates a white picture of size kWidth x kHeight with a
 // rectangle of size kBoxWidth x kBoxHeight. The rectangle moves kSpeed pixels
 // per frame along both axes, and bounces off the sides of the screen.
 static const int kWidth = 800;
 static const int kHeight = 600;
 static const int kBoxWidth = 140;
 static const int kBoxHeight = 140;
 static const int kSpeed = 20;
@@ skipping 13 matching lines @@
       box_speed_y_(kSpeed),
       current_buffer_(0),
       pixel_format_(media::VideoFrame::RGB32) {
   ScreenConfigurationChanged();
 }
 
 CapturerFake::~CapturerFake() {
 }
 
 void CapturerFake::ScreenConfigurationChanged() {
-  size_ = gfx::Size(kWidth, kHeight);
+  size_ = SkISize::Make(kWidth, kHeight);
   bytes_per_row_ = size_.width() * kBytesPerPixel;
   pixel_format_ = media::VideoFrame::RGB32;
 
   // Create memory for the buffers.
   int buffer_size = size_.height() * bytes_per_row_;
   for (int i = 0; i < kNumBuffers; i++) {
     buffers_[i].reset(new uint8[buffer_size]);
   }
 }
 
 media::VideoFrame::Format CapturerFake::pixel_format() const {
   return pixel_format_;
 }
 
 void CapturerFake::ClearInvalidRegion() {
   helper.ClearInvalidRegion();
 }
 
 void CapturerFake::InvalidateRegion(const SkRegion& invalid_region) {
   helper.InvalidateRegion(invalid_region);
 }
 
-void CapturerFake::InvalidateScreen(const gfx::Size& size) {
+void CapturerFake::InvalidateScreen(const SkISize& size) {
   helper.InvalidateScreen(size);
 }
 
 void CapturerFake::InvalidateFullScreen() {
   helper.InvalidateFullScreen();
 }
 
 void CapturerFake::CaptureInvalidRegion(CaptureCompletedCallback* callback) {
   scoped_ptr<CaptureCompletedCallback> callback_deleter(callback);
 
@@ skipping 11 matching lines @@
   scoped_refptr<CaptureData> capture_data(new CaptureData(planes,
                                                           size_,
                                                           pixel_format_));
   capture_data->mutable_dirty_region() = invalid_region;
 
   helper.set_size_most_recent(capture_data->size());
 
   callback->Run(capture_data);
 }
 
-const gfx::Size& CapturerFake::size_most_recent() const {
+const SkISize& CapturerFake::size_most_recent() const {
   return helper.size_most_recent();
 }
 
 void CapturerFake::GenerateImage() {
   memset(buffers_[current_buffer_].get(), 0xff,
          size_.width() * size_.height() * kBytesPerPixel);
 
   uint8* row = buffers_[current_buffer_].get() +
       (box_pos_y_ * size_.width() + box_pos_x_) * kBytesPerPixel;
 
@@ skipping 17 matching lines @@
       row[x * kBytesPerPixel] = r;
       row[x * kBytesPerPixel+1] = g;
       row[x * kBytesPerPixel+2] = b;
       row[x * kBytesPerPixel+3] = 0xff;
     }
     row += bytes_per_row_;
   }
 }
 
 }  // namespace remoting