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

trunk/src/remoting/codec/codec_test.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 <deque>
 #include <stdlib.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 46 matching lines @@
                      const DesktopSize& view_size)
       : screen_size_(screen_size),
         view_size_(view_size),
         strict_(false),
         decoder_(decoder),
         frame_(NULL) {
     image_data_.reset(new uint8[
         view_size_.width() * view_size_.height() * kBytesPerPixel]);
     EXPECT_TRUE(image_data_.get());
     decoder_->Initialize(
-        webrtc::DesktopSize(screen_size_.width(), screen_size_.height()));
+        SkISize::Make(screen_size_.width(), screen_size_.height()));
   }
 
   void Reset() {
     expected_region_.Clear();
-    update_region_.Clear();
+    update_region_.setEmpty();
   }
 
   void ResetRenderedData() {
     memset(image_data_.get(), 0,
            view_size_.width() * view_size_.height() * kBytesPerPixel);
   }
 
   void ReceivedPacket(VideoPacket* packet) {
     VideoDecoder::DecodeResult result = decoder_->DecodePacket(packet);
 
     ASSERT_NE(VideoDecoder::DECODE_ERROR, result);
 
     if (result == VideoDecoder::DECODE_DONE) {
       RenderFrame();
     }
   }
 
   void RenderFrame() {
     decoder_->RenderFrame(
-        webrtc::DesktopSize(view_size_.width(), view_size_.height()),
-        webrtc::DesktopRect::MakeWH(view_size_.width(), view_size_.height()),
-        image_data_.get(), view_size_.width() * kBytesPerPixel,
+        SkISize::Make(view_size_.width(), view_size_.height()),
+        SkIRect::MakeWH(view_size_.width(), view_size_.height()),
+        image_data_.get(),
+        view_size_.width() * kBytesPerPixel,
         &update_region_);
   }
 
   void ReceivedScopedPacket(scoped_ptr<VideoPacket> packet) {
     ReceivedPacket(packet.get());
   }
 
   void set_strict(bool strict) {
     strict_ = strict;
   }
@@ skipping 12 matching lines @@
     expected_region_.AddRegion(region);
   }
 
   void VerifyResults() {
     if (!strict_)
       return;
 
     ASSERT_TRUE(frame_);
 
     // Test the content of the update region.
-    EXPECT_TRUE(expected_region_.Equals(update_region_));
+    webrtc::DesktopRegion update_region;
+    for (SkRegion::Iterator i(update_region_); !i.done(); i.next()) {
+      update_region.AddRect(webrtc::DesktopRect::MakeXYWH(
+          i.rect().x(), i.rect().y(), i.rect().width(), i.rect().height()));
+    }
+    EXPECT_TRUE(expected_region_.Equals(update_region));
 
-    for (webrtc::DesktopRegion::Iterator i(update_region_); !i.IsAtEnd();
-         i.Advance()) {
+    for (SkRegion::Iterator i(update_region_); !i.done(); i.next()) {
       const int stride = view_size_.width() * kBytesPerPixel;
       EXPECT_EQ(stride, frame_->stride());
       const int offset =  stride * i.rect().top() +
           kBytesPerPixel * i.rect().left();
       const uint8* original = frame_->data() + offset;
       const uint8* decoded = image_data_.get() + offset;
       const int row_size = kBytesPerPixel * i.rect().width();
       for (int y = 0; y < i.rect().height(); ++y) {
         EXPECT_EQ(0, memcmp(original, decoded, row_size))
             << "Row " << y << " is different";
         original += stride;
         decoded += stride;
       }
     }
   }
 
   // The error at each pixel is the root mean square of the errors in
   // the R, G, and B components, each normalized to [0, 1]. This routine
   // checks that the maximum and mean pixel errors do not exceed given limits.
   void VerifyResultsApprox(const uint8* expected_view_data,
                            double max_error_limit, double mean_error_limit) {
     double max_error = 0.0;
     double sum_error = 0.0;
     int error_num = 0;
-    for (webrtc::DesktopRegion::Iterator i(update_region_); !i.IsAtEnd();
-         i.Advance()) {
+    for (SkRegion::Iterator i(update_region_); !i.done(); i.next()) {
       const int stride = view_size_.width() * kBytesPerPixel;
       const int offset =  stride * i.rect().top() +
           kBytesPerPixel * i.rect().left();
       const uint8* expected = expected_view_data + offset;
       const uint8* actual = image_data_.get() + offset;
       for (int y = 0; y < i.rect().height(); ++y) {
         for (int x = 0; x < i.rect().width(); ++x) {
           double error = CalculateError(expected, actual);
           max_error = std::max(max_error, error);
           sum_error += error;
@@ skipping 21 matching lines @@
     original++;
     decoded++;
     return sqrt(error_sum_squares / 3.0);
   }
 
  private:
   DesktopSize screen_size_;
   DesktopSize view_size_;
   bool strict_;
   webrtc::DesktopRegion expected_region_;
-  webrtc::DesktopRegion update_region_;
+  SkRegion update_region_;
   VideoDecoder* decoder_;
   scoped_ptr<uint8[]> image_data_;
   webrtc::DesktopFrame* frame_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoDecoderTester);
 };
 
 // The VideoEncoderTester provides a hook for retrieving the data, and passing
 // the message to other subprograms for validaton.
 class VideoEncoderTester {
@@ skipping 161 matching lines @@
   scoped_ptr<VideoPacket> packet = encoder->Encode(*frame);
   decoder_tester.ReceivedScopedPacket(packet.Pass());
 
   decoder_tester.VerifyResultsApprox(expected_result->data(),
                                      max_error_limit, mean_error_limit);
 
   // Check that the decoder correctly re-renders the frame if its client
   // invalidates the frame.
   decoder_tester.ResetRenderedData();
   decoder->Invalidate(
-      webrtc::DesktopSize(view_size.width(), view_size.height()),
-      webrtc::DesktopRegion(
-          webrtc::DesktopRect::MakeWH(view_size.width(), view_size.height())));
+      SkISize::Make(view_size.width(), view_size.height()),
+      SkRegion(SkIRect::MakeWH(view_size.width(), view_size.height())));
   decoder_tester.RenderFrame();
   decoder_tester.VerifyResultsApprox(expected_result->data(),
                                      max_error_limit, mean_error_limit);
 }
 
 }  // namespace remoting