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

chrome/browser/media/router/media_router_mojo_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 <stddef.h>
 #include <stdint.h>
-
 #include <string>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/test/histogram_tester.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/media/router/issue.h"
@@ skipping 61 matching lines @@
   mojoIssue->title = title;
   mojoIssue->message = "msg";
   mojoIssue->route_id = "";
   mojoIssue->default_action =
       interfaces::Issue::ActionType::ACTION_TYPE_DISMISS;
   mojoIssue->secondary_actions =
       mojo::Array<interfaces::Issue::ActionType>::New(0);
   mojoIssue->severity = interfaces::Issue::Severity::SEVERITY_WARNING;
   mojoIssue->is_blocking = false;
   mojoIssue->help_url = "";
-  return mojoIssue.Pass();
+  return mojoIssue;
 }
 
 }  // namespace
 
 class RouteResponseCallbackHandler {
  public:
   MOCK_METHOD3(Invoke,
                void(const MediaRoute* route,
                     const std::string& presentation_id,
                     const std::string& error_text));
 };
 
 class SendMessageCallbackHandler {
  public:
   MOCK_METHOD1(Invoke, void(bool));
 };
 
 class ListenForMessagesCallbackHandler {
  public:
   ListenForMessagesCallbackHandler(
       ScopedVector<content::PresentationSessionMessage> expected_messages,
       bool pass_ownership)
-      : expected_messages_(expected_messages.Pass()),
+      : expected_messages_(std::move(expected_messages)),
         pass_ownership_(pass_ownership) {}
   void Invoke(const ScopedVector<content::PresentationSessionMessage>& messages,
               bool pass_ownership) {
     InvokeObserver();
     EXPECT_EQ(pass_ownership_, pass_ownership);
     EXPECT_EQ(messages.size(), expected_messages_.size());
     for (size_t i = 0; i < expected_messages_.size(); ++i) {
       EXPECT_TRUE(ArePresentationSessionMessagesEqual(expected_messages_[i],
                                                       messages[i]));
     }
@@ skipping 64 matching lines @@
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(mock_media_route_provider_,
               CreateRoute(mojo::String(kSource), mojo::String(kSinkId), _,
                           mojo::String(kOrigin), kInvalidTabId, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& sink,
           const mojo::String& presentation_id, const mojo::String& origin,
           int tab_id,
           const interfaces::MediaRouteProvider::CreateRouteCallback& cb) {
-        cb.Run(route.Pass(), mojo::String());
+        cb.Run(std::move(route), mojo::String());
       }));
 
   // MediaRouterMojoImpl will start observing local displayable routes as a
   // result of having one created.
   EXPECT_CALL(mock_media_route_provider_, StartObservingMediaRoutes());
 
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, Invoke(Pointee(Equals(expected_route)), Not(""), ""));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
@@ skipping 39 matching lines @@
   // Use a lambda function as an invocation target here to work around
   // a limitation with GMock::Invoke that prevents it from using move-only types
   // in runnable parameter lists.
   EXPECT_CALL(mock_media_route_provider_,
               JoinRoute(mojo::String(kSource), mojo::String(kPresentationId),
                         mojo::String(kOrigin), kInvalidTabId, _))
       .WillOnce(Invoke([&route](
           const mojo::String& source, const mojo::String& presentation_id,
           const mojo::String& origin, int tab_id,
           const interfaces::MediaRouteProvider::JoinRouteCallback& cb) {
-        cb.Run(route.Pass(), mojo::String());
+        cb.Run(std::move(route), mojo::String());
       }));
 
   // MediaRouterMojoImpl will start observing local displayable routes as a
   // result of having one created.
   EXPECT_CALL(mock_media_route_provider_, StartObservingMediaRoutes());
 
   RouteResponseCallbackHandler handler;
   EXPECT_CALL(handler, Invoke(Pointee(Equals(expected_route)), Not(""), ""));
   std::vector<MediaRouteResponseCallback> route_response_callbacks;
   route_response_callbacks.push_back(base::Bind(
@@ skipping 45 matching lines @@
 
   interfaces::IssuePtr mojo_issue1 = CreateMojoIssue("title 1");
   const Issue& expected_issue1 = mojo_issue1.To<Issue>();
 
   const Issue* issue;
   EXPECT_CALL(issue_observer1,
               OnIssueUpdated(Pointee(EqualsIssue(expected_issue1))))
       .WillOnce(SaveArg<0>(&issue));
   EXPECT_CALL(issue_observer2,
               OnIssueUpdated(Pointee(EqualsIssue(expected_issue1))));
-  media_router_proxy_->OnIssue(mojo_issue1.Pass());
+  media_router_proxy_->OnIssue(std::move(mojo_issue1));
   ProcessEventLoop();
 
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer1));
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
 
   EXPECT_CALL(issue_observer1, OnIssueUpdated(nullptr));
   EXPECT_CALL(issue_observer2, OnIssueUpdated(nullptr));
 
   router()->ClearIssue(issue->id());
 
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer1));
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
   router()->UnregisterIssuesObserver(&issue_observer1);
   interfaces::IssuePtr mojo_issue2 = CreateMojoIssue("title 2");
   const Issue& expected_issue2 = mojo_issue2.To<Issue>();
 
   EXPECT_CALL(issue_observer2,
               OnIssueUpdated(Pointee(EqualsIssue(expected_issue2))));
   router()->AddIssue(expected_issue2);
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
 
   EXPECT_CALL(issue_observer2, OnIssueUpdated(nullptr));
   router()->ClearIssue(issue->id());
   EXPECT_TRUE(Mock::VerifyAndClearExpectations(&issue_observer2));
 
   EXPECT_CALL(issue_observer2,
               OnIssueUpdated(Pointee(EqualsIssue(expected_issue2))));
