Reland of Remove ScopedVector from all other codes in media/

media/gpu/video_encode_accelerator_unittest.cc

 // Copyright 2013 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 <inttypes.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <queue>
 #include <string>
 #include <utility>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/bits.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
 #include "base/memory/aligned_memory.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/process/process_handle.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread.h"
@@ skipping 339 matching lines @@
     }
     src_offset += static_cast<off_t>(visible_buffer_size);
   }
   src.Close();
 
   LOG_ASSERT(test_stream->num_frames > 0UL);
 }
 
 // Parse |data| into its constituent parts, set the various output fields
 // accordingly, read in video stream, and store them to |test_streams|.
-static void ParseAndReadTestStreamData(const base::FilePath::StringType& data,
-                                       ScopedVector<TestStream>* test_streams) {
+static void ParseAndReadTestStreamData(
+    const base::FilePath::StringType& data,
+    std::vector<std::unique_ptr<TestStream>>* test_streams) {
   // Split the string to individual test stream data.
   std::vector<base::FilePath::StringType> test_streams_data =
       base::SplitString(data, base::FilePath::StringType(1, ';'),
                         base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   LOG_ASSERT(test_streams_data.size() >= 1U) << data;
 
   // Parse each test stream data and read the input file.
   for (size_t index = 0; index < test_streams_data.size(); ++index) {
     std::vector<base::FilePath::StringType> fields = base::SplitString(
         test_streams_data[index], base::FilePath::StringType(1, ','),
         base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     // Try using ":" as the seperator if "," isn't used.
     if (fields.size() == 1U) {
       fields = base::SplitString(test_streams_data[index],
                                  base::FilePath::StringType(1, ':'),
                                  base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
     }
     LOG_ASSERT(fields.size() >= 4U) << data;
     LOG_ASSERT(fields.size() <= 9U) << data;
-    TestStream* test_stream = new TestStream();
+    auto test_stream = base::MakeUnique<TestStream>();
 
     test_stream->in_filename = FilePathStringTypeToString(fields[0]);
     int width, height;
     bool result = base::StringToInt(fields[1], &width);
     LOG_ASSERT(result);
     result = base::StringToInt(fields[2], &height);
     LOG_ASSERT(result);
     test_stream->visible_size = gfx::Size(width, height);
     LOG_ASSERT(!test_stream->visible_size.IsEmpty());
     int profile;
@@ skipping 16 matching lines @@
 
     if (fields.size() >= 8 && !fields[7].empty()) {
       LOG_ASSERT(base::StringToUint(
           fields[7], &test_stream->requested_subsequent_bitrate));
     }
 
     if (fields.size() >= 9 && !fields[8].empty()) {
       LOG_ASSERT(base::StringToUint(
           fields[8], &test_stream->requested_subsequent_framerate));
     }
-    test_streams->push_back(test_stream);
+    test_streams->push_back(std::move(test_stream));
   }
 }
 
 static std::unique_ptr<VideoEncodeAccelerator> CreateFakeVEA() {
   std::unique_ptr<VideoEncodeAccelerator> encoder;
   if (g_fake_encoder) {
     encoder.reset(new FakeVideoEncodeAccelerator(
         scoped_refptr<base::SingleThreadTaskRunner>(
             base::ThreadTaskRunnerHandle::Get())));
   }
@@ skipping 86 matching lines @@
   bool run_at_fps() const { return run_at_fps_; }
 
   // Whether to measure encode latency. This is set by the command line switch
   // "--measure_latency".
   bool needs_encode_latency() const { return needs_encode_latency_; }
 
   // Verify the encoder output of all testcases. This is set by the command line
   // switch "--verify_all_output".
   bool verify_all_output() const { return verify_all_output_; }
 
-  ScopedVector<TestStream> test_streams_;
+  std::vector<std::unique_ptr<TestStream>> test_streams_;
 
  private:
   std::unique_ptr<base::FilePath::StringType> test_stream_data_;
   base::FilePath log_path_;
   std::unique_ptr<base::File> log_file_;
   bool run_at_fps_;
   bool needs_encode_latency_;
   bool verify_all_output_;
 };
 
@@ skipping 357 matching lines @@
 
   std::unique_ptr<VideoEncodeAccelerator> encoder_;
 
   // Used to notify another thread about the state. VEAClientBase does not own
   // this.
   ClientStateNotification<ClientState>* note_;
 
   // All methods of this class should be run on the same thread.
   base::ThreadChecker thread_checker_;
 
-  ScopedVector<base::SharedMemory> output_shms_;
+  std::vector<std::unique_ptr<base::SharedMemory>> output_shms_;
   int32_t next_output_buffer_id_;
 };
 
 class VEAClient : public VEAClientBase {
  public:
   VEAClient(TestStream* test_stream,
             ClientStateNotification<ClientState>* note,
             bool save_to_file,
             unsigned int keyframe_period,
             bool force_bitrate,
@@ skipping 462 matching lines @@
     WriteIvfFileHeader();
 
   input_coded_size_ = input_coded_size;
   num_required_input_buffers_ = input_count;
   ASSERT_GT(num_required_input_buffers_, 0UL);
 
   output_buffer_size_ = output_size;
   ASSERT_GT(output_buffer_size_, 0UL);
 
   for (unsigned int i = 0; i < kNumOutputBuffers; ++i) {
-    base::SharedMemory* shm = new base::SharedMemory();
+    auto shm = base::MakeUnique<base::SharedMemory>();
     LOG_ASSERT(shm->CreateAndMapAnonymous(output_buffer_size_));
-    output_shms_.push_back(shm);
-    FeedEncoderWithOutput(shm);
+    FeedEncoderWithOutput(shm.get());
+    output_shms_.push_back(std::move(shm));
   }
 
   if (g_env->run_at_fps()) {
     input_timer_.reset(new base::RepeatingTimer());
     input_timer_->Start(
         FROM_HERE, base::TimeDelta::FromSeconds(1) / current_framerate_,
         base::Bind(&VEAClient::OnInputTimer, base::Unretained(this)));
   } else {
     while (inputs_at_client_.size() <
            num_required_input_buffers_ + kNumExtraInputFrames)
@@ skipping 472 matching lines @@
 
 void SimpleVEAClientBase::RequireBitstreamBuffers(
     unsigned int input_count,
     const gfx::Size& input_coded_size,
     size_t output_size) {
   DCHECK(thread_checker_.CalledOnValidThread());
   SetState(CS_ENCODING);
   ASSERT_GT(output_size, 0UL);
 
   for (unsigned int i = 0; i < kNumOutputBuffers; ++i) {
-    base::SharedMemory* shm = new base::SharedMemory();
+    auto shm = base::MakeUnique<base::SharedMemory>();
     LOG_ASSERT(shm->CreateAndMapAnonymous(output_size));
-    output_shms_.push_back(shm);
-    FeedEncoderWithOutput(shm, output_size);
+    FeedEncoderWithOutput(shm.get(), output_size);
+    output_shms_.push_back(std::move(shm));
   }
 }
 
 void SimpleVEAClientBase::FeedEncoderWithOutput(base::SharedMemory* shm,
                                                 size_t output_size) {
   if (!has_encoder())
     return;
 
   base::SharedMemoryHandle dup_handle = shm->handle().Duplicate();
   LOG_ASSERT(dup_handle.IsValid());
@@ skipping 159 matching lines @@
   const bool save_to_file = std::get<1>(GetParam());
   const unsigned int keyframe_period = std::get<2>(GetParam());
   const bool force_bitrate = std::get<3>(GetParam());
   const bool test_perf = std::get<4>(GetParam());
   const bool mid_stream_bitrate_switch = std::get<5>(GetParam());
   const bool mid_stream_framerate_switch = std::get<6>(GetParam());
   const bool verify_output =
       std::get<7>(GetParam()) || g_env->verify_all_output();
   const bool verify_output_timestamp = std::get<8>(GetParam());
 
-  ScopedVector<ClientStateNotification<ClientState>> notes;
-  ScopedVector<VEAClient> clients;
+  std::vector<std::unique_ptr<ClientStateNotification<ClientState>>> notes;
+  std::vector<std::unique_ptr<VEAClient>> clients;
   base::Thread vea_client_thread("EncoderClientThread");
   ASSERT_TRUE(vea_client_thread.Start());
 
   if (g_env->test_streams_.size() > 1)
     num_concurrent_encoders = g_env->test_streams_.size();
 
   // Create all encoders.
   for (size_t i = 0; i < num_concurrent_encoders; i++) {
     size_t test_stream_index = i % g_env->test_streams_.size();
     // Disregard save_to_file if we didn't get an output filename.
     bool encoder_save_to_file =
         (save_to_file &&
          !g_env->test_streams_[test_stream_index]->out_filename.empty());
 
-    notes.push_back(new ClientStateNotification<ClientState>());
-    clients.push_back(new VEAClient(
-        g_env->test_streams_[test_stream_index], notes.back(),
+    notes.push_back(base::MakeUnique<ClientStateNotification<ClientState>>());
+    clients.push_back(base::MakeUnique<VEAClient>(
+        g_env->test_streams_[test_stream_index].get(), notes.back().get(),
         encoder_save_to_file, keyframe_period, force_bitrate, test_perf,
         mid_stream_bitrate_switch, mid_stream_framerate_switch, verify_output,
         verify_output_timestamp));
 
     vea_client_thread.task_runner()->PostTask(
         FROM_HERE, base::Bind(&VEAClient::CreateEncoder,
-                              base::Unretained(clients.back())));
+                              base::Unretained(clients.back().get())));
   }
 
   // All encoders must pass through states in this order.
   enum ClientState state_transitions[] = {CS_INITIALIZED, CS_ENCODING,
                                           CS_FINISHED, CS_VALIDATED};
 
   // Wait for all encoders to go through all states and finish.
   // Do this by waiting for all encoders to advance to state n before checking
   // state n+1, to verify that they are able to operate concurrently.
   // It also simulates the real-world usage better, as the main thread, on which
   // encoders are created/destroyed, is a single GPU Process ChildThread.
   // Moreover, we can't have proper multithreading on X11, so this could cause
   // hard to debug issues there, if there were multiple "ChildThreads".
   for (const auto& state : state_transitions) {
     for (size_t i = 0; i < num_concurrent_encoders && !HasFailure(); i++) {
       EXPECT_EQ(state, notes[i]->Wait());
     }
     if (HasFailure()) {
       break;
     }
   }
 
   for (size_t i = 0; i < num_concurrent_encoders; ++i) {
     vea_client_thread.task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&VEAClient::DestroyEncoder, base::Unretained(clients[i])));
+        FROM_HERE, base::Bind(&VEAClient::DestroyEncoder,
+                              base::Unretained(clients[i].get())));
   }
 
   // This ensures all tasks have finished.
   vea_client_thread.Stop();
 }
 
 // Test parameters:
 // - Test type
 //   0: No input test
 //   1: Cache line-unaligned test
@@ skipping 230 matching lines @@
 
   media::g_env =
       reinterpret_cast<media::VideoEncodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoEncodeAcceleratorTestEnvironment(
                   std::move(test_stream_data), log_path, run_at_fps,
                   needs_encode_latency, verify_all_output)));
 
   return RUN_ALL_TESTS();
 }