Remove ScopedVector in //components/dom_distiller/

components/dom_distiller/core/distiller.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 "components/dom_distiller/core/distiller.h"
 
 #include <map>
 #include <utility>
 #include <vector>
 
 #include "base/auto_reset.h"
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/location.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "components/dom_distiller/core/distiller_page.h"
 #include "components/dom_distiller/core/distiller_url_fetcher.h"
 #include "components/dom_distiller/core/proto/distilled_article.pb.h"
 #include "components/dom_distiller/core/proto/distilled_page.pb.h"
@@ skipping 63 matching lines @@
 
 bool DistillerImpl::IsPageNumberInUse(int page_num) const {
   return waiting_pages_.find(page_num) != waiting_pages_.end() ||
          started_pages_index_.find(page_num) != started_pages_index_.end() ||
          finished_pages_index_.find(page_num) != finished_pages_index_.end();
 }
 
 DistillerImpl::DistilledPageData* DistillerImpl::GetPageAtIndex(size_t index)
     const {
   DCHECK_LT(index, pages_.size());
-  DistilledPageData* page_data = pages_[index];
+  DistilledPageData* page_data = pages_[index].get();
   DCHECK(page_data);
   return page_data;
 }
 
 void DistillerImpl::DistillPage(const GURL& url,
                                 std::unique_ptr<DistillerPage> distiller_page,
                                 const DistillationFinishedCallback& finished_cb,
                                 const DistillationUpdateCallback& update_cb) {
   DCHECK(AreAllPagesFinished());
   distiller_page_ = std::move(distiller_page);
   finished_cb_ = finished_cb;
   update_cb_ = update_cb;
 
   AddToDistillationQueue(0, url);
   DistillNextPage();
 }
 
 void DistillerImpl::DistillNextPage() {
   if (!waiting_pages_.empty()) {
     std::map<int, GURL>::iterator front = waiting_pages_.begin();
     int page_num = front->first;
     const GURL url = front->second;
 
     waiting_pages_.erase(front);
     DCHECK(url.is_valid());
     DCHECK(started_pages_index_.find(page_num) == started_pages_index_.end());
     DCHECK(finished_pages_index_.find(page_num) == finished_pages_index_.end());
     seen_urls_.insert(url.spec());
-    pages_.push_back(new DistilledPageData());
+    pages_.push_back(base::MakeUnique<DistilledPageData>());
     started_pages_index_[page_num] = pages_.size() - 1;
     distiller_page_->DistillPage(
         url,
         dom_distiller_options_,
         base::Bind(&DistillerImpl::OnPageDistillationFinished,
                    weak_factory_.GetWeakPtr(),
                    page_num,
                    url));
   }
 }
@@ skipping 146 matching lines @@
 }
 
 void DistillerImpl::FetchImage(int page_num,
                                const std::string& image_id,
                                const std::string& image_url) {
   if (!GURL(image_url).is_valid()) return;
   DCHECK(started_pages_index_.find(page_num) != started_pages_index_.end());
   DistilledPageData* page_data = GetPageAtIndex(started_pages_index_[page_num]);
   DistillerURLFetcher* fetcher =
       distiller_url_fetcher_factory_.CreateDistillerURLFetcher();
-  page_data->image_fetchers_.push_back(fetcher);
+  page_data->image_fetchers_.push_back(base::WrapUnique(fetcher));
 
   fetcher->FetchURL(image_url,
                     base::Bind(&DistillerImpl::OnFetchImageDone,
                                weak_factory_.GetWeakPtr(),
                                page_num,
                                base::Unretained(fetcher),
                                image_id,
                                image_url));
 }
 
 void DistillerImpl::OnFetchImageDone(int page_num,
                                      DistillerURLFetcher* url_fetcher,
                                      const std::string& id,
                                      const std::string& original_url,
                                      const std::string& response) {
   DCHECK(started_pages_index_.find(page_num) != started_pages_index_.end());
   DistilledPageData* page_data = GetPageAtIndex(started_pages_index_[page_num]);
   DCHECK(page_data->distilled_page_proto.get());
   DCHECK(url_fetcher);
-  ScopedVector<DistillerURLFetcher>::iterator fetcher_it =
-      std::find(page_data->image_fetchers_.begin(),
-                page_data->image_fetchers_.end(),
-                url_fetcher);
+  auto fetcher_it = std::find_if(
+      page_data->image_fetchers_.begin(), page_data->image_fetchers_.end(),
+      [url_fetcher](const std::unique_ptr<DistillerURLFetcher>& f) {
+        return url_fetcher == f.get();
+      });
 
   DCHECK(fetcher_it != page_data->image_fetchers_.end());
   // Delete the |url_fetcher| by DeleteSoon since the OnFetchImageDone
   // callback is invoked by the |url_fetcher|.
-  page_data->image_fetchers_.weak_erase(fetcher_it);
+  fetcher_it->release();
+  page_data->image_fetchers_.erase(fetcher_it);
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, url_fetcher);
 
   DistilledPageProto_Image* image =
       page_data->distilled_page_proto->data.add_image();
   image->set_name(id);
   image->set_data(response);
   image->set_url(original_url);
 
   AddPageIfDone(page_num);
 }
@@ skipping 62 matching lines @@
     DCHECK(finished_pages_index_.empty());
 
     base::AutoReset<bool> dont_delete_this_in_callback(&destruction_allowed_,
                                                        false);
     finished_cb_.Run(std::move(article_proto));
     finished_cb_.Reset();
   }
 }
 
 }  // namespace dom_distiller