Move screen capturers from remoting/capturer to media/video/capturer/screen

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 162 matching lines @@
   }
 
   void ReceivedScopedPacket(scoped_ptr<VideoPacket> packet) {
     ReceivedPacket(packet.get());
   }
 
   void set_strict(bool strict) {
     strict_ = strict;
   }
 
-  void set_capture_data(scoped_refptr<CaptureData> data) {
+  void set_capture_data(scoped_refptr<media::ScreenCaptureData> data) {
     capture_data_ = data;
   }
 
   void AddRects(const SkIRect* rects, int count) {
     SkRegion new_rects;
     new_rects.setRects(rects, count);
     AddRegion(new_rects);
   }
 
   void AddRegion(const SkRegion& region) {
@@ skipping 71 matching lines @@
   }
 
  private:
   SkISize screen_size_;
   SkISize view_size_;
   bool strict_;
   SkRegion expected_region_;
   SkRegion update_region_;
   VideoDecoder* decoder_;
   scoped_array<uint8> image_data_;
-  scoped_refptr<CaptureData> capture_data_;
+  scoped_refptr<media::ScreenCaptureData> capture_data_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoDecoderTester);
 };
 
 // The VideoEncoderTester provides a hook for retrieving the data, and passing
 // the message to other subprograms for validaton.
 class VideoEncoderTester {
  public:
   VideoEncoderTester(VideoEncoderMessageTester* message_tester)
       : message_tester_(message_tester),
@@ skipping 24 matching lines @@
   }
 
  private:
   VideoEncoderMessageTester* message_tester_;
   VideoDecoderTester* decoder_tester_;
   int data_available_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoEncoderTester);
 };
 
-scoped_refptr<CaptureData> PrepareEncodeData(const SkISize& size,
-                                             scoped_array<uint8>* memory) {
+scoped_refptr<media::ScreenCaptureData> PrepareEncodeData(
+    const SkISize& size,
+    scoped_array<uint8>* memory) {
   int memory_size = size.width() * size.height() * kBytesPerPixel;
 
   memory->reset(new uint8[memory_size]);
 
   srand(0);
   for (int i = 0; i < memory_size; ++i) {
     (*memory)[i] = rand() % 256;
   }
 
-  scoped_refptr<CaptureData> data =
-      new CaptureData(memory->get(), size.width() * kBytesPerPixel, size);
+  scoped_refptr<media::ScreenCaptureData> data = new media::ScreenCaptureData(
+      memory->get(), size.width() * kBytesPerPixel, size);
   return data;
 }
 
 static void TestEncodingRects(VideoEncoder* encoder,
                               VideoEncoderTester* tester,
-                              scoped_refptr<CaptureData> data,
+                              scoped_refptr<media::ScreenCaptureData> 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) {
   const int kSizes[] = {320, 319, 317, 150};
 
   VideoEncoderMessageTester message_tester;
   message_tester.set_strict(strict);
 
   VideoEncoderTester tester(&message_tester);
 
   scoped_array<uint8> memory;
 
   for (size_t xi = 0; xi < arraysize(kSizes); ++xi) {
     for (size_t yi = 0; yi < arraysize(kSizes); ++yi) {
       SkISize size = SkISize::Make(kSizes[xi], kSizes[yi]);
-      scoped_refptr<CaptureData> data =
+      scoped_refptr<media::ScreenCaptureData> data =
           PrepareEncodeData(size, &memory);
       std::vector<std::vector<SkIRect> > test_rect_lists =
           MakeTestRectLists(size);
       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,
                                   VideoEncoderTester* encoder_tester,
                                   VideoDecoderTester* decoder_tester,
-                                  scoped_refptr<CaptureData> data,
+                                  scoped_refptr<media::ScreenCaptureData> 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) {
     const int bytes_per_pixel = 4;  // Because of RGB32 on previous line.
     const int row_size = bytes_per_pixel * rects[i].width();
@@ skipping 16 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);
 
   scoped_array<uint8> memory;
-  scoped_refptr<CaptureData> data = PrepareEncodeData(kSize, &memory);
+  scoped_refptr<media::ScreenCaptureData> data =
+      PrepareEncodeData(kSize, &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 24 matching lines @@
   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);
 
-  scoped_refptr<CaptureData> capture_data =
-      new CaptureData(screen_data.get(), screen_size.width() * kBytesPerPixel,
-                      screen_size);
+  scoped_refptr<media::ScreenCaptureData> capture_data =
+      new media::ScreenCaptureData(
+          screen_data.get(), screen_size.width() * kBytesPerPixel, screen_size);
   capture_data->mutable_dirty_region().op(screen_rect, SkRegion::kUnion_Op);
 
   VideoDecoderTester decoder_tester(decoder, screen_size, view_size);
   decoder_tester.set_capture_data(capture_data);
   decoder_tester.AddRegion(capture_data->dirty_region());
 
   encoder->Encode(capture_data, true,
                   base::Bind(&VideoDecoderTester::ReceivedScopedPacket,
                              base::Unretained(&decoder_tester)));
 
   decoder_tester.VerifyResultsApprox(expected_view_data.get(),
                                      max_error_limit, mean_error_limit);
 
   // 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