Convert Pass()→std::move() in //media (Android Cast edition)

media/base/android/media_codec_player.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 "media/base/android/media_codec_player.h"
 
+#include <utility>
+
 #include "base/barrier_closure.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "media/base/android/media_codec_audio_decoder.h"
 #include "media/base/android/media_codec_video_decoder.h"
 #include "media/base/android/media_drm_bridge.h"
@@ skipping 21 matching lines @@
     int player_id,
     base::WeakPtr<MediaPlayerManager> manager,
     const OnDecoderResourcesReleasedCB& on_decoder_resources_released_cb,
     scoped_ptr<DemuxerAndroid> demuxer,
     const GURL& frame_url)
     : MediaPlayerAndroid(player_id,
                          manager.get(),
                          on_decoder_resources_released_cb,
                          frame_url),
       ui_task_runner_(base::ThreadTaskRunnerHandle::Get()),
-      demuxer_(demuxer.Pass()),
+      demuxer_(std::move(demuxer)),
       state_(kStatePaused),
       interpolator_(&default_tick_clock_),
       pending_start_(false),
       pending_seek_(kNoTimestamp()),
       cdm_registration_id_(0),
       key_is_required_(false),
       key_is_added_(false),
       media_weak_factory_(this) {
   DCHECK(ui_task_runner_->BelongsToCurrentThread());
 
@@ skipping 93 matching lines @@
   }
 
   // Do not set unprotected surface if we know that we need a protected one.
   // Empty surface means the surface removal and we always allow for it.
   if (!surface_is_empty && video_decoder_->IsProtectedSurfaceRequired() &&
       !surface.is_protected()) {
     DVLOG(0) << __FUNCTION__ << ": surface is not protected, ignoring";
     return;
   }
 
-  video_decoder_->SetVideoSurface(surface.Pass());
+  video_decoder_->SetVideoSurface(std::move(surface));
 
   if (surface_is_empty) {
     // Remove video surface.
     switch (state_) {
       case kStatePlaying:
         if (VideoFinished())
           break;
 
         DVLOG(1) << __FUNCTION__ << ": stopping and restarting";
         // Stop decoders as quickly as possible.
@@ skipping 777 matching lines @@
 
   if (media_crypto->is_null()) {
     // TODO(timav): Fail playback nicely here if needed. Note that we could get
     // here even though the stream to play is unencrypted and therefore
     // MediaCrypto is not needed. In that case, we may ignore this error and
     // continue playback, or fail the playback.
     LOG(ERROR) << "MediaCrypto creation failed.";
     return;
   }
 
-  media_crypto_ = media_crypto.Pass();
+  media_crypto_ = std::move(media_crypto);
 
   if (audio_decoder_) {
     audio_decoder_->SetNeedsReconfigure();
   }
 
   if (video_decoder_) {
     video_decoder_->SetNeedsReconfigure();
     video_decoder_->SetProtectedSurfaceRequired(needs_protected_surface);
   }
 
@@ skipping 442 matching lines @@
     RETURN_STRING(kStateWaitingForMediaCrypto);
     RETURN_STRING(kStateWaitingForSeek);
     RETURN_STRING(kStateError);
   }
   return nullptr;  // crash early
 }
 
 #undef RETURN_STRING
 
 }  // namespace media