EncoderZlib/DecoderZlib for chromoting

remoting/base/codec_test.cc

 // Copyright (c) 2010 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 "gfx/rect.h"
 #include "media/base/video_frame.h"
 #include "remoting/base/codec_test.h"
 #include "remoting/base/encoder.h"
 #include "remoting/base/mock_objects.h"
+#include "remoting/base/protocol_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 static const int kWidth = 320;
 static const int kHeight = 240;
 static const int kBytesPerPixel = 4;
 
 // Some sample rects for testing.
 static const gfx::Rect kTestRects[] = {
   gfx::Rect(0, 0, kWidth, kHeight),
   gfx::Rect(0, 0, kWidth / 2, kHeight / 2),
   gfx::Rect(kWidth / 2, kHeight / 2, kWidth / 2, kHeight / 2),
   gfx::Rect(16, 16, 16, 16),
-  gfx::Rect(128, 64, 32, 32)
+  gfx::Rect(128, 64, 32, 32),
 };
 
 namespace remoting {
 
 // A class to test that the state transition of the Encoder is correct.
 class EncoderStateTester {
  public:
   EncoderStateTester()
       : next_state_(Encoder::EncodingStarting) {
   }
@@ skipping 27 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(EncoderStateTester);
 };
 
 // A class to test the message output of the encoder.
 class EncoderMessageTester {
  public:
   EncoderMessageTester()
       : begin_rect_(0),
         rect_data_(0),
         end_rect_(0),
+        added_rects_(0),
         state_(kWaitingForBeginRect),
         strict_(false) {
   }
 
   ~EncoderMessageTester() {
     EXPECT_EQ(begin_rect_, end_rect_);
     EXPECT_EQ(kWaitingForBeginRect, state_);
+    if (strict_){
+      EXPECT_EQ(begin_rect_, added_rects_);
+    }
   }
 
   // Test that we received the correct message.
   void ReceivedMessage(HostMessage* message) {
     EXPECT_TRUE(message->has_update_stream_packet());
 
     if (state_ == kWaitingForBeginRect) {
       EXPECT_TRUE(message->update_stream_packet().has_begin_rect());
       state_ = kWaitingForRectData;
       ++begin_rect_;
@@ skipping 26 matching lines @@
       }
     }
   }
 
   void set_strict(bool strict) {
     strict_ = strict;
   }
 
   void AddRects(const gfx::Rect* rects, int count) {
     rects_.insert(rects_.begin() + rects_.size(), rects, rects + count);
+    added_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<gfx::Rect> rects_;
 
   DISALLOW_COPY_AND_ASSIGN(EncoderMessageTester);
 };
 
 class DecoderTester {
  public:
@@ skipping 18 matching lines @@
       decoder_->BeginDecode(
           frame_, &update_rects_,
           NewRunnableMethod(this, &DecoderTester::OnPartialDecodeDone),
           NewRunnableMethod(this, &DecoderTester::OnDecodeDone));
     }
 
     if (message->has_end_update_stream()) {
       decoder_->EndDecode();
     }
     delete message;
-    return;
   }
 
   void set_strict(bool strict) {
     strict_ = strict;
   }
 
   void set_capture_data(scoped_refptr<CaptureData> data) {
     capture_data_ = data;
   }
 
   void AddRects(const gfx::Rect* rects, int count) {
     rects_.insert(rects_.begin() + rects_.size(), rects, rects + count);
   }
 
   bool decode_done() const { return decode_done_; }
   void reset_decode_done() { decode_done_ = false; }
 
  private:
   void OnPartialDecodeDone() {
     if (!strict_)
       return;
+
+    // Test the content of the update rect.
     for (size_t i = 0; i < update_rects_.size(); ++i) {
+      LOG(INFO) << "Testing Rect " << i;
       EXPECT_FALSE(rects_.empty());
       gfx::Rect rect = rects_.front();
       rects_.pop_front();
       EXPECT_EQ(rect, update_rects_[i]);
+
+      EXPECT_EQ(frame_->stride(0), capture_data_->data_planes().strides[0]);
+      const int stride = frame_->stride(0);
+      const int offset =  stride * update_rects_[i].y() +
+          kBytesPerPixel * update_rects_[i].x();
+      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) {
+        EXPECT_EQ(0, memcmp(original, decoded, row_size))
+            << "Row " << y << " is different";
+        original += stride;
+        decoded += stride;
+      }
     }
   }
 
   void OnDecodeDone() {
     decode_done_ = true;
     if (!strict_)
       return;
 
     EXPECT_TRUE(capture_data_.get());
     for (int i = 0; i < DataPlanes::kPlaneCount; ++i) {
@@ skipping 135 matching lines @@
                               DecoderTester* decoder_tester,
                               scoped_refptr<CaptureData> data,
                               const gfx::Rect* rects, int count) {
   data->mutable_dirty_rects().clear();
   data->mutable_dirty_rects().insert(
       data->mutable_dirty_rects().begin(), rects, rects + count);
   encoder_tester->AddRects(rects, count);
   decoder_tester->AddRects(rects, count);
   decoder_tester->reset_decode_done();
 
+  // Generate random data for the updated rects.
+  srand(0);
+  for (int i = 0; i < count; ++i) {
+    const gfx::Rect rect = rects[i];
+    const int bytes_per_pixel = GetBytesPerPixel(data->pixel_format());
+    const int row_size = bytes_per_pixel * rect.width();
+    uint8* memory = data->data_planes().data[0] +
+                    data->data_planes().strides[0] * rect.y() +
+                    bytes_per_pixel * rect.x();
+    for (int y = 0; y < rect.height(); ++y) {
+      for (int x = 0; x < row_size; ++x)
+        memory[x] = rand() % 256;
+      memory += data->data_planes().strides[0];
+    }
+  }
+
   encoder->Encode(data, true,
                   NewCallback(encoder_tester, &EncoderTester::DataAvailable));
   EXPECT_TRUE(decoder_tester->decode_done());
 }
 
 void TestEncoderDecoder(Encoder* encoder, Decoder* decoder, bool strict) {
   EncoderMessageTester message_tester;
   message_tester.set_strict(strict);
 
   EncoderStateTester state_tester;
@@ skipping 14 matching lines @@
   TestEncodingRects(encoder, &encoder_tester, &decoder_tester, data,
                     kTestRects + 2, 1);
   TestEncodingRects(encoder, &encoder_tester, &decoder_tester, data,
                     kTestRects + 3, 2);
   delete [] memory;
 }
 
 }  // namespace remoting
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(remoting::DecoderTester);