Convert Pass()→std::move() in //content/browser

content/browser/presentation/presentation_service_impl_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 "content/browser/presentation/presentation_service_impl.h"
+
 #include <stddef.h>
 #include <stdint.h>
-
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/location.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/test/test_timeouts.h"
 #include "base/thread_task_runner_handle.h"
-#include "content/browser/presentation/presentation_service_impl.h"
 #include "content/public/browser/presentation_service_delegate.h"
 #include "content/public/browser/presentation_session.h"
 #include "content/public/common/presentation_constants.h"
 #include "content/test/test_render_frame_host.h"
 #include "content/test/test_render_view_host.h"
 #include "content/test/test_web_contents.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "mojo/public/cpp/bindings/string.h"
 #include "testing/gmock/include/gmock/gmock.h"
 
@@ skipping 132 matching lines @@
   }
   MOCK_METHOD2(OnConnectionStateChanged,
                void(const presentation::PresentationSessionInfo& connection,
                     presentation::PresentationConnectionState new_state));
 
   MOCK_METHOD1(OnScreenAvailabilityNotSupported, void(const mojo::String& url));
 
   void OnSessionMessagesReceived(
       presentation::PresentationSessionInfoPtr session_info,
       mojo::Array<presentation::SessionMessagePtr> messages) override {
-    messages_received_ = messages.Pass();
+    messages_received_ = std::move(messages);
     MessagesReceived();
   }
   MOCK_METHOD0(MessagesReceived, void());
 
   void OnDefaultSessionStarted(
       presentation::PresentationSessionInfoPtr session_info) override {
     OnDefaultSessionStarted(*session_info);
   }
   MOCK_METHOD1(OnDefaultSessionStarted,
                void(const presentation::PresentationSessionInfo& session_info));
 
   mojo::Array<presentation::SessionMessagePtr> messages_received_;
 };
 
 class PresentationServiceImplTest : public RenderViewHostImplTestHarness {
  public:
   PresentationServiceImplTest() : default_session_started_count_(0) {}
 
   void SetUp() override {
     RenderViewHostImplTestHarness::SetUp();
 
     auto request = mojo::GetProxy(&service_ptr_);
     EXPECT_CALL(mock_delegate_, AddObserver(_, _, _)).Times(1);
     service_impl_.reset(new PresentationServiceImpl(
         contents()->GetMainFrame(), contents(), &mock_delegate_));
-    service_impl_->Bind(request.Pass());
+    service_impl_->Bind(std::move(request));
 
     presentation::PresentationServiceClientPtr client_ptr;
     client_binding_.reset(
         new mojo::Binding<presentation::PresentationServiceClient>(
             &mock_client_, mojo::GetProxy(&client_ptr)));
-    service_impl_->SetClient(client_ptr.Pass());
+    service_impl_->SetClient(std::move(client_ptr));
   }
 
   void TearDown() override {
     service_ptr_.reset();
     if (service_impl_.get()) {
       EXPECT_CALL(mock_delegate_, RemoveObserver(_, _)).Times(1);
       service_impl_.reset();
     }
     RenderViewHostImplTestHarness::TearDown();
   }
@@ skipping 115 matching lines @@
                         SaveArg<3>(&message_cb)));
     service_ptr_->ListenForSessionMessages(session.Clone());
     run_loop.Run();
     }
 
     ScopedVector<PresentationSessionMessage> messages;
     scoped_ptr<content::PresentationSessionMessage> message;
     message.reset(
         new content::PresentationSessionMessage(PresentationMessageType::TEXT));
     message->message = text_msg;
-    messages.push_back(message.Pass());
+    messages.push_back(std::move(message));
     message.reset(new content::PresentationSessionMessage(
         PresentationMessageType::ARRAY_BUFFER));
     message->data.reset(new std::vector<uint8_t>(binary_data));
-    messages.push_back(message.Pass());
+    messages.push_back(std::move(message));
 
     std::vector<presentation::SessionMessagePtr> actual_msgs;
     {
       base::RunLoop run_loop;
       EXPECT_CALL(mock_client_, MessagesReceived())
           .WillOnce(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit));
