Replace RectVectors with SkRegions in Decoder.

remoting/base/codec_test.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 <deque>
 #include <stdlib.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 114 matching lines @@
         decoder_(decoder) {
     frame_ = media::VideoFrame::CreateFrame(media::VideoFrame::RGB32,
                                             kWidth, kHeight,
                                             base::TimeDelta(),
                                             base::TimeDelta());
     EXPECT_TRUE(frame_.get());
     decoder_->Initialize(frame_);
   }
 
   void Reset() {
-    rects_.clear();
-    update_rects_.clear();
+    expected_region_.setEmpty();
+    update_region_.setEmpty();
   }
 
   void ReceivedPacket(VideoPacket* packet) {
     Decoder::DecodeResult result = decoder_->DecodePacket(packet);
 
     ASSERT_NE(Decoder::DECODE_ERROR, result);
 
     if (result == Decoder::DECODE_DONE) {
-      decoder_->GetUpdatedRects(&update_rects_);
+      decoder_->GetUpdatedRegion(&update_region_);
     }
   }
 
   void set_strict(bool strict) {
     strict_ = strict;
   }
 
   void set_capture_data(scoped_refptr<CaptureData> data) {
     capture_data_ = data;
   }
 
   void AddRects(const SkIRect* rects, int count) {
-    rects_.insert(rects_.begin() + rects_.size(), rects, rects + count);
+    SkRegion new_rects;
+    new_rects.setRects(rects, count);
+    expected_region_.op(new_rects, SkRegion::kUnion_Op);
   }
 
   void VerifyResults() {
     if (!strict_)
       return;
 
     ASSERT_TRUE(capture_data_.get());
 
-    // Test the content of the update rect.
-    ASSERT_EQ(rects_.size(), update_rects_.size());
-    for (size_t i = 0; i < update_rects_.size(); ++i) {
-      EXPECT_EQ(rects_[i], update_rects_[i]);
-
+    // Test the content of the update region.
+    EXPECT_EQ(expected_region_, update_region_);
+    for (SkRegion::Iterator i(update_region_); !i.done(); i.next()) {
       EXPECT_EQ(frame_->stride(0), capture_data_->data_planes().strides[0]);
       const int stride = frame_->stride(0);
-      const int offset =  stride * update_rects_[i].fTop +
-          kBytesPerPixel * update_rects_[i].fLeft;
+      const int offset =  stride * i.rect().top() +
+          kBytesPerPixel * i.rect().left();
       const uint8* original = capture_data_->data_planes().data[0] + offset;
       const uint8* decoded = frame_->data(0) + offset;
-      const int row_size = kBytesPerPixel * update_rects_[i].width();
-      for (int y = 0; y < update_rects_[i].height(); ++y) {
+      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;
       }
     }
   }
 
  private:
   bool strict_;
-  std::deque<SkIRect> rects_;
-  RectVector update_rects_;
+  SkRegion expected_region_;
+  SkRegion update_region_;
   Decoder* decoder_;
   scoped_refptr<media::VideoFrame> frame_;
   scoped_refptr<CaptureData> capture_data_;
 
   DISALLOW_COPY_AND_ASSIGN(DecoderTester);
 };
 
 // The EncoderTester provides a hook for retrieving the data, and passing the
 // message to other subprograms for validaton.
 class EncoderTester {
@@ skipping 83 matching lines @@
   scoped_refptr<CaptureData> data =
       PrepareEncodeData(media::VideoFrame::RGB32, &memory);
   scoped_array<uint8> memory_wrapper(memory);
 
   TestEncodingRects(encoder, &tester, data, kTestRects, 1);
   TestEncodingRects(encoder, &tester, data, kTestRects + 1, 1);
   TestEncodingRects(encoder, &tester, data, kTestRects + 2, 1);
   TestEncodingRects(encoder, &tester, data, kTestRects + 3, 2);
 }
 
-static void TestEncodingRects(Encoder* encoder,
-                              EncoderTester* encoder_tester,
-                              DecoderTester* decoder_tester,
-                              scoped_refptr<CaptureData> data,
-                              const SkIRect* rects, int count) {
-  data->mutable_dirty_region().setEmpty();
-  for (int i = 0; i < count; ++i) {
-    data->mutable_dirty_region().op(rects[i], SkRegion::kUnion_Op);
-  }
+static void TestEncodeDecodeRects(Encoder* encoder,
+                                  EncoderTester* encoder_tester,
+                                  DecoderTester* decoder_tester,
+                                  scoped_refptr<CaptureData> data,
+                                  const SkIRect* rects, int count) {
+  data->mutable_dirty_region().setRects(rects, count);
   encoder_tester->AddRects(rects, count);
   decoder_tester->AddRects(rects, count);
 
-  // Generate random data for the updated rects.
+  // Generate random data for the updated region.
   srand(0);
   for (int i = 0; i < count; ++i) {
-    const SkIRect& rect = rects[i];
     const int bytes_per_pixel = GetBytesPerPixel(data->pixel_format());
-    const int row_size = bytes_per_pixel * rect.width();
+    const int row_size = bytes_per_pixel * rects[i].width();
     uint8* memory = data->data_planes().data[0] +
-                    data->data_planes().strides[0] * rect.fTop +
-                    bytes_per_pixel * rect.fLeft;
-    for (int y = 0; y < rect.height(); ++y) {
+      data->data_planes().strides[0] * rects[i].top() +
+      bytes_per_pixel * rects[i].left();
+    for (int y = 0; y < rects[i].height(); ++y) {
       for (int x = 0; x < row_size; ++x)
         memory[x] = rand() % 256;
       memory += data->data_planes().strides[0];
     }
   }
 
   encoder->Encode(data, true, base::Bind(&EncoderTester::DataAvailable,
                                          base::Unretained(encoder_tester)));
   decoder_tester->VerifyResults();
   decoder_tester->Reset();
 }
 
 void TestEncoderDecoder(Encoder* encoder, Decoder* decoder, bool strict) {
   EncoderMessageTester message_tester;
   message_tester.set_strict(strict);
 
   EncoderTester encoder_tester(&message_tester);
 
   uint8* memory;
   scoped_refptr<CaptureData> data =
       PrepareEncodeData(media::VideoFrame::RGB32, &memory);
   scoped_array<uint8> memory_wrapper(memory);
 
   DecoderTester decoder_tester(decoder);
   decoder_tester.set_strict(strict);
   decoder_tester.set_capture_data(data);
   encoder_tester.set_decoder_tester(&decoder_tester);
 
-  TestEncodingRects(encoder, &encoder_tester, &decoder_tester, data,
-                    kTestRects, 1);
-  TestEncodingRects(encoder, &encoder_tester, &decoder_tester, data,
-                    kTestRects + 1, 1);
-  TestEncodingRects(encoder, &encoder_tester, &decoder_tester, data,
-                    kTestRects + 2, 1);
-  TestEncodingRects(encoder, &encoder_tester, &decoder_tester, data,
-                    kTestRects + 3, 2);
+  TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data,
+                        kTestRects, 1);
+  TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data,
+                        kTestRects + 1, 1);
+  TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data,
+                        kTestRects + 2, 1);
+  TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data,
+                        kTestRects + 3, 2);
 }
 
 }  // namespace remoting