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

media/test/pipeline_integration_test.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 <stddef.h>
 #include <stdint.h>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 #include "media/base/cdm_callback_promise.h"
@@ skipping 212 matching lines @@
   }
 
   void OnSessionClosed(const std::string& session_id) {
     app_->OnSessionClosed(session_id);
   }
 
   void OnSessionKeysChange(const std::string& session_id,
                            bool has_additional_usable_key,
                            CdmKeysInfo keys_info) {
     app_->OnSessionKeysChange(session_id, has_additional_usable_key,
-                              keys_info.Pass());
+                              std::move(keys_info));
   }
 
   void OnLegacySessionError(const std::string& session_id,
                             const std::string& error_name,
                             uint32_t system_code,
                             const std::string& error_message) {
     app_->OnLegacySessionError(session_id, error_name, system_code,
                                error_message);
   }
 
@@ skipping 43 matching lines @@
                 const std::string& error_message) {
     EXPECT_EQ(expected, REJECTED) << error_message;
   }
 
   scoped_ptr<SimpleCdmPromise> CreatePromise(PromiseResult expected) {
     scoped_ptr<media::SimpleCdmPromise> promise(new media::CdmCallbackPromise<>(
         base::Bind(
             &KeyProvidingApp::OnResolve, base::Unretained(this), expected),
         base::Bind(
             &KeyProvidingApp::OnReject, base::Unretained(this), expected)));
-    return promise.Pass();
+    return promise;
   }
 
   scoped_ptr<NewSessionCdmPromise> CreateSessionPromise(
       PromiseResult expected) {
     scoped_ptr<media::NewSessionCdmPromise> promise(
         new media::CdmCallbackPromise<std::string>(
             base::Bind(&KeyProvidingApp::OnResolveWithSession,
                        base::Unretained(this),
                        expected),
             base::Bind(
                 &KeyProvidingApp::OnReject, base::Unretained(this), expected)));
-    return promise.Pass();
+    return promise;
   }
 
   void OnSessionMessage(const std::string& session_id,
                         MediaKeys::MessageType message_type,
                         const std::vector<uint8_t>& message,
                         const GURL& legacy_destination_url,
                         AesDecryptor* decryptor) override {
     EXPECT_FALSE(session_id.empty());
     EXPECT_FALSE(message.empty());
     EXPECT_EQ(current_session_id_, session_id);
@@ skipping 159 matching lines @@
 
     if (initial_append_size_ == kAppendWholeFile)
       initial_append_size_ = file_data_->data_size();
 
     DCHECK_GT(initial_append_size_, 0);
     DCHECK_LE(initial_append_size_, file_data_->data_size());
   }
 
   virtual ~MockMediaSource() {}
 
-  scoped_ptr<Demuxer> GetDemuxer() { return owned_chunk_demuxer_.Pass(); }
+  scoped_ptr<Demuxer> GetDemuxer() { return std::move(owned_chunk_demuxer_); }
 
   void set_encrypted_media_init_data_cb(
       const Demuxer::EncryptedMediaInitDataCB& encrypted_media_init_data_cb) {
     encrypted_media_init_data_cb_ = encrypted_media_init_data_cb;
   }
 
   void Seek(base::TimeDelta seek_time, int new_position, int seek_append_size) {
     chunk_demuxer_->StartWaitingForSeek(seek_time);
 
     chunk_demuxer_->ResetParserState(
@@ skipping 140 matching lines @@
   }
 
  protected:
   scoped_ptr<Renderer> CreateRenderer() override {
     application_impl()->ConnectToService("mojo:media", &media_service_factory_);
 
     interfaces::RendererPtr mojo_renderer;
     media_service_factory_->CreateRenderer(mojo::GetProxy(&mojo_renderer));
 
     return make_scoped_ptr(new MojoRendererImpl(message_loop_.task_runner(),
-                                                mojo_renderer.Pass()));
+                                                std::move(mojo_renderer)));
   }
 
  private:
   interfaces::ServiceFactoryPtr media_service_factory_;
 };
 #else
 class PipelineIntegrationTestHost : public testing::Test,
                                     public PipelineIntegrationTestBase {};
 #endif
 
 class PipelineIntegrationTest : public PipelineIntegrationTestHost {
  public:
   void StartPipelineWithMediaSource(MockMediaSource* source) {
     EXPECT_CALL(*source, InitSegmentReceived()).Times(AtLeast(1));
     EXPECT_CALL(*this, OnMetadata(_))
         .Times(AtMost(1))
         .WillRepeatedly(SaveArg<0>(&metadata_));
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_ENOUGH))
         .Times(AnyNumber());
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_NOTHING))
         .Times(AnyNumber());
 
     // Encrypted content not used, so this is never called.
     EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
 
-    demuxer_ = source->GetDemuxer().Pass();
+    demuxer_ = source->GetDemuxer();
     pipeline_->Start(
         demuxer_.get(), CreateRenderer(),
         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnStatusCallback,
                    base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnMetadata,
                    base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnBufferingStateChanged,
                    base::Unretained(this)),
@@ skipping 26 matching lines @@
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_ENOUGH))
         .Times(AnyNumber());
     EXPECT_CALL(*this, OnBufferingStateChanged(BUFFERING_HAVE_NOTHING))
         .Times(AnyNumber());
     EXPECT_CALL(*this, DecryptorAttached(true));
 
     // Encrypted content used but keys provided in advance, so this is
     // never called.
     EXPECT_CALL(*this, OnWaitingForDecryptionKey()).Times(0);
 
-    demuxer_ = source->GetDemuxer().Pass();
+    demuxer_ = source->GetDemuxer();
 
     pipeline_->SetCdm(encrypted_media->GetCdmContext(),
                       base::Bind(&PipelineIntegrationTest::DecryptorAttached,
                                  base::Unretained(this)));
 
     pipeline_->Start(
         demuxer_.get(), CreateRenderer(),
         base::Bind(&PipelineIntegrationTest::OnEnded, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnError, base::Unretained(this)),
         base::Bind(&PipelineIntegrationTest::OnStatusCallback,
@@ skipping 1195 matching lines @@
 
 TEST_F(PipelineIntegrationTest, BasicPlaybackPositiveStartTime) {
   ASSERT_EQ(PIPELINE_OK, Start("nonzero-start-time.webm"));
   Play();
   ASSERT_TRUE(WaitUntilOnEnded());
   ASSERT_EQ(base::TimeDelta::FromMicroseconds(396000),
             demuxer_->GetStartTime());
 }
 
 }  // namespace media