Replace gmock's deprecated SetArgumentPointee with SetArgPointee.

remoting/protocol/jingle_session_unittest.cc

 // Copyright (c) 2012 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 "remoting/protocol/jingle_session.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 using testing::_;
 using testing::AtLeast;
 using testing::AtMost;
 using testing::DeleteArg;
 using testing::DoAll;
 using testing::InSequence;
 using testing::Invoke;
 using testing::InvokeWithoutArgs;
 using testing::Return;
 using testing::SaveArg;
-using testing::SetArgumentPointee;
+using testing::SetArgPointee;
 using testing::WithArg;
 
 namespace remoting {
 namespace protocol {
 
 namespace {
 
 const char kHostJid[] = "Host@gmail.com/123";
 const char kClientJid[] = "Client@gmail.com/321";
 
@@ skipping 158 matching lines @@
     host_server_.reset();
     client_server_.reset();
     host_signal_strategy_.reset();
     client_signal_strategy_.reset();
   }
 
   void SetHostExpectation(bool expect_fail) {
     EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
         .WillOnce(
             DoAll(WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
-                  SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
+                  SetArgPointee<1>(protocol::SessionManager::ACCEPT)));
 
     {
       InSequence dummy;
 
       EXPECT_CALL(host_session_event_handler_,
                   OnSessionStateChange(Session::ACCEPTED))
           .Times(AtMost(1));
       EXPECT_CALL(host_session_event_handler_,
                   OnSessionStateChange(Session::AUTHENTICATING))
           .Times(AtMost(1));
@@ skipping 113 matching lines @@
   CreateSessionManagers(FakeAuthenticator::Config(FakeAuthenticator::ACCEPT));
 }
 
 // Verify that an incoming session can be rejected, and that the
 // status of the connection is set to FAILED in this case.
 TEST_F(JingleSessionTest, RejectConnection) {
   CreateSessionManagers(FakeAuthenticator::Config(FakeAuthenticator::ACCEPT));
 
   // Reject incoming session.
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
-      .WillOnce(SetArgumentPointee<1>(protocol::SessionManager::DECLINE));
+      .WillOnce(SetArgPointee<1>(protocol::SessionManager::DECLINE));
 
   {
     InSequence dummy;
     EXPECT_CALL(client_session_event_handler_,
                 OnSessionStateChange(Session::FAILED))
         .Times(1);
   }
 
   ConnectClient(FakeAuthenticator::Config(FakeAuthenticator::ACCEPT));
   client_session_->SetEventHandler(&client_session_event_handler_);
@@ skipping 119 matching lines @@
   EXPECT_FALSE(host_session_);
 }
 
 TEST_F(JingleSessionTest, DeleteSessionOnIncomingConnection) {
   const int kAuthRoundtrips = 3;
   FakeAuthenticator::Config auth_config(kAuthRoundtrips,
                                         FakeAuthenticator::ACCEPT, true);
   CreateSessionManagers(auth_config);
 
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
-      .WillOnce(DoAll(
-          WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
-          SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
+      .WillOnce(
+          DoAll(WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
+                SetArgPointee<1>(protocol::SessionManager::ACCEPT)));
 
   EXPECT_CALL(host_session_event_handler_,
       OnSessionStateChange(Session::ACCEPTED))
       .Times(AtMost(1));
 
   EXPECT_CALL(host_session_event_handler_,
               OnSessionStateChange(Session::AUTHENTICATING))
       .WillOnce(InvokeWithoutArgs(this, &JingleSessionTest::DeleteHostSession));
 
   ConnectClient(auth_config);
 }
 
 TEST_F(JingleSessionTest, DeleteSessionOnAuth) {
   // Same as the previous test, but set messages_till_started to 2 in
   // CreateSessionManagers so that the session will goes into the
   // AUTHENTICATING state after two message exchanges.
   const int kMessagesTillStarted = 2;
 
   const int kAuthRoundtrips = 3;
   FakeAuthenticator::Config auth_config(kAuthRoundtrips,
                                         FakeAuthenticator::ACCEPT, true);
   CreateSessionManagers(auth_config, kMessagesTillStarted);
 
   EXPECT_CALL(host_server_listener_, OnIncomingSession(_, _))
       .WillOnce(
           DoAll(WithArg<0>(Invoke(this, &JingleSessionTest::SetHostSession)),
-                SetArgumentPointee<1>(protocol::SessionManager::ACCEPT)));
+                SetArgPointee<1>(protocol::SessionManager::ACCEPT)));
 
   EXPECT_CALL(host_session_event_handler_,
       OnSessionStateChange(Session::ACCEPTED))
       .Times(AtMost(1));
 
   EXPECT_CALL(host_session_event_handler_,
               OnSessionStateChange(Session::AUTHENTICATING))
       .WillOnce(InvokeWithoutArgs(this, &JingleSessionTest::DeleteHostSession));
 
   ConnectClient(auth_config);
@@ skipping 89 matching lines @@
 
   client_session_->Close(HOST_OVERLOAD);
   base::RunLoop().RunUntilIdle();
   // We should only send a SESSION_TERMINATE message if the session has been
   // closed before SESSION_INITIATE message.
   ASSERT_EQ(1U, host_signal_strategy_->received_messages().size());
 }
 
 }  // namespace protocol
 }  // namespace remoting