Remove ScopedVector from chrome/browser/.

chrome/browser/bitmap_fetcher/bitmap_fetcher_service.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 "chrome/browser/bitmap_fetcher/bitmap_fetcher_service.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/macros.h"
@@ skipping 53 matching lines @@
 }
 
 BitmapFetcherService::BitmapFetcherService(content::BrowserContext* context)
     : cache_(kMaxCacheEntries), current_request_id_(1), context_(context) {
 }
 
 BitmapFetcherService::~BitmapFetcherService() {
 }
 
 void BitmapFetcherService::CancelRequest(int request_id) {
-  ScopedVector<BitmapFetcherRequest>::iterator iter;
-  for (iter = requests_.begin(); iter != requests_.end(); ++iter) {
+  for (auto iter = requests_.begin(); iter != requests_.end(); ++iter) {
     if ((*iter)->request_id() == request_id) {
       requests_.erase(iter);
       // Deliberately leave the associated fetcher running to populate cache.
       return;
     }
   }
 }
 
 BitmapFetcherService::RequestId BitmapFetcherService::RequestImage(
     const GURL& url,
     Observer* observer,
     const net::NetworkTrafficAnnotationTag& traffic_annotation) {
   // Create a new request, assigning next available request ID.
   ++current_request_id_;
   if (current_request_id_ == REQUEST_ID_INVALID)
     ++current_request_id_;
   int request_id = current_request_id_;
-  std::unique_ptr<BitmapFetcherRequest> request(
-      new BitmapFetcherRequest(request_id, observer));
+  auto request = base::MakeUnique<BitmapFetcherRequest>(request_id, observer);
 
   // Reject invalid URLs.
   if (!url.is_valid())
     return REQUEST_ID_INVALID;
 
   // Check for existing images first.
   auto iter = cache_.Get(url);
   if (iter != cache_.end()) {
     BitmapFetcherService::CacheEntry* entry = iter->second.get();
     request->NotifyImageChanged(entry->bitmap.get());
 
     // There is no request ID associated with this - data is already delivered.
     return REQUEST_ID_INVALID;
   }
 
   // Limit number of simultaneous in-flight requests.
   if (requests_.size() > kMaxRequests)
     return REQUEST_ID_INVALID;
 
   // Make sure there's a fetcher for this URL and attach to request.
   const chrome::BitmapFetcher* fetcher =
       EnsureFetcherForUrl(url, traffic_annotation);
   request->set_fetcher(fetcher);
 
-  requests_.push_back(request.release());
+  requests_.push_back(std::move(request));
   return requests_.back()->request_id();
 }
 
 void BitmapFetcherService::Prefetch(
     const GURL& url,
     const net::NetworkTrafficAnnotationTag& traffic_annotation) {
   if (url.is_valid())
     EnsureFetcherForUrl(url, traffic_annotation);
 }
 
@@ skipping 45 matching lines @@
   DCHECK(it != active_fetchers_.end());
   active_fetchers_.erase(it);
 }
 
 void BitmapFetcherService::OnFetchComplete(const GURL& url,
                                            const SkBitmap* bitmap) {
   const chrome::BitmapFetcher* fetcher = FindFetcherForUrl(url);
   DCHECK(fetcher);
 
   // Notify all attached requests of completion.
-  ScopedVector<BitmapFetcherRequest>::iterator iter = requests_.begin();
+  auto iter = requests_.begin();
   while (iter != requests_.end()) {
     if ((*iter)->get_fetcher() == fetcher) {
       (*iter)->NotifyImageChanged(bitmap);
       iter = requests_.erase(iter);
     } else {
       ++iter;
     }
   }
 
   if (bitmap && !bitmap->isNull()) {
     std::unique_ptr<CacheEntry> entry(new CacheEntry);
     entry->bitmap.reset(new SkBitmap(*bitmap));
     cache_.Put(fetcher->url(), std::move(entry));
   }
 
   RemoveFetcher(fetcher);
 }