Replace ScopedVector with vector<scoped_ptr> in BitmapFetcherService.

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 "base/memory/weak_ptr.h"
 #include "chrome/browser/bitmap_fetcher/bitmap_fetcher.h"
 #include "chrome/browser/profiles/profile.h"
 #include "net/base/load_flags.h"
@@ skipping 100 matching lines @@
 
   requests_.push_back(request.release());
   return requests_.back()->request_id();
 }
 
 void BitmapFetcherService::Prefetch(const GURL& url) {
   if (url.is_valid())
     EnsureFetcherForUrl(url);
 }
 
-chrome::BitmapFetcher* BitmapFetcherService::CreateFetcher(const GURL& url) {
-  chrome::BitmapFetcher* new_fetcher = new chrome::BitmapFetcher(url, this);
+scoped_ptr<chrome::BitmapFetcher> BitmapFetcherService::CreateFetcher(
+    const GURL& url) {
+  scoped_ptr<chrome::BitmapFetcher> new_fetcher(
+      new chrome::BitmapFetcher(url, this));
 
   new_fetcher->Init(
       context_->GetRequestContext(),
       std::string(),
       net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE,
       net::LOAD_NORMAL);
   new_fetcher->Start();
   return new_fetcher;
 }
 
 const chrome::BitmapFetcher* BitmapFetcherService::EnsureFetcherForUrl(
     const GURL& url) {
   const chrome::BitmapFetcher* fetcher = FindFetcherForUrl(url);
   if (fetcher)
     return fetcher;
 
-  chrome::BitmapFetcher* new_fetcher = CreateFetcher(url);
-  active_fetchers_.push_back(new_fetcher);
-  return new_fetcher;
+  scoped_ptr<chrome::BitmapFetcher> new_fetcher = CreateFetcher(url);
+  active_fetchers_.push_back(new_fetcher.Pass());
+  return active_fetchers_.back().get();
 }
 
 const chrome::BitmapFetcher* BitmapFetcherService::FindFetcherForUrl(
     const GURL& url) {
-  for (BitmapFetchers::iterator iter = active_fetchers_.begin();
-       iter != active_fetchers_.end();
-       ++iter) {
-    if (url == (*iter)->url())
-      return *iter;
+  for (auto it = active_fetchers_.begin(); it != active_fetchers_.end(); ++it) {
+    if (url == (*it)->url())
+      return it->get();
   }
-  return NULL;
+  return nullptr;
 }
 
 void BitmapFetcherService::RemoveFetcher(const chrome::BitmapFetcher* fetcher) {
-  for (BitmapFetchers::iterator iter = active_fetchers_.begin();
-       iter != active_fetchers_.end();
-       ++iter) {
-    if (fetcher == (*iter)) {
-      active_fetchers_.erase(iter);
-      return;
-    }
-  }
-  NOTREACHED();  // RemoveFetcher should always result in removal.
+  auto it =
+      std::find(active_fetchers_.begin(), active_fetchers_.end(), fetcher);

[danakj, 2015/11/11 01:29:08]

find() won't work with unique_ptr cuz it doesn't have operator==(T*), you'd have
to compare to another unique_ptr. We should remove that from scoped_ptr, so I
won't add a use of it here, and reverted back to a for loop (I could do find_if
but that's pretty verbose).

+  // RemoveFetcher should always result in removal.
+  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();
   while (iter != requests_.end()) {
     if ((*iter)->get_fetcher() == fetcher) {
       (*iter)->NotifyImageChanged(bitmap);
       iter = requests_.erase(iter);
     } else {
       ++iter;
     }
   }
 
   if (bitmap && !bitmap->isNull()) {
     CacheEntry* entry = new CacheEntry;
     entry->bitmap.reset(new SkBitmap(*bitmap));
     cache_.Put(fetcher->url(), entry);
   }
 
   RemoveFetcher(fetcher);
 }