Remove ScopedVector in //components/dom_distiller/

components/dom_distiller/core/distiller_unittest.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 <stddef.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 83 matching lines @@
 }
 
 struct MultipageDistillerData {
  public:
   MultipageDistillerData() {}
   ~MultipageDistillerData() {}
   vector<string> page_urls;
   vector<string> content;
   vector<vector<int> > image_ids;
   // The Javascript values returned by mock distiller.
-  ScopedVector<base::Value> distilled_values;
+  std::vector<std::unique_ptr<base::Value>> distilled_values;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MultipageDistillerData);
 };
 
 void VerifyIncrementalUpdatesMatch(
     const MultipageDistillerData* distiller_data,
     int num_pages_in_article,
     const vector<dom_distiller::ArticleDistillationUpdate>& incremental_updates,
     int start_page_num) {
@@ skipping 54 matching lines @@
                               base::SizeTToString(page_num));
     result->image_ids.push_back(vector<int>());
     string next_page_url =
         GenerateNextPageUrl(url_prefix, page_num, pages_size);
     string prev_page_url =
         GeneratePrevPageUrl(url_prefix, page_num);
     std::unique_ptr<base::Value> distilled_value =
         CreateDistilledValueReturnedFromJS(kTitle, result->content[page_num],
                                            result->image_ids[page_num],
                                            next_page_url, prev_page_url);
-    result->distilled_values.push_back(distilled_value.release());
+    result->distilled_values.push_back(std::move(distilled_value));
   }
   return result;
 }
 
 void VerifyArticleProtoMatchesMultipageData(
     const dom_distiller::DistilledArticleProto* article_proto,
     const MultipageDistillerData* distiller_data,
     size_t distilled_pages_size,
     size_t total_pages_size) {
   ASSERT_EQ(distilled_pages_size,
@@ skipping 138 matching lines @@
     int start_page_num) {
   MockDistillerPage* distiller_page = new MockDistillerPage();
   {
     testing::InSequence s;
     vector<int> page_nums = GetPagesInSequence(start_page_num, pages_size);
     for (size_t page_num = 0; page_num < pages_size; ++page_num) {
       int page = page_nums[page_num];
       GURL url = GURL(distiller_data->page_urls[page]);
       EXPECT_CALL(*distiller_page, DistillPageImpl(url, _))
           .WillOnce(DistillerPageOnDistillationDone(
-              distiller_page, url, distiller_data->distilled_values[page]));
+              distiller_page, url,
+              distiller_data->distilled_values[page].get()));
     }
   }
   return std::unique_ptr<DistillerPage>(distiller_page);
 }
 
 TEST_F(DistillerTest, DistillPage) {
   base::MessageLoopForUI loop;
   std::unique_ptr<base::Value> result =
       CreateDistilledValueReturnedFromJS(kTitle, kContent, vector<int>(), "");
   distiller_.reset(
@@ skipping 136 matching lines @@
 
   // Note: Next page url of the last page of article is set. So distiller will
   // try to do kMaxPagesInArticle + 1 calls if the max article limit does not
   // work.
   std::unique_ptr<base::Value> last_page_data =
       CreateDistilledValueReturnedFromJS(
           kTitle, distiller_data->content[kMaxPagesInArticle - 1],
           vector<int>(), "", distiller_data->page_urls[kMaxPagesInArticle - 2]);
 
   distiller_data->distilled_values.pop_back();
-  distiller_data->distilled_values.push_back(last_page_data.release());
+  distiller_data->distilled_values.push_back(std::move(last_page_data));
 
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
 
   distiller_->SetMaxNumPagesInArticle(kMaxPagesInArticle);
 
   DistillPage(
       distiller_data->page_urls[0],
       CreateMockDistillerPages(distiller_data.get(), kMaxPagesInArticle, 0));
   base::RunLoop().RunUntilIdle();
@@ skipping 41 matching lines @@
   std::unique_ptr<MultipageDistillerData> distiller_data =
       CreateMultipageDistillerDataWithoutImages(kNumPages);
 
   // The page number of the failed page.
   size_t failed_page_num = 3;
   // reset distilled data of the failed page.
   distiller_data->distilled_values.erase(
       distiller_data->distilled_values.begin() + failed_page_num);
   distiller_data->distilled_values.insert(
       distiller_data->distilled_values.begin() + failed_page_num,
-      base::Value::CreateNullValue().release());
+      base::Value::CreateNullValue());
   // Expect only calls till the failed page number.
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(
       distiller_data->page_urls[0],
       CreateMockDistillerPages(distiller_data.get(), failed_page_num + 1, 0));
   base::RunLoop().RunUntilIdle();
   EXPECT_EQ(kTitle, article_proto_->title());
   VerifyArticleProtoMatchesMultipageData(
       article_proto_.get(), distiller_data.get(), failed_page_num, kNumPages);
@@ skipping 10 matching lines @@
   distiller_data->content[empty_page_num] = "";
   std::unique_ptr<base::Value> distilled_value =
       CreateDistilledValueReturnedFromJS(kTitle, "", vector<int>(),
       GenerateNextPageUrl(kURL, empty_page_num, kNumPages),
       GeneratePrevPageUrl(kURL, empty_page_num));
   // Reset distilled data of the first page.
   distiller_data->distilled_values.erase(
       distiller_data->distilled_values.begin() + empty_page_num);
   distiller_data->distilled_values.insert(
       distiller_data->distilled_values.begin() + empty_page_num,
-      distilled_value.release());
+      std::move(distilled_value));
 
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(distiller_data->page_urls[0],
               CreateMockDistillerPages(distiller_data.get(), 1, 0));
   base::RunLoop().RunUntilIdle();
   // If the first page has no content, stop fetching the next page.
   EXPECT_EQ(1, article_proto_->pages_size());
   VerifyArticleProtoMatchesMultipageData(
       article_proto_.get(), distiller_data.get(), 1, 1);
@@ skipping 10 matching lines @@
   distiller_data->content[empty_page_num] = "";
   std::unique_ptr<base::Value> distilled_value =
       CreateDistilledValueReturnedFromJS(kTitle, "", vector<int>(),
       GenerateNextPageUrl(kURL, empty_page_num, kNumPages),
       GeneratePrevPageUrl(kURL, empty_page_num));
   // Reset distilled data of the second page.
   distiller_data->distilled_values.erase(
       distiller_data->distilled_values.begin() + empty_page_num);
   distiller_data->distilled_values.insert(
       distiller_data->distilled_values.begin() + empty_page_num,
-      distilled_value.release());
+      std::move(distilled_value));
 
   distiller_.reset(
       new DistillerImpl(url_fetcher_factory_, DomDistillerOptions()));
   DistillPage(distiller_data->page_urls[0],
               CreateMockDistillerPages(distiller_data.get(), kNumPages, 0));
   base::RunLoop().RunUntilIdle();
 
   VerifyArticleProtoMatchesMultipageData(
       article_proto_.get(), distiller_data.get(), kNumPages, kNumPages);
 }
@@ skipping 122 matching lines @@
 
   ASSERT_TRUE(distiller_page);
   // Post the task to execute javascript and then delete the distiller.
   distiller_page->OnDistillationDone(GURL(kURL), distilled_value.get());
   distiller_.reset();
 
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace dom_distiller