Revert 224101 "Remove dependency on Skia from chromoting client."

trunk/src/remoting/codec/video_decoder_verbatim.cc

 // Copyright (c) 2012 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/codec/video_decoder_verbatim.h"
 
 #include "base/logging.h"
 #include "remoting/base/util.h"
 
 namespace remoting {
 
 namespace {
 // Both input and output data are assumed to be RGBA32.
 const int kBytesPerPixel = 4;
 }  // namespace
 
-VideoDecoderVerbatim::VideoDecoderVerbatim() {}
+VideoDecoderVerbatim::VideoDecoderVerbatim()
+    : screen_size_(SkISize::Make(0, 0)) {}
 
 VideoDecoderVerbatim::~VideoDecoderVerbatim() {}
 
 bool VideoDecoderVerbatim::IsReadyForData() {
   return true;
 }
 
-void VideoDecoderVerbatim::Initialize(const webrtc::DesktopSize& screen_size) {
-  updated_region_.Clear();
+void VideoDecoderVerbatim::Initialize(const SkISize& screen_size) {
+  updated_region_.setEmpty();
   screen_buffer_.reset();
 
   screen_size_ = screen_size;
   // Allocate the screen buffer, if necessary.
-  if (!screen_size_.is_empty()) {
+  if (!screen_size_.isEmpty()) {
     screen_buffer_.reset(
         new uint8
             [screen_size_.width() * screen_size_.height() * kBytesPerPixel]);
   }
 }
 
 VideoDecoder::DecodeResult VideoDecoderVerbatim::DecodePacket(
     const VideoPacket* packet) {
-  webrtc::DesktopRegion region;
+  SkRegion region;
 
   const char* in = packet->data().data();
   int stride = kBytesPerPixel * screen_size_.width();
   for (int i = 0; i < packet->dirty_rects_size(); ++i) {
     Rect proto_rect = packet->dirty_rects(i);
-    webrtc::DesktopRect rect =
-        webrtc::DesktopRect::MakeXYWH(proto_rect.x(), proto_rect.y(),
-                                      proto_rect.width(), proto_rect.height());
-    region.AddRect(rect);
+    SkIRect rect = SkIRect::MakeXYWH(proto_rect.x(),
+                                     proto_rect.y(),
+                                     proto_rect.width(),
+                                     proto_rect.height());
+    region.op(rect, SkRegion::kUnion_Op);
 
-    if (!DoesRectContain(webrtc::DesktopRect::MakeSize(screen_size_), rect)) {
+    if (!SkIRect::MakeSize(screen_size_).contains(rect)) {
       LOG(ERROR) << "Invalid packet received";
       return DECODE_ERROR;
     }
 
     int rect_row_size = kBytesPerPixel * rect.width();
-    uint8_t* out = screen_buffer_.get() + rect.top() * stride +
-                   rect.left() * kBytesPerPixel;
-    for (int y = rect.top(); y < rect.top() + rect.height(); ++y) {
+    uint8_t* out = screen_buffer_.get() + rect.y() * stride +
+                   rect.x() * kBytesPerPixel;
+    for (int y = rect.y(); y < rect.y() + rect.height(); ++y) {
       if (in + rect_row_size > packet->data().data() + packet->data().size()) {
         LOG(ERROR) << "Invalid packet received";
         return DECODE_ERROR;
       }
       memcpy(out, in, rect_row_size);
       in += rect_row_size;
       out += stride;
     }
   }
 
   if (in != packet->data().data() + packet->data().size()) {
     LOG(ERROR) << "Invalid packet received";
     return DECODE_ERROR;
   }
 
-  updated_region_.AddRegion(region);
+  updated_region_.op(region, SkRegion::kUnion_Op);
 
   return DECODE_DONE;
 }
 
 VideoPacketFormat::Encoding VideoDecoderVerbatim::Encoding() {
   return VideoPacketFormat::ENCODING_VERBATIM;
 }
 
-void VideoDecoderVerbatim::Invalidate(const webrtc::DesktopSize& view_size,
-                                      const webrtc::DesktopRegion& region) {
-  updated_region_.AddRegion(region);
+void VideoDecoderVerbatim::Invalidate(const SkISize& view_size,
+                                      const SkRegion& region) {
+  updated_region_.op(region, SkRegion::kUnion_Op);
 }
 
-void VideoDecoderVerbatim::RenderFrame(const webrtc::DesktopSize& view_size,
-                                       const webrtc::DesktopRect& clip_area,
+void VideoDecoderVerbatim::RenderFrame(const SkISize& view_size,
+                                       const SkIRect& clip_area,
                                        uint8* image_buffer,
                                        int image_stride,
-                                       webrtc::DesktopRegion* output_region) {
-  output_region->Clear();
+                                       SkRegion* output_region) {
+  output_region->setEmpty();
 
   // TODO(alexeypa): scaling is not implemented.
-  webrtc::DesktopRect clip_rect = webrtc::DesktopRect::MakeSize(screen_size_);
-  clip_rect.IntersectWith(clip_area);
-  if (clip_rect.is_empty())
+  SkIRect clip_rect = SkIRect::MakeSize(screen_size_);
+  if (!clip_rect.intersect(clip_area))
     return;
 
   int screen_stride = screen_size_.width() * kBytesPerPixel;
 
-  for (webrtc::DesktopRegion::Iterator i(updated_region_);
-       !i.IsAtEnd(); i.Advance()) {
-    webrtc::DesktopRect rect(i.rect());
-    rect.IntersectWith(clip_rect);
-    if (rect.is_empty())
+  for (SkRegion::Iterator i(updated_region_); !i.done(); i.next()) {
+    SkIRect rect(i.rect());
+    if (!rect.intersect(clip_rect))
       continue;
 
     CopyRGB32Rect(screen_buffer_.get(), screen_stride,
                   clip_rect,
                   image_buffer, image_stride,
                   clip_area,
                   rect);
-    output_region->AddRect(rect);
+    output_region->op(rect, SkRegion::kUnion_Op);
   }
 
-  updated_region_.Clear();
+  updated_region_.setEmpty();
 }
 
-const webrtc::DesktopRegion* VideoDecoderVerbatim::GetImageShape() {
+const SkRegion* VideoDecoderVerbatim::GetImageShape() {
   return NULL;
 }
 
 }  // namespace remoting