-      message_cb.Run(messages.Pass(), pass_ownership);
+      message_cb.Run(std::move(messages), pass_ownership);
       run_loop.Run();
     }
     ExpectSessionMessages(expected_msgs, mock_client_.messages_received_);
   }
 
   MockPresentationServiceDelegate mock_delegate_;
 
   scoped_ptr<PresentationServiceImpl> service_impl_;
   mojo::InterfacePtr<presentation::PresentationService> service_ptr_;
 
@@ skipping 272 matching lines @@
   presentation::PresentationSessionInfoPtr session(
       presentation::PresentationSessionInfo::New());
   session->url = kPresentationUrl;
   session->id = kPresentationId;
   presentation::SessionMessagePtr message_request(
       presentation::SessionMessage::New());
   message_request->type = presentation::PresentationMessageType::
                           PRESENTATION_MESSAGE_TYPE_TEXT;
   message_request->message = message;
   service_ptr_->SendSessionMessage(
-      session.Pass(), message_request.Pass(),
+      std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendMessageMojoCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<3>(&test_message), SaveArg<4>(&send_message_cb)));
   run_loop.Run();
@@ skipping 18 matching lines @@
   presentation::PresentationSessionInfoPtr session(
       presentation::PresentationSessionInfo::New());
   session->url = kPresentationUrl;
   session->id = kPresentationId;
   presentation::SessionMessagePtr message_request(
       presentation::SessionMessage::New());
   message_request->type = presentation::PresentationMessageType::
                           PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER;
   message_request->data = mojo::Array<uint8_t>::From(data);
   service_ptr_->SendSessionMessage(
-      session.Pass(), message_request.Pass(),
+      std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendMessageMojoCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<3>(&test_message), SaveArg<4>(&send_message_cb)));
   run_loop.Run();
@@ skipping 24 matching lines @@
   presentation::PresentationSessionInfoPtr session(
       presentation::PresentationSessionInfo::New());
   session->url = kPresentationUrl;
   session->id = kPresentationId;
   presentation::SessionMessagePtr message_request(
       presentation::SessionMessage::New());
   message_request->type = presentation::PresentationMessageType::
                           PRESENTATION_MESSAGE_TYPE_ARRAY_BUFFER;
   message_request->data = mojo::Array<uint8_t>::From(data);
   service_ptr_->SendSessionMessage(
-      session.Pass(), message_request.Pass(),
+      std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendMessageMojoCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<3>(&test_message), SaveArg<4>(&send_message_cb)));
   run_loop.Run();
@@ skipping 11 matching lines @@
   presentation::PresentationSessionInfoPtr session(
       presentation::PresentationSessionInfo::New());
   session->url = kPresentationUrl;
   session->id = kPresentationId;
   presentation::SessionMessagePtr message_request(
       presentation::SessionMessage::New());
   message_request->type =
       presentation::PresentationMessageType::PRESENTATION_MESSAGE_TYPE_BLOB;
   message_request->data = mojo::Array<uint8_t>::From(data);
   service_ptr_->SendSessionMessage(
-      session.Pass(), message_request.Pass(),
+      std::move(session), std::move(message_request),
       base::Bind(&PresentationServiceImplTest::ExpectSendMessageMojoCallback,
                  base::Unretained(this)));
 
   base::RunLoop run_loop;
   base::Callback<void(bool)> send_message_cb;
   PresentationSessionMessage* test_message = nullptr;
   EXPECT_CALL(mock_delegate_, SendMessageRawPtr(_, _, _, _, _))
       .WillOnce(DoAll(InvokeWithoutArgs(&run_loop, &base::RunLoop::Quit),
                       SaveArg<3>(&test_message), SaveArg<4>(&send_message_cb)));
   run_loop.Run();
@@ skipping 38 matching lines @@
 
 TEST_F(PresentationServiceImplTest, ScreenAvailabilityNotSupported) {
   mock_delegate_.set_screen_availability_listening_supported(false);
   EXPECT_CALL(mock_client_,
               OnScreenAvailabilityNotSupported(Eq(kPresentationUrl)));
 
   ListenForScreenAvailabilityAndWait(kPresentationUrl, false);
 }
 
 }  // namespace content