Convert Pass()→std::move() in //chrome

chrome/browser/download/download_ui_controller_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 "chrome/browser/download/download_ui_controller.h"
+
+#include <utility>
+
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "chrome/browser/download/download_history.h"
 #include "chrome/browser/download/download_service_factory.h"
 #include "chrome/browser/download/download_service_impl.h"
-#include "chrome/browser/download/download_ui_controller.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/test/base/chrome_render_view_host_test_harness.h"
 #include "components/history/core/browser/download_row.h"
 #include "content/public/test/mock_download_item.h"
 #include "content/public/test/mock_download_manager.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::MockDownloadItem;
 using content::MockDownloadManager;
@@ skipping 146 matching lines @@
               RemoveObserver(testing::Eq(
                   testing::ByRef(download_history_manager_observer_))))
       .WillOnce(testing::Assign(
           &download_history_manager_observer_,
           static_cast<content::DownloadManager::Observer*>(NULL)));
   EXPECT_CALL(*manager_, GetAllDownloads(_)).Times(AnyNumber());
 
   scoped_ptr<HistoryAdapter> history_adapter(new HistoryAdapter);
   history_adapter_ = history_adapter.get();
   scoped_ptr<DownloadHistory> download_history(
-      new DownloadHistory(manager_.get(), history_adapter.Pass()));
+      new DownloadHistory(manager_.get(), std::move(history_adapter)));
   ASSERT_TRUE(download_history_manager_observer_);
 
   EXPECT_CALL(*manager_, AddObserver(_))
       .WillOnce(SaveArg<0>(&manager_observer_));
   EXPECT_CALL(*manager_,
               RemoveObserver(testing::Eq(testing::ByRef(manager_observer_))))
       .WillOnce(testing::Assign(
           &manager_observer_,
           static_cast<content::DownloadManager::Observer*>(NULL)));
   TestDownloadService* download_service = static_cast<TestDownloadService*>(
       DownloadServiceFactory::GetInstance()->SetTestingFactoryAndUse(
           browser_context(), &TestingDownloadServiceFactory));
   ASSERT_TRUE(download_service);
-  download_service->set_download_history(download_history.Pass());
+  download_service->set_download_history(std::move(download_history));
 }
 
 scoped_ptr<MockDownloadItem>
 DownloadUIControllerTest::CreateMockInProgressDownload() {
   scoped_ptr<MockDownloadItem> item(
       new testing::StrictMock<MockDownloadItem>());
   EXPECT_CALL(*item, GetBrowserContext())
       .WillRepeatedly(Return(browser_context()));
   EXPECT_CALL(*item, GetId()).WillRepeatedly(Return(1));
   EXPECT_CALL(*item, GetTargetFilePath()).WillRepeatedly(
@@ skipping 17 matching lines @@
       .WillRepeatedly(Return(content::DOWNLOAD_INTERRUPT_REASON_NONE));
   EXPECT_CALL(*item, GetReceivedBytes()).WillRepeatedly(Return(0));
   EXPECT_CALL(*item, GetTotalBytes()).WillRepeatedly(Return(0));
   EXPECT_CALL(*item, GetTargetDisposition()).WillRepeatedly(
       Return(content::DownloadItem::TARGET_DISPOSITION_OVERWRITE));
   EXPECT_CALL(*item, GetOpened()).WillRepeatedly(Return(false));
   EXPECT_CALL(*item, GetMimeType()).WillRepeatedly(Return(std::string()));
   EXPECT_CALL(*item, GetURL()).WillRepeatedly(testing::ReturnRefOfCopy(GURL()));
   EXPECT_CALL(*item, GetWebContents()).WillRepeatedly(Return(nullptr));
   EXPECT_CALL(*item, IsTemporary()).WillRepeatedly(Return(false));
-  return item.Pass();
+  return item;
 }
 
 scoped_ptr<DownloadUIController::Delegate>
 DownloadUIControllerTest::GetTestDelegate() {
   scoped_ptr<DownloadUIController::Delegate> delegate(
       new TestDelegate(notified_item_receiver_factory_.GetWeakPtr()));
-  return delegate.Pass();
+  return delegate;
 }
 
 // New downloads should be presented to the UI when GetTargetFilePath() returns
 // a non-empty path.  I.e. once the download target has been determined.
 TEST_F(DownloadUIControllerTest, DownloadUIController_NotifyBasic) {
   scoped_ptr<MockDownloadItem> item(CreateMockInProgressDownload());
   DownloadUIController controller(manager(), GetTestDelegate());
   EXPECT_CALL(*item, GetTargetFilePath())
       .WillOnce(ReturnRefOfCopy(base::FilePath()));
 
@@ skipping 74 matching lines @@
         base::Bind(&content::DownloadManager::Observer::OnDownloadCreated,
                    base::Unretained(download_history_manager_observer()),
                    manager(),
                    item.get());
     EXPECT_CALL(*manager(), MockCreateDownloadItem(_)).WillOnce(
         testing::DoAll(testing::InvokeWithoutArgs(&history_on_created_callback,
                                                   &base::Closure::Run),
                        Return(item.get())));
     EXPECT_CALL(mock_function, Call());
 
-    history_query_callback().Run(history_downloads.Pass());
+    history_query_callback().Run(std::move(history_downloads));
     mock_function.Call();
   }
 
   // Now pass along the notification to the OnDownloadCreated observer from
   // DownloadUIController. It should ignore the download since it's marked as
   // being restored from history.
   ASSERT_TRUE(manager_observer());
   manager_observer()->OnDownloadCreated(manager(), item.get());
 
   // Finally, the expectation we've been waiting for:
   EXPECT_FALSE(notified_item());
 }
 
 } // namespace