Roll webrtc 4143:4179

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"
 #include "media/base/video_frame.h"
 #include "remoting/codec/codec_test.h"
 #include "remoting/codec/video_decoder.h"
 #include "remoting/codec/video_encoder.h"
 #include "remoting/base/util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/modules/desktop_capture/desktop_frame.h"
 
 using webrtc::DesktopRect;
+using webrtc::DesktopRegion;
 using webrtc::DesktopSize;
 
 namespace {
 
 const int kBytesPerPixel = 4;
 
 // Some sample rects for testing.
 std::vector<std::vector<DesktopRect> > MakeTestRectLists(DesktopSize size) {
   std::vector<std::vector<DesktopRect> > rect_lists;
   std::vector<DesktopRect> rects;
@@ skipping 19 matching lines @@
 
 namespace remoting {
 
 // A class to test the message output of the encoder.
 class VideoEncoderMessageTester {
  public:
   VideoEncoderMessageTester()
       : begin_rect_(0),
         rect_data_(0),
         end_rect_(0),
-        added_rects_(0),
         state_(kWaitingForBeginRect),
         strict_(false) {
   }
 
   ~VideoEncoderMessageTester() {
     EXPECT_EQ(begin_rect_, end_rect_);
     EXPECT_GT(begin_rect_, 0);
     EXPECT_EQ(kWaitingForBeginRect, state_);
     if (strict_) {
-      EXPECT_EQ(added_rects_, begin_rect_);
+      EXPECT_TRUE(region_.Equals(received_region_));
     }
   }
 
   // Test that we received the correct packet.
   void ReceivedPacket(VideoPacket* packet) {
     if (state_ == kWaitingForBeginRect) {
       EXPECT_TRUE((packet->flags() & VideoPacket::FIRST_PACKET) != 0);
       state_ = kWaitingForRectData;
       ++begin_rect_;
 
       if (strict_) {
-        DesktopRect rect = rects_.front();
-        rects_.pop_front();
-        EXPECT_EQ(rect.left(), packet->format().x());
-        EXPECT_EQ(rect.top(), packet->format().y());
-        EXPECT_EQ(rect.width(), packet->format().width());
-        EXPECT_EQ(rect.height(), packet->format().height());
+        received_region_.AddRect(webrtc::DesktopRect::MakeXYWH(
+            packet->format().x(), packet->format().y(),
+            packet->format().width(), packet->format().height()));
       }
     } else {
       EXPECT_FALSE((packet->flags() & VideoPacket::FIRST_PACKET) != 0);
     }
 
     if (state_ == kWaitingForRectData) {
       if (packet->has_data()) {
         ++rect_data_;
       }
 
@@ skipping 10 matching lines @@
         EXPECT_TRUE((packet->flags() & VideoPacket::LAST_PACKET) != 0);
       }
     }
   }
 
   void set_strict(bool strict) {
     strict_ = strict;
   }
 
   void AddRects(const DesktopRect* rects, int count) {
-    rects_.insert(rects_.begin() + rects_.size(), rects, rects + count);
-    added_rects_ += count;
+    region_.AddRects(rects, count);
   }
 
  private:
   enum State {
     kWaitingForBeginRect,
     kWaitingForRectData,
   };
 
   int begin_rect_;
   int rect_data_;
   int end_rect_;
-  int added_rects_;
   State state_;
   bool strict_;
 
-  std::deque<DesktopRect> rects_;
+  DesktopRegion region_;
+  DesktopRegion received_region_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoEncoderMessageTester);
 };
 
 class VideoDecoderTester {
  public:
   VideoDecoderTester(VideoDecoder* decoder,
                      const DesktopSize& screen_size,
                      const DesktopSize& view_size)
       : screen_size_(screen_size),
@@ skipping 345 matching lines @@
   decoder_tester.ResetRenderedData();
   decoder->Invalidate(
       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