Use std::move() instead of .Pass() in remoting/*

remoting/signaling/iq_sender_unittest.cc

 // Copyright 2014 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/signaling/iq_sender.h"
+
+#include <utility>
+
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
-#include "remoting/signaling/iq_sender.h"
 #include "remoting/signaling/mock_signal_strategy.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 #include "third_party/webrtc/libjingle/xmpp/constants.h"
 
 using ::testing::_;
 using ::testing::DeleteArg;
 using ::testing::InvokeWithoutArgs;
 using ::testing::NotNull;
@@ skipping 36 matching lines @@
 
  protected:
   void SendTestMessage() {
     scoped_ptr<XmlElement> iq_body(
         new XmlElement(QName(kNamespace, kBodyTag)));
     XmlElement* sent_stanza;
     EXPECT_CALL(signal_strategy_, GetNextId())
         .WillOnce(Return(kStanzaId));
     EXPECT_CALL(signal_strategy_, SendStanzaPtr(_))
         .WillOnce(DoAll(SaveArg<0>(&sent_stanza), Return(true)));
-    request_ = sender_->SendIq(kType, kTo, iq_body.Pass(), base::Bind(
+    request_ = sender_->SendIq(kType, kTo, std::move(iq_body), base::Bind(
         &MockCallback::OnReply, base::Unretained(&callback_)));
 
     std::string expected_xml_string =
         base::StringPrintf(
             "<cli:iq type=\"%s\" to=\"%s\" id=\"%s\" "
             "xmlns:cli=\"jabber:client\">"
             "<%s:%s xmlns:%s=\"%s\"/>"
             "</cli:iq>",
             kType, kTo, kStanzaId, kNamespacePrefix, kBodyTag,
             kNamespacePrefix, kNamespace);
     EXPECT_EQ(expected_xml_string, sent_stanza->Str());
     delete sent_stanza;
   }
 
   bool FormatAndDeliverResponse(const std::string& from,
                                 scoped_ptr<XmlElement>* response_out) {
     scoped_ptr<XmlElement> response(new XmlElement(buzz::QN_IQ));
     response->AddAttr(QName(std::string(), "type"), "result");
     response->AddAttr(QName(std::string(), "id"), kStanzaId);
     response->AddAttr(QName(std::string(), "from"), from);
 
     XmlElement* response_body = new XmlElement(
         QName("test:namespace", "response-body"));
     response->AddElement(response_body);
 
     bool result = sender_->OnSignalStrategyIncomingStanza(response.get());
 
     if (response_out)
-      *response_out = response.Pass();
+      *response_out = std::move(response);
 
     return result;
   }
 
   base::MessageLoop message_loop_;
   MockSignalStrategy signal_strategy_;
   scoped_ptr<IqSender> sender_;
   MockCallback callback_;
   scoped_ptr<IqRequest> request_;
 };
@@ skipping 42 matching lines @@
     SendTestMessage();
   });
 
   EXPECT_FALSE(FormatAndDeliverResponse("different_user@domain.com", nullptr));
 
   EXPECT_CALL(callback_, OnReply(_, _)).Times(0);
   base::RunLoop().RunUntilIdle();
 }
 
 }  // namespace remoting