Remove ScopedVector in //components/search_provider_logos

components/search_provider_logos/logo_tracker_unittest.cc

 // Copyright 2014 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 "components/search_provider_logos/logo_tracker.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <memory>
 #include <vector>
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/json/json_writer.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/simple_test_clock.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "components/search_provider_logos/google_logo_api.h"
 #include "net/base/url_util.h"
 #include "net/http/http_response_headers.h"
@@ skipping 662 matching lines @@
   EXPECT_CALL(*logo_cache_, UpdateCachedLogoMetadata(_)).Times(0);
   EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(0);
   EXPECT_CALL(*logo_cache_, SetCachedLogo(NULL)).Times(AnyNumber());
   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(1));
   observer_.ExpectCachedLogo(NULL);
   GetLogo();
 }
 
 // Tests that deal with multiple listeners.
 
-void EnqueueObservers(LogoTracker* logo_tracker,
-                      const ScopedVector<MockLogoObserver>& observers,
-                      size_t start_index) {
+void EnqueueObservers(
+    LogoTracker* logo_tracker,
+    const std::vector<std::unique_ptr<MockLogoObserver>>& observers,
+    size_t start_index) {
   if (start_index >= observers.size())
     return;
 
-  logo_tracker->GetLogo(observers[start_index]);
+  logo_tracker->GetLogo(observers[start_index].get());
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE, base::Bind(&EnqueueObservers, logo_tracker,
                             base::ConstRef(observers), start_index + 1));
 }
 
 TEST_F(LogoTrackerTest, SupportOverlappingLogoRequests) {
   Logo cached_logo = GetSampleLogo(logo_url_, test_clock_->Now());
   logo_cache_->EncodeAndSetCachedLogo(cached_logo);
   ON_CALL(*logo_cache_, SetCachedLogo(_)).WillByDefault(Return());
 
   Logo fresh_logo = GetSampleLogo2(logo_url_, test_clock_->Now());
   std::string response = ServerResponse(fresh_logo);
   SetServerResponse(response);
   SetServerResponseWhenFingerprint(cached_logo.metadata.fingerprint, response);
 
   const int kNumListeners = 10;
-  ScopedVector<MockLogoObserver> listeners;
+  std::vector<std::unique_ptr<MockLogoObserver>> listeners;
   for (int i = 0; i < kNumListeners; ++i) {
     MockLogoObserver* listener = new MockLogoObserver();
     listener->ExpectCachedAndFreshLogos(&cached_logo, &fresh_logo);
-    listeners.push_back(listener);
+    listeners.push_back(base::WrapUnique(listener));
   }
   EnqueueObservers(logo_tracker_, listeners, 0);
 
   EXPECT_CALL(*logo_cache_, SetCachedLogo(_)).Times(AtMost(3));
   EXPECT_CALL(*logo_cache_, OnGetCachedLogo()).Times(AtMost(3));
 
   base::RunLoop().RunUntilIdle();
 }
 
 TEST_F(LogoTrackerTest, DeleteObserversWhenLogoURLChanged) {
@@ skipping 12 matching lines @@
   MockLogoObserver listener2;
   listener2.ExpectFreshLogo(&logo);
   logo_tracker_->GetLogo(&listener2);
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace
 
 }  // namespace search_provider_logos