Cleaned up codec_test.cc

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 301 matching lines @@
  private:
   VideoEncoderMessageTester* message_tester_;
   VideoDecoderTester* decoder_tester_;
   int data_available_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoEncoderTester);
 };
 
 scoped_refptr<CaptureData> PrepareEncodeData(const SkISize& size,
                                              media::VideoFrame::Format format,
-                                             uint8** memory) {
+                                             scoped_array<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];

[Wez, 2012/08/24 20:57:31]

This allocates a buffer of the necessary size; you need to do the same and
memory->reset() it, I think?

[kxing, 2012/08/24 21:28:30]

Done.

   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.data[0] = memory->get();
   planes.strides[0] = size.width() * kBytesPerPixel;
 
   scoped_refptr<CaptureData> data =
       new CaptureData(planes, size, format);
   return data;
 }
 
 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(
       &VideoEncoderTester::DataAvailable, base::Unretained(tester)));
 }
 
 void TestVideoEncoder(VideoEncoder* encoder, bool strict) {
   SkISize kSize = SkISize::Make(320, 240);
 
   VideoEncoderMessageTester message_tester;
   message_tester.set_strict(strict);
 
   VideoEncoderTester tester(&message_tester);
 
-  uint8* memory;
+  scoped_array<uint8> memory(
+      new uint8[kSize.width() * kSize.height() * kBytesPerPixel]);

[Wez, 2012/08/24 20:57:31]

Move this back into PrepareEncodeData, as per previous comment, so that there's
no possibility of the amount of memory being written to differing from the
amount allocated?

[kxing, 2012/08/24 21:28:30]

Done.

   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(VideoEncoder* encoder,
@@ skipping 29 matching lines @@
 
 void TestVideoEncoderDecoder(
     VideoEncoder* encoder, VideoDecoder* decoder, bool strict) {
   SkISize kSize = SkISize::Make(320, 240);
 
   VideoEncoderMessageTester message_tester;
   message_tester.set_strict(strict);
 
   VideoEncoderTester encoder_tester(&message_tester);
 
-  uint8* memory;
+  scoped_array<uint8> memory(
+      new uint8[kSize.width() * kSize.height() * kBytesPerPixel]);
   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);
 
   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];
     TestEncodeDecodeRects(encoder, &encoder_tester, &decoder_tester, data,
@@ skipping 55 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