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

remoting/base/decoder_vp8.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/base/decoder_vp8.h"
 
 #include "media/base/media.h"
 #include "media/base/yuv_convert.h"
 #include "remoting/base/util.h"
 
@@ skipping 71 matching lines @@
 
   // Gets the decoded data.
   vpx_codec_iter_t iter = NULL;
   vpx_image_t* image = vpx_codec_get_frame(codec_, &iter);
   if (!image) {
     LOG(INFO) << "No video frame decoded";
     return DECODE_ERROR;
   }
   last_image_ = image;
 
-  std::vector<gfx::Rect> rects;
+  RectVector rects;
+  rects.reserve(packet->dirty_rects_size());
   for (int i = 0; i < packet->dirty_rects_size(); ++i) {
-    gfx::Rect r = gfx::Rect(packet->dirty_rects(i).x(),
-                            packet->dirty_rects(i).y(),
-                            packet->dirty_rects(i).width(),
-                            packet->dirty_rects(i).height());
-    rects.push_back(r);
+    Rect remoting_rect = packet->dirty_rects(i);
+    rects.push_back(SkIRect::MakeXYWH(remoting_rect.x(),
+                                      remoting_rect.y(),
+                                      remoting_rect.width(),
+                                      remoting_rect.height()));
   }
 
   if (!DoScaling())
     ConvertRects(rects, &updated_rects_);
   else
     ScaleAndConvertRects(rects, &updated_rects_);
   return DECODE_DONE;
 }
 
-void DecoderVp8::GetUpdatedRects(UpdatedRects* rects) {
+void DecoderVp8::GetUpdatedRects(RectVector* rects) {
   rects->swap(updated_rects_);
 }
 
 void DecoderVp8::Reset() {
   frame_ = NULL;
   state_ = kUninitialized;
 }
 
 bool DecoderVp8::IsReadyForData() {
   return state_ == kReady;
@@ skipping 10 matching lines @@
   // is not implemented yet.
   if (horizontal_ratio > 1.0 || horizontal_ratio <= 0.0 ||
       vertical_ratio > 1.0 || vertical_ratio <= 0.0) {
     return;
   }
 
   horizontal_scale_ratio_ = horizontal_ratio;
   vertical_scale_ratio_ = vertical_ratio;
 }
 
-void DecoderVp8::SetClipRect(const gfx::Rect& clip_rect) {
+void DecoderVp8::SetClipRect(const SkIRect& clip_rect) {
   clip_rect_ = clip_rect;
 }
 
-void DecoderVp8::RefreshRects(const std::vector<gfx::Rect>& rects) {
+void DecoderVp8::RefreshRects(const RectVector& rects) {
   if (!DoScaling())
     ConvertRects(rects, &updated_rects_);
   else
     ScaleAndConvertRects(rects, &updated_rects_);
 }
 
 bool DecoderVp8::DoScaling() const {
   return horizontal_scale_ratio_ != 1.0 || vertical_scale_ratio_ != 1.0;
 }
 
-void DecoderVp8::ConvertRects(const UpdatedRects& rects,
-                              UpdatedRects* output_rects) {
+void DecoderVp8::ConvertRects(const RectVector& rects,
+                              RectVector* output_rects) {
   if (!last_image_)
     return;
 
   uint8* data_start = frame_->data(media::VideoFrame::kRGBPlane);
   const int stride = frame_->stride(media::VideoFrame::kRGBPlane);
 
   output_rects->clear();
+  output_rects->reserve(rects.size());
   for (size_t i = 0; i < rects.size(); ++i) {
+    // Clip by the clipping rectangle first.
+    SkIRect dest_rect = rects[i];
+    if (!dest_rect.intersect(clip_rect_))
+      continue;
+
     // Round down the image width and height.
     int image_width = RoundToTwosMultiple(last_image_->d_w);
     int image_height = RoundToTwosMultiple(last_image_->d_h);
 
-    // Clip by the clipping rectangle first.
-    gfx::Rect dest_rect = rects[i].Intersect(clip_rect_);
-
     // Then clip by the rounded down dimension of the image for safety.
-    dest_rect = dest_rect.Intersect(
-        gfx::Rect(0, 0, image_width, image_height));
+    if (!dest_rect.intersect(SkIRect::MakeWH(image_width, image_height)))
+      continue;
 
     // Align the rectangle to avoid artifacts in color space conversion.
     dest_rect = AlignRect(dest_rect);
 
-    if (dest_rect.IsEmpty())
-      continue;
-
     ConvertYUVToRGB32WithRect(last_image_->planes[0],
                               last_image_->planes[1],
                               last_image_->planes[2],
                               data_start,
                               dest_rect,
                               last_image_->stride[0],
                               last_image_->stride[1],
                               stride);
     output_rects->push_back(dest_rect);
   }
 }
 
-void DecoderVp8::ScaleAndConvertRects(const UpdatedRects& rects,
-                                      UpdatedRects* output_rects) {
+void DecoderVp8::ScaleAndConvertRects(const RectVector& rects,
+                                      RectVector* output_rects) {
   if (!last_image_)
     return;
 
   uint8* data_start = frame_->data(media::VideoFrame::kRGBPlane);
   const int stride = frame_->stride(media::VideoFrame::kRGBPlane);
 
   output_rects->clear();
+  output_rects->reserve(rects.size());
   for (size_t i = 0; i < rects.size(); ++i) {
     // Round down the image width and height.
     int image_width = RoundToTwosMultiple(last_image_->d_w);
     int image_height = RoundToTwosMultiple(last_image_->d_h);
 
     // Clip by the rounded down dimension of the image for safety.
-    gfx::Rect dest_rect =
-        rects[i].Intersect(gfx::Rect(0, 0, image_width, image_height));
+    SkIRect dest_rect = rects[i];
+    if (!dest_rect.intersect(SkIRect::MakeWH(image_width, image_height)))
+      continue;
 
     // Align the rectangle to avoid artifacts in color space conversion.
     dest_rect = AlignRect(dest_rect);
 
-    if (dest_rect.IsEmpty())
-      continue;
-
-    gfx::Rect scaled_rect = ScaleRect(dest_rect,
-                                      horizontal_scale_ratio_,
-                                      vertical_scale_ratio_);
+    SkIRect scaled_rect = ScaleRect(dest_rect,
+                                    horizontal_scale_ratio_,
+                                    vertical_scale_ratio_);
 
     ScaleYUVToRGB32WithRect(last_image_->planes[0],
                             last_image_->planes[1],
                             last_image_->planes[2],
                             data_start,
                             dest_rect,
                             scaled_rect,
                             last_image_->stride[0],
                             last_image_->stride[1],
                             stride);
     output_rects->push_back(scaled_rect);
   }
 }
 
 }  // namespace remoting