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

remoting/base/encoder_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/encoder_vp8.h"
 
 #include "base/logging.h"
 #include "media/base/yuv_convert.h"
 #include "remoting/base/capture_data.h"
 #include "remoting/base/util.h"
@@ skipping 15 matching lines @@
 
 namespace remoting {
 
 EncoderVp8::EncoderVp8()
     : initialized_(false),
       codec_(NULL),
       image_(NULL),
       active_map_width_(0),
       active_map_height_(0),
       last_timestamp_(0),
-      size_(0, 0) {
+      size_(SkISize::Make(0, 0)) {
 }
 
 EncoderVp8::~EncoderVp8() {
   Destroy();
 }
 
 void EncoderVp8::Destroy() {
   if (initialized_) {
     vpx_codec_err_t ret = vpx_codec_destroy(codec_.get());
     DCHECK(ret == VPX_CODEC_OK) << "Failed to destroy codec";
     initialized_ = false;
   }
 }
 
-bool EncoderVp8::Init(const gfx::Size& size) {
+bool EncoderVp8::Init(const SkISize& size) {
   Destroy();
   size_ = size;
   codec_.reset(new vpx_codec_ctx_t());
   image_.reset(new vpx_image_t());
   memset(image_.get(), 0, sizeof(vpx_image_t));
 
   image_->fmt = VPX_IMG_FMT_YV12;
 
   // libvpx seems to require both to be assigned.
   image_->d_w = size.width();
@@ skipping 65 matching lines @@
     return false;
 
   // Use the lowest level of noise sensitivity so as to spend less time
   // on motion estimation and inter-prediction mode.
   if (vpx_codec_control(codec_.get(), VP8E_SET_NOISE_SENSITIVITY, 0))
     return false;
   return true;
 }
 
 // static
-gfx::Rect EncoderVp8::AlignAndClipRect(const gfx::Rect& rect,
-                                       int width, int height) {
-  gfx::Rect screen(RoundToTwosMultiple(width), RoundToTwosMultiple(height));
-  return screen.Intersect(AlignRect(rect));
+SkIRect EncoderVp8::AlignAndClipRect(const SkIRect& rect,
+                                     int width, int height) {
+  SkIRect screen(SkIRect::MakeWH(RoundToTwosMultiple(width),
+                                 RoundToTwosMultiple(height)));
+  if (!screen.intersect(AlignRect(rect))) {
+    screen = SkIRect::MakeWH(0, 0);
+  }
+  return screen;
 }
 
 bool EncoderVp8::PrepareImage(scoped_refptr<CaptureData> capture_data,
-                              std::vector<gfx::Rect>* updated_rects) {
+                              RectVector* updated_rects) {
   // Perform RGB->YUV conversion.
   if (capture_data->pixel_format() != media::VideoFrame::RGB32) {
     LOG(ERROR) << "Only RGB32 is supported";
     return false;
   }
 
   const SkRegion& region = capture_data->dirty_region();
   const uint8* in = capture_data->data_planes().data[0];
   const int in_stride = capture_data->data_planes().strides[0];
   const int plane_size =
       capture_data->size().width() * capture_data->size().height();
   uint8* y_out = yuv_image_.get();
   uint8* u_out = yuv_image_.get() + plane_size;
   uint8* v_out = yuv_image_.get() + plane_size + plane_size / 4;
   const int y_stride = image_->stride[0];
   const int uv_stride = image_->stride[1];
 
   DCHECK(updated_rects->empty());
   for (SkRegion::Iterator r(region); !r.done(); r.next()) {
     // Align the rectangle, report it as updated.
-    SkIRect skRect = r.rect();
-    gfx::Rect rect(skRect.fLeft, skRect.fTop, skRect.width(), skRect.height());
+    SkIRect rect = r.rect();
     rect = AlignAndClipRect(rect, image_->w, image_->h);
-    if (!rect.IsEmpty())
+    if (!rect.isEmpty())
       updated_rects->push_back(rect);
 
     ConvertRGB32ToYUVWithRect(in,
                               y_out,
                               u_out,
                               v_out,
-                              rect.x(),
-                              rect.y(),
+                              rect.fLeft,
+                              rect.fTop,
                               rect.width(),
                               rect.height(),
                               in_stride,
                               y_stride,
                               uv_stride);
   }
   return true;
 }
 
-void EncoderVp8::PrepareActiveMap(
-    const std::vector<gfx::Rect>& updated_rects) {
+void EncoderVp8::PrepareActiveMap(const RectVector& updated_rects) {
   // Clear active map first.
   memset(active_map_.get(), 0, active_map_width_ * active_map_height_);
 
   // Mark blocks at active.
   for (size_t i = 0; i < updated_rects.size(); ++i) {
-    const gfx::Rect& r = updated_rects[i];
+    const SkIRect& r = updated_rects[i];
     CHECK(r.width() && r.height());
 
-    int left = r.x() / kMacroBlockSize;
-    int right = (r.right() - 1) / kMacroBlockSize;
-    int top = r.y() / kMacroBlockSize;
-    int bottom = (r.bottom() - 1) / kMacroBlockSize;
+    int left = r.fLeft / kMacroBlockSize;
+    int right = (r.fRight - 1) / kMacroBlockSize;
+    int top = r.fTop / kMacroBlockSize;
+    int bottom = (r.fBottom - 1) / kMacroBlockSize;
     CHECK(right < active_map_width_);
     CHECK(bottom < active_map_height_);
 
     uint8* map = active_map_.get() + top * active_map_width_;
     for (int y = top; y <= bottom; ++y) {
       for (int x = left; x <= right; ++x)
         map[x] = 1;
       map += active_map_width_;
     }
   }
 }
 
 void EncoderVp8::Encode(scoped_refptr<CaptureData> capture_data,
                         bool key_frame,
                         DataAvailableCallback* data_available_callback) {
   if (!initialized_ || (capture_data->size() != size_)) {
     bool ret = Init(capture_data->size());
     // TODO(hclam): Handle error better.
     DCHECK(ret) << "Initialization of encoder failed";
     initialized_ = ret;
   }
 
-  std::vector<gfx::Rect> updated_rects;
+  RectVector updated_rects;
   if (!PrepareImage(capture_data, &updated_rects)) {
     NOTREACHED() << "Can't image data for encoding";
   }
 
   // Update active map based on updated rectangles.
   PrepareActiveMap(updated_rects);
 
   // Apply active map to the encoder.
   vpx_active_map_t act_map;
   act_map.rows = active_map_height_;
@@ skipping 42 matching lines @@
 
   message->mutable_format()->set_encoding(VideoPacketFormat::ENCODING_VP8);
   message->set_flags(VideoPacket::FIRST_PACKET | VideoPacket::LAST_PACKET |
                      VideoPacket::LAST_PARTITION);
   message->mutable_format()->set_screen_width(capture_data->size().width());
   message->mutable_format()->set_screen_height(capture_data->size().height());
   message->set_capture_time_ms(capture_data->capture_time_ms());
   message->set_client_sequence_number(capture_data->client_sequence_number());
   for (size_t i = 0; i < updated_rects.size(); ++i) {
     Rect* rect = message->add_dirty_rects();
-    rect->set_x(updated_rects[i].x());
-    rect->set_y(updated_rects[i].y());
+    rect->set_x(updated_rects[i].fLeft);
+    rect->set_y(updated_rects[i].fTop);
     rect->set_width(updated_rects[i].width());
     rect->set_height(updated_rects[i].height());
   }
 
   data_available_callback->Run(message);
   delete data_available_callback;
 }
 
 }  // namespace remoting