Revert of Remove ScopedVector from all other codes in media/

media/gpu/jpeg_decode_accelerator_unittest.cc

 // Copyright 2015 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.
 
 // This has to be included first.
 // See http://code.google.com/p/googletest/issues/detail?id=371
 #include "testing/gtest/include/gtest/gtest.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include <memory>
 
 #include "base/at_exit.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/memory/ptr_util.h"
+#include "base/memory/scoped_vector.h"
 #include "base/path_service.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/string_split.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "media/base/test_data_util.h"
 #include "media/filters/jpeg_parser.h"
 #include "media/gpu/video_accelerator_unittest_helpers.h"
 #include "media/video/jpeg_decode_accelerator.h"
 #include "third_party/libyuv/include/libyuv.h"
@@ skipping 285 matching lines @@
   std::unique_ptr<TestImageFile> image_data_1280x720_black_;
   // Parsed data of |test_640x368_jpeg_file_|.
   std::unique_ptr<TestImageFile> image_data_640x368_black_;
   // Parsed data of |test_640x360_jpeg_file_|.
   std::unique_ptr<TestImageFile> image_data_640x360_black_;
   // Parsed data of "peach_pi-1280x720.jpg".
   std::unique_ptr<TestImageFile> image_data_1280x720_default_;
   // Parsed data of failure image.
   std::unique_ptr<TestImageFile> image_data_invalid_;
   // Parsed data from command line.
-  std::vector<std::unique_ptr<TestImageFile>> image_data_user_;
+  ScopedVector<TestImageFile> image_data_user_;
 
  private:
   const base::FilePath::CharType* user_jpeg_filenames_;
 
   // Used for InputSizeChange test case. The image size should be smaller than
   // |kDefaultJpegFilename|.
   base::FilePath test_1280x720_jpeg_file_;
   // Used for ResolutionChange test case.
   base::FilePath test_640x368_jpeg_file_;
   // Used for testing some drivers which will align the output resolution to a
@@ skipping 31 matching lines @@
   image_data_invalid_->visible_size.SetSize(1280, 720);
   image_data_invalid_->output_size = VideoFrame::AllocationSize(
       PIXEL_FORMAT_I420, image_data_invalid_->visible_size);
 
   // |user_jpeg_filenames_| may include many files and use ';' as delimiter.
   std::vector<base::FilePath::StringType> filenames = base::SplitString(
       user_jpeg_filenames_, base::FilePath::StringType(1, ';'),
       base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   for (const auto& filename : filenames) {
     base::FilePath input_file = GetTestDataFilePath(filename);
-    auto image_data = base::MakeUnique<TestImageFile>(filename);
+    TestImageFile* image_data = new TestImageFile(filename);
     ASSERT_NO_FATAL_FAILURE(ReadTestJpegImage(input_file, image_data));
     image_data_user_.push_back(image_data);
   }
 }
 
 void JpegDecodeAcceleratorTestEnvironment::TearDown() {
   base::DeleteFile(test_1280x720_jpeg_file_, false);
   base::DeleteFile(test_640x368_jpeg_file_, false);
   base::DeleteFile(test_640x360_jpeg_file_, false);
 }
@@ skipping 46 matching lines @@
 
  protected:
   DISALLOW_COPY_AND_ASSIGN(JpegDecodeAcceleratorTest);
 };
 
 void JpegDecodeAcceleratorTest::TestDecode(size_t num_concurrent_decoders) {
   LOG_ASSERT(test_image_files_.size() >= expected_status_.size());
   base::Thread decoder_thread("DecoderThread");
   ASSERT_TRUE(decoder_thread.Start());
 
-  std::vector<std::unique_ptr<ClientStateNotification<ClientState>>> notes;
-  std::vector<std::unique_ptr<JpegClient>> clients;
+  ScopedVector<ClientStateNotification<ClientState>> notes;
+  ScopedVector<JpegClient> clients;
 
   for (size_t i = 0; i < num_concurrent_decoders; i++) {
-    notes.push_back(base::MakeUnique<ClientStateNotification<ClientState>>());
-    clients.push_back(
-        base::MakeUnique<JpegClient>(test_image_files_, notes.back()));
+    notes.push_back(new ClientStateNotification<ClientState>());
+    clients.push_back(new JpegClient(test_image_files_, notes.back()));
     decoder_thread.task_runner()->PostTask(
         FROM_HERE, base::Bind(&JpegClient::CreateJpegDecoder,
-                              base::Unretained(clients.back().get())));
+                              base::Unretained(clients.back())));
     ASSERT_EQ(notes[i]->Wait(), CS_INITIALIZED);
   }
 
   for (size_t index = 0; index < test_image_files_.size(); index++) {
     for (size_t i = 0; i < num_concurrent_decoders; i++) {
       decoder_thread.task_runner()->PostTask(
           FROM_HERE, base::Bind(&JpegClient::StartDecode,
-                                base::Unretained(clients[i].get(), index));
+                                base::Unretained(clients[i]), index));
     }
     if (index < expected_status_.size()) {
       for (size_t i = 0; i < num_concurrent_decoders; i++) {
         ASSERT_EQ(notes[i]->Wait(), expected_status_[index]);
       }
     }
   }
 
   for (size_t i = 0; i < num_concurrent_decoders; i++) {
     decoder_thread.task_runner()->PostTask(
         FROM_HERE, base::Bind(&JpegClient::DestroyJpegDecoder,
-                              base::Unretained(clients[i].get())));
+                              base::Unretained(clients[i])));
   }
   decoder_thread.Stop();
 }
 
 TEST_F(JpegDecodeAcceleratorTest, SimpleDecode) {
   for (auto* image : g_env->image_data_user_) {
     test_image_files_.push_back(image);
     expected_status_.push_back(CS_DECODE_PASS);
   }
   TestDecode(1);
@@ skipping 97 matching lines @@
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY)
   media::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   media::g_env = reinterpret_cast<media::JpegDecodeAcceleratorTestEnvironment*>(
       testing::AddGlobalTestEnvironment(
           new media::JpegDecodeAcceleratorTestEnvironment(jpeg_filenames)));
 
   return RUN_ALL_TESTS();
 }