Convert Pass()→std::move() in //components/[n-z]*

components/offline_pages/offline_page_model_unittest.cc

 // Copyright 2015 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/offline_pages/offline_page_model.h"
 
 #include <stdint.h>
-
 #include <algorithm>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_mock_time_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/time.h"
@@ skipping 111 matching lines @@
       last_save_result_(SavePageResult::CANCELLED),
       last_delete_result_(DeletePageResult::CANCELLED),
       last_deleted_bookmark_id_(-1) {
 }
 
 OfflinePageModelTest::~OfflinePageModelTest() {
 }
 
 void OfflinePageModelTest::SetUp() {
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
-  model_ = BuildModel(BuildStore().Pass()).Pass();
+  model_ = BuildModel(BuildStore());
   model_->AddObserver(this);
   PumpLoop();
 }
 
 void OfflinePageModelTest::TearDown() {
   model_->RemoveObserver(this);
   model_.reset();
   PumpLoop();
 }
 
@@ skipping 38 matching lines @@
 }
 
 scoped_ptr<OfflinePageMetadataStore> OfflinePageModelTest::BuildStore() {
   return scoped_ptr<OfflinePageMetadataStore>(
       new OfflinePageTestStore(base::ThreadTaskRunnerHandle::Get()));
 }
 
 scoped_ptr<OfflinePageModel> OfflinePageModelTest::BuildModel(
     scoped_ptr<OfflinePageMetadataStore> store) {
   return scoped_ptr<OfflinePageModel>(new OfflinePageModel(
-      store.Pass(), temp_dir_.path(), base::ThreadTaskRunnerHandle::Get()));
+      std::move(store), temp_dir_.path(), base::ThreadTaskRunnerHandle::Get()));
 }
 
 void OfflinePageModelTest::ResetModel() {
   model_->RemoveObserver(this);
   OfflinePageTestStore* old_store = GetStore();
   scoped_ptr<OfflinePageMetadataStore> new_store(
       new OfflinePageTestStore(*old_store));
-  model_ = BuildModel(new_store.Pass()).Pass();
+  model_ = BuildModel(std::move(new_store));
   model_->AddObserver(this);
   PumpLoop();
 }
 
 void OfflinePageModelTest::PumpLoop() {
   task_runner_->RunUntilIdle();
 }
 
 void OfflinePageModelTest::FastForwardBy(base::TimeDelta delta) {
   task_runner_->FastForwardBy(delta);
@@ skipping 13 matching lines @@
   SavePageWithArchiverResult(
       url,
       bookmark_id,
       OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED);
 }
 
 void OfflinePageModelTest::SavePageWithArchiverResult(
     const GURL& url,
     int64_t bookmark_id,
     OfflinePageArchiver::ArchiverResult result) {
-  scoped_ptr<OfflinePageTestArchiver> archiver(
-      BuildArchiver(url, result).Pass());
+  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(url, result));
   model()->SavePage(
-      url, bookmark_id, archiver.Pass(),
+      url, bookmark_id, std::move(archiver),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 }
 
 TEST_F(OfflinePageModelTest, SavePageSuccessful) {
   EXPECT_FALSE(model()->HasOfflinePages());
   SavePage(kTestUrl, kTestPageBookmarkId1);
   EXPECT_TRUE(model()->HasOfflinePages());
 
   OfflinePageTestStore* store = GetStore();
@@ skipping 45 matching lines @@
   SavePageWithArchiverResult(
       kTestUrl,
       kTestPageBookmarkId1,
       OfflinePageArchiver::ArchiverResult::ERROR_ARCHIVE_CREATION_FAILED);
   EXPECT_EQ(SavePageResult::ARCHIVE_CREATION_FAILED, last_save_result());
 }
 
 TEST_F(OfflinePageModelTest, SavePageOfflineArchiverReturnedWrongUrl) {
   scoped_ptr<OfflinePageTestArchiver> archiver(
       BuildArchiver(GURL("http://other.random.url.com"),
-                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
-          .Pass());
+                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED));
   model()->SavePage(
-      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      kTestUrl, kTestPageBookmarkId1, std::move(archiver),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
   EXPECT_EQ(SavePageResult::ARCHIVE_CREATION_FAILED, last_save_result());
 }
 
 TEST_F(OfflinePageModelTest, SavePageOfflineCreationStoreWriteFailure) {
   GetStore()->set_test_scenario(
       OfflinePageTestStore::TestScenario::WRITE_FAILED);
   SavePage(kTestUrl, kTestPageBookmarkId1);
   EXPECT_EQ(SavePageResult::STORE_FAILURE, last_save_result());
 }
 
 TEST_F(OfflinePageModelTest, SavePageLocalFileFailed) {
   // Don't create archiver since it will not be needed for pages that are not
   // going to be saved.
   model()->SavePage(
       kFileUrl, kTestPageBookmarkId1, scoped_ptr<OfflinePageTestArchiver>(),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
   EXPECT_EQ(SavePageResult::SKIPPED, last_save_result());
 }
 
 TEST_F(OfflinePageModelTest, SavePageOfflineArchiverTwoPages) {
-  scoped_ptr<OfflinePageTestArchiver> archiver(
-      BuildArchiver(kTestUrl,
-                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
-          .Pass());
+  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
+      kTestUrl, OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED));
   // archiver_ptr will be valid until after first PumpLoop() call after
   // CompleteCreateArchive() is called.
   OfflinePageTestArchiver* archiver_ptr = archiver.get();
   archiver_ptr->set_delayed(true);
   model()->SavePage(
-      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      kTestUrl, kTestPageBookmarkId1, std::move(archiver),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   EXPECT_TRUE(archiver_ptr->create_archive_called());
 
   // Request to save another page.
   SavePage(kTestUrl2, kTestPageBookmarkId2);
 
   OfflinePageTestStore* store = GetStore();
 
   EXPECT_EQ(kTestUrl2, store->last_saved_page().url);
   EXPECT_EQ(kTestPageBookmarkId2, store->last_saved_page().bookmark_id);
@@ skipping 74 matching lines @@
   model()->UndoPageDeletion(kTestPageBookmarkId1);
   PumpLoop();
 
   // GetAllPages will now return the restored page.
   const std::vector<OfflinePageItem>& offline_pages_after_undo =
       model()->GetAllPages();
   EXPECT_EQ(1UL, offline_pages_after_undo.size());
 }
 
 TEST_F(OfflinePageModelTest, FinalizePageDeletion) {
-  scoped_ptr<OfflinePageTestArchiver> archiver(
-      BuildArchiver(kTestUrl,
-                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
-          .Pass());
+  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
+      kTestUrl, OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED));
   model()->SavePage(
-      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      kTestUrl, kTestPageBookmarkId1, std::move(archiver),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 
   // Mark the page for deletion.
   model()->MarkPageForDeletion(
       kTestPageBookmarkId1,
       base::Bind(&OfflinePageModelTest::OnDeletePageDone, AsWeakPtr()));
   PumpLoop();
 
   EXPECT_EQ(1UL, GetStore()->GetAllPages().size());
@@ skipping 116 matching lines @@
   PumpLoop();
 
   EXPECT_EQ(last_deleted_bookmark_id(), kTestPageBookmarkId1);
   EXPECT_EQ(0UL, model()->GetAllPages().size());
 }
 
 TEST_F(OfflinePageModelTest, DeleteMultiplePages) {
   OfflinePageTestStore* store = GetStore();
 
   // Save 3 pages.
-  scoped_ptr<OfflinePageTestArchiver> archiver(
-      BuildArchiver(kTestUrl,
-                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
-          .Pass());
+  scoped_ptr<OfflinePageTestArchiver> archiver(BuildArchiver(
+      kTestUrl, OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED));
   model()->SavePage(
-      kTestUrl, kTestPageBookmarkId1, archiver.Pass(),
+      kTestUrl, kTestPageBookmarkId1, std::move(archiver),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 
-  scoped_ptr<OfflinePageTestArchiver> archiver2(
-      BuildArchiver(kTestUrl2,
-                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
-          .Pass());
+  scoped_ptr<OfflinePageTestArchiver> archiver2(BuildArchiver(
+      kTestUrl2, OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED));
   model()->SavePage(
-      kTestUrl2, kTestPageBookmarkId2, archiver2.Pass(),
+      kTestUrl2, kTestPageBookmarkId2, std::move(archiver2),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 
-  scoped_ptr<OfflinePageTestArchiver> archiver3(
-      BuildArchiver(kTestUrl3,
-                    OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED)
-          .Pass());
+  scoped_ptr<OfflinePageTestArchiver> archiver3(BuildArchiver(
+      kTestUrl3, OfflinePageArchiver::ArchiverResult::SUCCESSFULLY_CREATED));
   model()->SavePage(
-      kTestUrl3, kTestPageBookmarkId3, archiver3.Pass(),
+      kTestUrl3, kTestPageBookmarkId3, std::move(archiver3),
       base::Bind(&OfflinePageModelTest::OnSavePageDone, AsWeakPtr()));
   PumpLoop();
 
   EXPECT_EQ(3u, store->GetAllPages().size());
 
   // Delete multiple pages.
   std::vector<int64_t> ids_to_delete;
   ids_to_delete.push_back(kTestPageBookmarkId2);
   ids_to_delete.push_back(kTestPageBookmarkId1);
   ids_to_delete.push_back(23434LL);  // Non-existent ID.
@@ skipping 192 matching lines @@
   bookmark_undo_provider_ = provider;
 }
 
 void OfflinePageModelBookmarkChangeTest::OnBookmarkNodeRemoved(
     bookmarks::BookmarkModel* model,
     const bookmarks::BookmarkNode* parent,
     int index,
     scoped_ptr<bookmarks::BookmarkNode> node) {
   removed_bookmark_parent_ = parent;
   removed_bookmark_index_ = index;
-  removed_bookmark_node_ = node.Pass();
+  removed_bookmark_node_ = std::move(node);
 }
 
 const bookmarks::BookmarkNode*
 OfflinePageModelBookmarkChangeTest::CreateBookmarkNode(const GURL& url) {
   const bookmarks::BookmarkNode* bookmark_root =
       bookmark_model()->bookmark_bar_node();
   return bookmark_model()->AddURL(bookmark_root, 0, base::string16(), url);
 }
 
 void OfflinePageModelBookmarkChangeTest::UndoBookmarkRemoval() {
-  bookmark_undo_provider_->RestoreRemovedNode(removed_bookmark_parent_,
-                                              removed_bookmark_index_,
-                                              removed_bookmark_node_.Pass());
+  bookmark_undo_provider_->RestoreRemovedNode(
+      removed_bookmark_parent_, removed_bookmark_index_,
+      std::move(removed_bookmark_node_));
   removed_bookmark_parent_ = nullptr;
   removed_bookmark_index_ = -1;
 }
 
 TEST_F(OfflinePageModelBookmarkChangeTest, ChangeBookmakeTitle) {
   // Creates a bookmark without offline copy.
   const bookmarks::BookmarkNode* bookmark_node = CreateBookmarkNode(kTestUrl);
   EXPECT_EQ(0UL, model()->GetAllPages().size());
 
   // Changing the bookmark title should have no effect.
@@ skipping 81 matching lines @@
   PumpLoop();
   EXPECT_EQ(0UL, model()->GetAllPages().size());
 
   // The offline copy should be restored upon the bookmark restore.
   UndoBookmarkRemoval();
   PumpLoop();
   EXPECT_EQ(1UL, model()->GetAllPages().size());
 }
 
 }  // namespace offline_pages