Improving the decoder pipeline.

remoting/base/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 "ppapi/cpp/image_data.h"

[Wez, 2012/02/07 01:56:31]

Is this needed?

[alexeypa (please no reviews), 2012/02/15 23:06:22]

No. Removed.

 #include "remoting/base/base_mock_objects.h"
 #include "remoting/base/codec_test.h"
 #include "remoting/base/decoder.h"
 #include "remoting/base/encoder.h"
 #include "remoting/base/util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 static const int kWidth = 320;
 static const int kHeight = 240;
 static const int kBytesPerPixel = 4;
@@ skipping 94 matching lines @@
   std::deque<SkIRect> rects_;
 
   DISALLOW_COPY_AND_ASSIGN(EncoderMessageTester);
 };
 
 class DecoderTester {
  public:
   DecoderTester(Decoder* decoder)
       : strict_(false),
         decoder_(decoder) {
-    frame_ = media::VideoFrame::CreateFrame(media::VideoFrame::RGB32,
-                                            kWidth, kHeight,
-                                            base::TimeDelta(),
-                                            base::TimeDelta());
-    EXPECT_TRUE(frame_.get());
-    decoder_->Initialize(frame_);
+    image_data_.reset(new uint8[kWidth * kHeight * kBytesPerPixel]);
+    EXPECT_TRUE(image_data_.get());
+    decoder_->Initialize(SkISize::Make(kWidth, kHeight));
   }
 
   void Reset() {
     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_->GetUpdatedRegion(&update_region_);
+      decoder_->Draw(SkISize::Make(kWidth, kHeight),
+                     SkIRect::MakeXYWH(0, 0, kWidth, kHeight),
+                     image_data_.get(),
+                     kWidth * kBytesPerPixel,
+                     &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) {
     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 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 stride = kWidth * kBytesPerPixel;
+      EXPECT_EQ(stride, capture_data_->data_planes().strides[0]);
       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 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;
       }
     }
   }
 
  private:
   bool strict_;
   SkRegion expected_region_;
   SkRegion update_region_;
   Decoder* decoder_;
-  scoped_refptr<media::VideoFrame> frame_;
+  scoped_array<uint8> image_data_;
   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 {
  public:
   EncoderTester(EncoderMessageTester* message_tester)
@@ skipping 138 matching lines @@
                         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