Renamed Encoder -> VideoEncoder.

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 26 matching lines @@
   rects.push_back(SkIRect::MakeXYWH(128, 64, 32, 32));
   rect_lists.push_back(rects);
   return rect_lists;
 }
 
 }  // namespace
 
 namespace remoting {
 
 // A class to test the message output of the encoder.
-class EncoderMessageTester {
+class VideoEncoderMessageTester {
  public:
-  EncoderMessageTester()
+  VideoEncoderMessageTester()
       : begin_rect_(0),
         rect_data_(0),
         end_rect_(0),
         added_rects_(0),
         state_(kWaitingForBeginRect),
         strict_(false) {
   }
 
-  ~EncoderMessageTester() {
+  ~VideoEncoderMessageTester() {
     EXPECT_EQ(begin_rect_, end_rect_);
     EXPECT_GT(begin_rect_, 0);
     EXPECT_EQ(kWaitingForBeginRect, state_);
     if (strict_) {
       EXPECT_EQ(added_rects_, begin_rect_);
     }
   }
 
   // Test that we received the correct packet.
   void ReceivedPacket(VideoPacket* packet) {
@@ skipping 51 matching lines @@
 
   int begin_rect_;
   int rect_data_;
   int end_rect_;
   int added_rects_;
   State state_;
   bool strict_;
 
   std::deque<SkIRect> rects_;
 
-  DISALLOW_COPY_AND_ASSIGN(EncoderMessageTester);
+  DISALLOW_COPY_AND_ASSIGN(VideoEncoderMessageTester);
 };
 
 class VideoDecoderTester {
  public:
   VideoDecoderTester(VideoDecoder* decoder, const SkISize& screen_size,
                      const SkISize& view_size)
       : screen_size_(screen_size),
         view_size_(view_size),
         strict_(false),
         decoder_(decoder) {
@@ skipping 129 matching lines @@
   bool strict_;
   SkRegion expected_region_;
   SkRegion update_region_;
   VideoDecoder* decoder_;
   scoped_array<uint8> image_data_;
   scoped_refptr<CaptureData> capture_data_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoDecoderTester);
 };
 
-// The EncoderTester provides a hook for retrieving the data, and passing the
-// message to other subprograms for validaton.
-class EncoderTester {
+// The VideoEncoderTester provides a hook for retrieving the data, and passing
+// the message to other subprograms for validaton.
+class VideoEncoderTester {
  public:
-  EncoderTester(EncoderMessageTester* message_tester)
+  VideoEncoderTester(VideoEncoderMessageTester* message_tester)
       : message_tester_(message_tester),
         decoder_tester_(NULL),
         data_available_(0) {
   }
 
-  ~EncoderTester() {
+  ~VideoEncoderTester() {
     EXPECT_GT(data_available_, 0);
   }
 
   void DataAvailable(scoped_ptr<VideoPacket> packet) {
     ++data_available_;
     message_tester_->ReceivedPacket(packet.get());
 
     // Send the message to the VideoDecoderTester.
     if (decoder_tester_) {
       decoder_tester_->ReceivedPacket(packet.get());
     }
   }
 
   void AddRects(const SkIRect* rects, int count) {
     message_tester_->AddRects(rects, count);
   }
 
   void set_decoder_tester(VideoDecoderTester* decoder_tester) {
     decoder_tester_ = decoder_tester;
   }
 
  private:
-  EncoderMessageTester* message_tester_;
+  VideoEncoderMessageTester* message_tester_;
   VideoDecoderTester* decoder_tester_;
   int data_available_;
 
-  DISALLOW_COPY_AND_ASSIGN(EncoderTester);
+  DISALLOW_COPY_AND_ASSIGN(VideoEncoderTester);
 };
 
 scoped_refptr<CaptureData> PrepareEncodeData(const SkISize& size,
                                              media::VideoFrame::Format format,
                                              uint8** memory) {
   // TODO(hclam): Support also YUV format.
   CHECK_EQ(format, media::VideoFrame::RGB32);
   int memory_size = size.width() * size.height() * kBytesPerPixel;
 
   *memory = new uint8[memory_size];
   srand(0);
   for (int i = 0; i < memory_size; ++i) {
     (*memory)[i] = rand() % 256;
   }
 
   DataPlanes planes;
   memset(planes.data, 0, sizeof(planes.data));
   memset(planes.strides, 0, sizeof(planes.strides));
   planes.data[0] = *memory;
   planes.strides[0] = size.width() * kBytesPerPixel;
 
   scoped_refptr<CaptureData> data =
       new CaptureData(planes, size, format);
   return data;
 }
 
-static void TestEncodingRects(Encoder* encoder,
-                              EncoderTester* tester,
+static void TestEncodingRects(VideoEncoder* encoder,
+                              VideoEncoderTester* 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);
   }
   tester->AddRects(rects, count);
 
   encoder->Encode(data, true, base::Bind(
-      &EncoderTester::DataAvailable, base::Unretained(tester)));
+      &VideoEncoderTester::DataAvailable, base::Unretained(tester)));
 }
 
-void TestEncoder(Encoder* encoder, bool strict) {
+void TestVideoEncoder(VideoEncoder* encoder, bool strict) {
   SkISize kSize = SkISize::Make(320, 240);
 
-  EncoderMessageTester message_tester;
+  VideoEncoderMessageTester message_tester;
   message_tester.set_strict(strict);
 
-  EncoderTester tester(&message_tester);
+  VideoEncoderTester tester(&message_tester);
 
   uint8* memory;
   scoped_refptr<CaptureData> data =
       PrepareEncodeData(kSize, media::VideoFrame::RGB32, &memory);
   scoped_array<uint8> memory_wrapper(memory);
 
   std::vector<std::vector<SkIRect> > test_rect_lists = MakeTestRectLists(kSize);
   for (size_t i = 0; i < test_rect_lists.size(); ++i) {
     const std::vector<SkIRect>& test_rects = test_rect_lists[i];
     TestEncodingRects(encoder, &tester, data,
                       &test_rects[0], test_rects.size());
   }
 }
 
-static void TestEncodeDecodeRects(Encoder* encoder,
-                                  EncoderTester* encoder_tester,
+static void TestEncodeDecodeRects(VideoEncoder* encoder,
+                                  VideoEncoderTester* encoder_tester,
                                   VideoDecoderTester* 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 region.
   srand(0);
   for (int i = 0; i < count; ++i) {
     CHECK_EQ(data->pixel_format(), media::VideoFrame::RGB32);
     const int bytes_per_pixel = 4;  // Because of RGB32 on previous line.
     const int row_size = bytes_per_pixel * rects[i].width();
     uint8* memory = data->data_planes().data[0] +
       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,
+  encoder->Encode(data, true, base::Bind(&VideoEncoderTester::DataAvailable,
                                          base::Unretained(encoder_tester)));
   decoder_tester->VerifyResults();
   decoder_tester->Reset();
 }
 
-void TestEncoderDecoder(Encoder* encoder, VideoDecoder* decoder, bool strict) {
+void TestVideoEncoderDecoder(
+    VideoEncoder* encoder, VideoDecoder* decoder, bool strict) {
   SkISize kSize = SkISize::Make(320, 240);
 
-  EncoderMessageTester message_tester;
+  VideoEncoderMessageTester message_tester;
   message_tester.set_strict(strict);
 
-  EncoderTester encoder_tester(&message_tester);
+  VideoEncoderTester encoder_tester(&message_tester);
 
   uint8* memory;
   scoped_refptr<CaptureData> data =
       PrepareEncodeData(kSize, media::VideoFrame::RGB32, &memory);
   scoped_array<uint8> memory_wrapper(memory);
 
   VideoDecoderTester decoder_tester(decoder, kSize, kSize);
   decoder_tester.set_strict(strict);
   decoder_tester.set_capture_data(data);
   encoder_tester.set_decoder_tester(&decoder_tester);
@@ skipping 13 matching lines @@
     for (int i = rect.left(); i < rect.right(); ++i) {
       *p++ = static_cast<uint8>((255.0 * i) / frame_size.width());
       *p++ = static_cast<uint8>((164.0 * j) / frame_size.height());
       *p++ = static_cast<uint8>((82.0 * (i + j)) /
                                    (frame_size.width() + frame_size.height()));
       *p++ = 0;
     }
   }
 }
 
-void TestEncoderDecoderGradient(Encoder* encoder,
-                                VideoDecoder* decoder,
-                                const SkISize& screen_size,
-                                const SkISize& view_size,
-                                double max_error_limit,
-                                double mean_error_limit) {
+void TestVideoEncoderDecoderGradient(VideoEncoder* encoder,
+                                     VideoDecoder* decoder,
+                                     const SkISize& screen_size,
+                                     const SkISize& view_size,
+                                     double max_error_limit,
+                                     double mean_error_limit) {
   SkIRect screen_rect = SkIRect::MakeSize(screen_size);
   scoped_array<uint8> screen_data(new uint8[
       screen_size.width() * screen_size.height() * kBytesPerPixel]);
   FillWithGradient(screen_data.get(), screen_size, screen_rect);
 
   SkIRect view_rect = SkIRect::MakeSize(view_size);
   scoped_array<uint8> expected_view_data(new uint8[
       view_size.width() * view_size.height() * kBytesPerPixel]);
   FillWithGradient(expected_view_data.get(), view_size, view_rect);
 
@@ skipping 21 matching lines @@
   // Check that the decoder correctly re-renders the frame if its client
   // invalidates the frame.
   decoder_tester.ResetRenderedData();
   decoder->Invalidate(view_size, SkRegion(view_rect));
   decoder_tester.RenderFrame();
   decoder_tester.VerifyResultsApprox(expected_view_data.get(),
                                      max_error_limit, mean_error_limit);
 }
 
 }  // namespace remoting