-  media_router_proxy_->OnIssue(mojo_issue2.Pass());
+  media_router_proxy_->OnIssue(std::move(mojo_issue2));
   ProcessEventLoop();
 
   issue_observer1.UnregisterObserver();
   issue_observer2.UnregisterObserver();
 }
 
 TEST_F(MediaRouterMojoImplTest, RegisterAndUnregisterMediaSinksObserver) {
   router()->OnSinkAvailabilityUpdated(
       interfaces::MediaRouter::SINK_AVAILABILITY_AVAILABLE);
   MediaSource media_source(kSource);
@@ skipping 28 matching lines @@
       media_router::interfaces::MediaSink::IconType::ICON_TYPE_CAST;
   mojo_sinks[1] = interfaces::MediaSink::New();
   mojo_sinks[1]->sink_id = kSinkId2;
   mojo_sinks[1]->name = kSinkName;
   mojo_sinks[1]->icon_type =
       media_router::interfaces::MediaSink::IconType::ICON_TYPE_CAST;
 
   EXPECT_CALL(sinks_observer, OnSinksReceived(SequenceEquals(expected_sinks)));
   EXPECT_CALL(extra_sinks_observer,
               OnSinksReceived(SequenceEquals(expected_sinks)));
-  media_router_proxy_->OnSinksReceived(media_source.id(), mojo_sinks.Pass());
+  media_router_proxy_->OnSinksReceived(media_source.id(),
+                                       std::move(mojo_sinks));
   ProcessEventLoop();
 
   EXPECT_CALL(mock_media_route_provider_,
               StopObservingMediaSinks(mojo::String(kSource)));
   EXPECT_CALL(mock_media_route_provider_,
               StopObservingMediaSinks(mojo::String(kSource2)));
   router()->UnregisterMediaSinksObserver(&sinks_observer);
   router()->UnregisterMediaSinksObserver(&extra_sinks_observer);
   router()->UnregisterMediaSinksObserver(&unrelated_sinks_observer);
   ProcessEventLoop();
@@ skipping 128 matching lines @@
   mojo_routes[1]->media_route_id = kRouteId2;
   mojo_routes[1]->media_source = kSource;
   mojo_routes[1]->media_sink_id = kSinkId;
   mojo_routes[1]->description = kDescription;
   mojo_routes[1]->is_local = false;
 
   EXPECT_CALL(routes_observer,
               OnRoutesUpdated(SequenceEquals(expected_routes)));
   EXPECT_CALL(extra_routes_observer,
               OnRoutesUpdated(SequenceEquals(expected_routes)));
-  media_router_proxy_->OnRoutesUpdated(mojo_routes.Pass());
+  media_router_proxy_->OnRoutesUpdated(std::move(mojo_routes));
   ProcessEventLoop();
 
   EXPECT_CALL(mock_router, UnregisterMediaRoutesObserver(&routes_observer));
   EXPECT_CALL(mock_router,
               UnregisterMediaRoutesObserver(&extra_routes_observer));
   router()->UnregisterMediaRoutesObserver(&routes_observer);
   router()->UnregisterMediaRoutesObserver(&extra_routes_observer);
   EXPECT_CALL(mock_media_route_provider_, StopObservingMediaRoutes());
   ProcessEventLoop();
 }
@@ skipping 27 matching lines @@
           const MediaRoute::Id& route_id, const std::vector<uint8_t>& data,
           const interfaces::MediaRouteProvider::SendRouteMessageCallback& cb) {
         EXPECT_EQ(
             0, memcmp(kBinaryMessage, &(data[0]), arraysize(kBinaryMessage)));
         cb.Run(true);
       }));
 
   SendMessageCallbackHandler handler;
   EXPECT_CALL(handler, Invoke(true));
   router()->SendRouteBinaryMessage(
-      kRouteId, expected_binary_data.Pass(),
+      kRouteId, std::move(expected_binary_data),
       base::Bind(&SendMessageCallbackHandler::Invoke,
                  base::Unretained(&handler)));
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, PresentationSessionMessagesSingleObserver) {
   mojo::Array<interfaces::RouteMessagePtr> mojo_messages(2);
   mojo_messages[0] = interfaces::RouteMessage::New();
   mojo_messages[0]->type = interfaces::RouteMessage::Type::TYPE_TEXT;
   mojo_messages[0]->message = "text";
   mojo_messages[1] = interfaces::RouteMessage::New();
   mojo_messages[1]->type = interfaces::RouteMessage::Type::TYPE_BINARY;
   mojo_messages[1]->data.push_back(1);
 
   ScopedVector<content::PresentationSessionMessage> expected_messages;
   scoped_ptr<content::PresentationSessionMessage> message;
   message.reset(new content::PresentationSessionMessage(
       content::PresentationMessageType::TEXT));
   message->message = "text";
-  expected_messages.push_back(message.Pass());
+  expected_messages.push_back(std::move(message));
 
   message.reset(new content::PresentationSessionMessage(
       content::PresentationMessageType::ARRAY_BUFFER));
   message->data.reset(new std::vector<uint8_t>(1, 1));
-  expected_messages.push_back(message.Pass());
+  expected_messages.push_back(std::move(message));
 
   MediaRoute::Id expected_route_id("foo");
   interfaces::MediaRouteProvider::ListenForRouteMessagesCallback mojo_callback;
   EXPECT_CALL(mock_media_route_provider_,
               ListenForRouteMessages(Eq(expected_route_id), _))
       .WillOnce(SaveArg<1>(&mojo_callback));
 
   // |pass_ownership| param is "true" here because there is only one observer.
-  ListenForMessagesCallbackHandler handler(expected_messages.Pass(), true);
+  ListenForMessagesCallbackHandler handler(std::move(expected_messages), true);
 
   EXPECT_CALL(handler, InvokeObserver());
   // Creating PresentationSessionMessagesObserver will register itself to the
   // MediaRouter, which in turn will start listening for route messages.
   scoped_ptr<PresentationSessionMessagesObserver> observer(
       new PresentationSessionMessagesObserver(
           base::Bind(&ListenForMessagesCallbackHandler::Invoke,
                      base::Unretained(&handler)),
           expected_route_id, router()));
   ProcessEventLoop();
 
   // Simulate messages by invoking the saved mojo callback.
   // We expect one more ListenForRouteMessages call since |observer| was
   // still registered when the first set of messages arrived.
-  mojo_callback.Run(mojo_messages.Pass(), false);
+  mojo_callback.Run(std::move(mojo_messages), false);
   interfaces::MediaRouteProvider::ListenForRouteMessagesCallback
       mojo_callback_2;
   EXPECT_CALL(mock_media_route_provider_, ListenForRouteMessages(_, _))
       .WillOnce(SaveArg<1>(&mojo_callback_2));
   ProcessEventLoop();
 
   // Stop listening for messages. In particular, MediaRouterMojoImpl will not
   // call ListenForRouteMessages again when it sees there are no more observers.
   mojo::Array<interfaces::RouteMessagePtr> mojo_messages_2(1);
   mojo_messages_2[0] = interfaces::RouteMessage::New();
   mojo_messages_2[0]->type = interfaces::RouteMessage::Type::TYPE_TEXT;
   mojo_messages_2[0]->message = "foo";
   observer.reset();
-  mojo_callback_2.Run(mojo_messages_2.Pass(), false);
+  mojo_callback_2.Run(std::move(mojo_messages_2), false);
   EXPECT_CALL(mock_media_route_provider_, StopListeningForRouteMessages(_));
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, PresentationSessionMessagesMultipleObservers) {
   mojo::Array<interfaces::RouteMessagePtr> mojo_messages(2);
   mojo_messages[0] = interfaces::RouteMessage::New();
   mojo_messages[0]->type = interfaces::RouteMessage::Type::TYPE_TEXT;
   mojo_messages[0]->message = "text";
   mojo_messages[1] = interfaces::RouteMessage::New();
   mojo_messages[1]->type = interfaces::RouteMessage::Type::TYPE_BINARY;
   mojo_messages[1]->data.push_back(1);
 
   ScopedVector<content::PresentationSessionMessage> expected_messages;
   scoped_ptr<content::PresentationSessionMessage> message;
   message.reset(new content::PresentationSessionMessage(
       content::PresentationMessageType::TEXT));
   message->message = "text";
-  expected_messages.push_back(message.Pass());
+  expected_messages.push_back(std::move(message));
 
   message.reset(new content::PresentationSessionMessage(
       content::PresentationMessageType::ARRAY_BUFFER));
   message->data.reset(new std::vector<uint8_t>(1, 1));
-  expected_messages.push_back(message.Pass());
+  expected_messages.push_back(std::move(message));
 
   MediaRoute::Id expected_route_id("foo");
   interfaces::MediaRouteProvider::ListenForRouteMessagesCallback mojo_callback;
   EXPECT_CALL(mock_media_route_provider_,
               ListenForRouteMessages(Eq(expected_route_id), _))
       .WillOnce(SaveArg<1>(&mojo_callback));
 
   // |pass_ownership| param is "false" here because there are more than one
   // observers.
-  ListenForMessagesCallbackHandler handler(expected_messages.Pass(), false);
+  ListenForMessagesCallbackHandler handler(std::move(expected_messages), false);
 
   EXPECT_CALL(handler, InvokeObserver()).Times(2);
   // Creating PresentationSessionMessagesObserver will register itself to the
   // MediaRouter, which in turn will start listening for route messages.
   scoped_ptr<PresentationSessionMessagesObserver> observer1(
       new PresentationSessionMessagesObserver(
           base::Bind(&ListenForMessagesCallbackHandler::Invoke,
                      base::Unretained(&handler)),
           expected_route_id, router()));
   scoped_ptr<PresentationSessionMessagesObserver> observer2(
       new PresentationSessionMessagesObserver(
           base::Bind(&ListenForMessagesCallbackHandler::Invoke,
                      base::Unretained(&handler)),
           expected_route_id, router()));
   ProcessEventLoop();
 
   // Simulate messages by invoking the saved mojo callback.
   // We expect one more ListenForRouteMessages call since |observer| was
   // still registered when the first set of messages arrived.
-  mojo_callback.Run(mojo_messages.Pass(), false);
+  mojo_callback.Run(std::move(mojo_messages), false);
   interfaces::MediaRouteProvider::ListenForRouteMessagesCallback
       mojo_callback_2;
   EXPECT_CALL(mock_media_route_provider_, ListenForRouteMessages(_, _))
       .WillOnce(SaveArg<1>(&mojo_callback_2));
   ProcessEventLoop();
 
   // Stop listening for messages. In particular, MediaRouterMojoImpl will not
   // call ListenForRouteMessages again when it sees there are no more observers.
   mojo::Array<interfaces::RouteMessagePtr> mojo_messages_2(1);
   mojo_messages_2[0] = interfaces::RouteMessage::New();
   mojo_messages_2[0]->type = interfaces::RouteMessage::Type::TYPE_TEXT;
   mojo_messages_2[0]->message = "foo";
   observer1.reset();
   observer2.reset();
-  mojo_callback_2.Run(mojo_messages_2.Pass(), false);
+  mojo_callback_2.Run(std::move(mojo_messages_2), false);
   EXPECT_CALL(mock_media_route_provider_, StopListeningForRouteMessages(_));
   ProcessEventLoop();
 }
 
 TEST_F(MediaRouterMojoImplTest, PresentationSessionMessagesError) {
   MediaRoute::Id expected_route_id("foo");
   interfaces::MediaRouteProvider::ListenForRouteMessagesCallback mojo_callback;
   EXPECT_CALL(mock_media_route_provider_,
               ListenForRouteMessages(Eq(expected_route_id), _))
       .WillOnce(SaveArg<1>(&mojo_callback));
@@ skipping 62 matching lines @@
 
 TEST_F(MediaRouterMojoImplTest, HasLocalRoute) {
   EXPECT_FALSE(router()->HasLocalDisplayRoute());
   interfaces::MediaRoutePtr mojo_route1 = interfaces::MediaRoute::New();
   mojo_route1->media_route_id = "routeId1";
   mojo_route1->media_sink_id = "sinkId";
   mojo_route1->is_local = false;
   mojo_route1->for_display = false;
   router()->RouteResponseReceived("presentationId1",
                                   std::vector<MediaRouteResponseCallback>(),
-                                  mojo_route1.Pass(), "");
+                                  std::move(mojo_route1), "");
   EXPECT_FALSE(router()->HasLocalDisplayRoute());
 
   interfaces::MediaRoutePtr mojo_route2 = interfaces::MediaRoute::New();
   mojo_route2->media_route_id = "routeId2";
   mojo_route2->media_sink_id = "sinkId";
   mojo_route2->is_local = false;
   mojo_route2->for_display = true;
   router()->RouteResponseReceived("presentationId2",
                                   std::vector<MediaRouteResponseCallback>(),
-                                  mojo_route2.Pass(), "");
+                                  std::move(mojo_route2), "");
   EXPECT_FALSE(router()->HasLocalDisplayRoute());
 
   interfaces::MediaRoutePtr mojo_route3 = interfaces::MediaRoute::New();
   mojo_route3->media_route_id = "routeId3";
   mojo_route3->media_sink_id = "sinkId";
   mojo_route3->is_local = true;
   mojo_route3->for_display = false;
   router()->RouteResponseReceived("presentationId3",
                                   std::vector<MediaRouteResponseCallback>(),
-                                  mojo_route3.Pass(), "");
+                                  std::move(mojo_route3), "");
   EXPECT_FALSE(router()->HasLocalDisplayRoute());
 
   interfaces::MediaRoutePtr mojo_route4 = interfaces::MediaRoute::New();
   mojo_route4->media_route_id = "routeId4";
   mojo_route4->media_sink_id = "sinkId";
   mojo_route4->is_local = true;
   mojo_route4->for_display = true;
   router()->RouteResponseReceived("presentationId4",
                                   std::vector<MediaRouteResponseCallback>(),
-                                  mojo_route4.Pass(), "");
+                                  std::move(mojo_route4), "");
   EXPECT_TRUE(router()->HasLocalDisplayRoute());
 }
 
 TEST_F(MediaRouterMojoImplTest, QueuedWhileAsleep) {
   EXPECT_CALL(mock_event_page_tracker_, IsEventPageSuspended(extension_id()))
       .Times(2)
       .WillRepeatedly(Return(true));
   EXPECT_CALL(mock_event_page_tracker_, WakeEventPage(extension_id(), _))
       .Times(2)
       .WillRepeatedly(Return(true));
@@ skipping 53 matching lines @@
   }
 
   void ResetMediaRouteProvider() {
     binding_.reset();
     media_router_->BindToMojoRequest(mojo::GetProxy(&media_router_proxy_),
                                      kExtensionId);
   }
 
   void RegisterMediaRouteProvider() {
     media_router_proxy_->RegisterMediaRouteProvider(
-      media_route_provider_proxy_.Pass(),
-      base::Bind(&RegisterMediaRouteProviderHandler::Invoke,
-                 base::Unretained(&provide_handler_)));
+        std::move(media_route_provider_proxy_),
+        base::Bind(&RegisterMediaRouteProviderHandler::Invoke,
+                   base::Unretained(&provide_handler_)));
   }
 
   void ProcessEventLoop() {
     message_loop_.RunUntilIdle();
   }
 
   void ExpectWakeReasonBucketCount(MediaRouteProviderWakeReason reason,
                                    int expected_count) {
     histogram_tester_.ExpectBucketCount("MediaRouter.Provider.WakeReason",
                                         static_cast<int>(reason),
@@ skipping 141 matching lines @@
   EXPECT_CALL(provide_handler_, Invoke(testing::Not("")));
   EXPECT_CALL(*process_manager_, IsEventPageSuspended(kExtensionId))
       .WillOnce(Return(false));
   EXPECT_CALL(mock_media_route_provider_, DetachRoute(mojo::String(kRouteId2)))
       .Times(kMaxPendingRequests);
   RegisterMediaRouteProvider();
   ProcessEventLoop();
 }
 
 }  // namespace media_router