diff --git a/starboard/common/scoped_ptr.h b/starboard/common/scoped_ptr.h
index 35e29088b869..7d85d6fc51e4 100644
--- a/starboard/common/scoped_ptr.h
+++ b/starboard/common/scoped_ptr.h
@@ -93,6 +93,7 @@
 // scoped_array, scoped_ptr_malloc.
 
 #include <algorithm>
+#include <memory>
 #include <utility>
 
 #include "starboard/common/log.h"
@@ -134,6 +135,8 @@ class scoped_ptr {
       : ptr_(other.release()) {}
 #endif
 
+  scoped_ptr(scoped_ptr&& other) : ptr_(other.release()) {}
+
   // Constructor.  Move constructor for C++03 move emulation of this type.
   scoped_ptr(RValue rvalue)  // NOLINT(runtime/explicit)
       : ptr_(rvalue.object->release()) {}
@@ -497,6 +500,14 @@ scoped_ptr<T> make_scoped_ptr(T* ptr) {
   return scoped_ptr<T>(ptr);
 }
 
+#ifdef DEPRECATED_SCOPED_PTR
+template <class C>
+using unique_ptr_alias = std::unique_ptr<C>;
+#else
+template <class C>
+using unique_ptr_alias = scoped_ptr<C>;
+#endif
+
 }  // namespace starboard
 
 #endif  // STARBOARD_COMMON_SCOPED_PTR_H_
diff --git a/starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.h b/starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.h
index 60a301bdcc94..5ee80a7b7b6b 100644
--- a/starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.h
+++ b/starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.h
@@ -36,7 +36,7 @@ namespace filter {
 
 class AdaptiveAudioDecoder : public AudioDecoder, private JobQueue::JobOwner {
  public:
-  typedef std::function<scoped_ptr<filter::AudioDecoder>(
+  typedef std::function<unique_ptr_alias<filter::AudioDecoder>(
       const media::AudioStreamInfo& audio_stream_info,
       SbDrmSystem drm_system)>
       AudioDecoderCreator;
@@ -80,9 +80,9 @@ class AdaptiveAudioDecoder : public AudioDecoder, private JobQueue::JobOwner {
   OutputCB output_cb_ = nullptr;
   ErrorCB error_cb_ = nullptr;
 
-  scoped_ptr<filter::AudioDecoder> audio_decoder_;
-  scoped_ptr<filter::AudioResampler> resampler_;
-  scoped_ptr<filter::AudioChannelLayoutMixer> channel_mixer_;
+  unique_ptr_alias<filter::AudioDecoder> audio_decoder_;
+  std::unique_ptr<filter::AudioResampler> resampler_;
+  std::unique_ptr<filter::AudioChannelLayoutMixer> channel_mixer_;
   InputBuffers pending_input_buffers_;
   ConsumedCB pending_consumed_cb_;
   std::queue<scoped_refptr<DecodedAudio>> decoded_audios_;
diff --git a/starboard/shared/starboard/player/filter/audio_channel_layout_mixer.h b/starboard/shared/starboard/player/filter/audio_channel_layout_mixer.h
index 31da031d97f6..bd75d64fb5f4 100644
--- a/starboard/shared/starboard/player/filter/audio_channel_layout_mixer.h
+++ b/starboard/shared/starboard/player/filter/audio_channel_layout_mixer.h
@@ -15,6 +15,7 @@
 #ifndef STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_CHANNEL_LAYOUT_MIXER_H_
 #define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_CHANNEL_LAYOUT_MIXER_H_
 
+#include <memory>
 #include <vector>
 
 #include "starboard/common/ref_counted.h"
@@ -38,7 +39,7 @@ class AudioChannelLayoutMixer {
   virtual scoped_refptr<DecodedAudio> Mix(
       const scoped_refptr<DecodedAudio>& audio_data) = 0;
 
-  static scoped_ptr<AudioChannelLayoutMixer> Create(
+  static std::unique_ptr<AudioChannelLayoutMixer> Create(
       SbMediaAudioSampleType sample_type,
       SbMediaAudioFrameStorageType storage_type,
       int output_channels);
diff --git a/starboard/shared/starboard/player/filter/audio_channel_layout_mixer_impl.cc b/starboard/shared/starboard/player/filter/audio_channel_layout_mixer_impl.cc
index f37772035057..0f09fa0da62e 100644
--- a/starboard/shared/starboard/player/filter/audio_channel_layout_mixer_impl.cc
+++ b/starboard/shared/starboard/player/filter/audio_channel_layout_mixer_impl.cc
@@ -388,12 +388,13 @@ AudioChannelLayoutMixerImpl::MixMonoToStereoOptimized(
 }  // namespace
 
 // static
-scoped_ptr<AudioChannelLayoutMixer> AudioChannelLayoutMixer::Create(
+std::unique_ptr<AudioChannelLayoutMixer> AudioChannelLayoutMixer::Create(
     SbMediaAudioSampleType sample_type,
     SbMediaAudioFrameStorageType storage_type,
     int output_channels) {
-  return scoped_ptr<AudioChannelLayoutMixer>(new AudioChannelLayoutMixerImpl(
-      sample_type, storage_type, output_channels));
+  return std::unique_ptr<AudioChannelLayoutMixer>(
+      new AudioChannelLayoutMixerImpl(sample_type, storage_type,
+                                      output_channels));
 }
 
 }  // namespace filter
diff --git a/starboard/shared/starboard/player/filter/audio_frame_tracker.cc b/starboard/shared/starboard/player/filter/audio_frame_tracker.cc
index badce2651d66..da2f58643402 100644
--- a/starboard/shared/starboard/player/filter/audio_frame_tracker.cc
+++ b/starboard/shared/starboard/player/filter/audio_frame_tracker.cc
@@ -18,7 +18,6 @@
 
 #include "starboard/common/log.h"
 #include "starboard/common/mutex.h"
-#include "starboard/common/scoped_ptr.h"
 #include "starboard/media.h"
 #include "starboard/shared/starboard/thread_checker.h"
 
diff --git a/starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.cc b/starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.cc
index 676aad853e97..4b99d91765e7 100644
--- a/starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.cc
+++ b/starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.cc
@@ -16,6 +16,7 @@
 
 #include <algorithm>
 #include <string>
+#include <utility>
 
 #include "starboard/common/time.h"
 #include "starboard/memory.h"
@@ -67,8 +68,8 @@ SbMediaAudioSampleType GetSinkAudioSampleType(
 }  // namespace
 
 AudioRendererPcm::AudioRendererPcm(
-    scoped_ptr<AudioDecoder> decoder,
-    scoped_ptr<AudioRendererSink> audio_renderer_sink,
+    unique_ptr_alias<AudioDecoder> decoder,
+    unique_ptr_alias<AudioRendererSink> audio_renderer_sink,
     const media::AudioStreamInfo& audio_stream_info,
     int max_cached_frames,
     int min_frames_per_append)
@@ -79,10 +80,10 @@ AudioRendererPcm::AudioRendererPcm(
       bytes_per_frame_(media::GetBytesPerSample(sink_sample_type_) * channels_),
       frame_buffer_(max_cached_frames_ * bytes_per_frame_),
       frames_consumed_set_at_(CurrentMonotonicTime()),
-      decoder_(decoder.Pass()),
+      decoder_(std::move(decoder)),
       process_audio_data_job_(
           std::bind(&AudioRendererPcm::ProcessAudioData, this)),
-      audio_renderer_sink_(audio_renderer_sink.Pass()) {
+      audio_renderer_sink_(std::move(audio_renderer_sink)) {
   SB_DLOG(INFO) << "Creating AudioRendererPcm with " << channels_
                 << " channels, " << bytes_per_frame_ << " bytes per frame, "
                 << max_cached_frames_ << " max cached frames, and "
diff --git a/starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.h b/starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.h
index 2af3cc1787f4..6d881264de0a 100644
--- a/starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.h
+++ b/starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.h
@@ -16,6 +16,7 @@
 #define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_RENDERER_INTERNAL_PCM_H_
 
 #include <functional>
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -66,8 +67,8 @@ class AudioRendererPcm : public AudioRenderer,
   //    longer accept more data.
   // |min_frames_per_append| is the min number of frames that the audio renderer
   // tries to append to the sink buffer at once.
-  AudioRendererPcm(scoped_ptr<AudioDecoder> decoder,
-                   scoped_ptr<AudioRendererSink> audio_renderer_sink,
+  AudioRendererPcm(unique_ptr_alias<AudioDecoder> decoder,
+                   unique_ptr_alias<AudioRendererSink> audio_renderer_sink,
                    const media::AudioStreamInfo& audio_stream_info,
                    int max_cached_frames,
                    int min_frames_per_append);
@@ -128,7 +129,7 @@ class AudioRendererPcm : public AudioRenderer,
   int64_t total_frames_consumed_by_sink_ = 0;
   int32_t frames_consumed_by_sink_since_last_get_current_time_;
 
-  scoped_ptr<AudioDecoder> decoder_;
+  unique_ptr_alias<AudioDecoder> decoder_;
 
   int64_t frames_consumed_set_at_;
   double playback_rate_ = 1.0;
@@ -161,7 +162,7 @@ class AudioRendererPcm : public AudioRenderer,
   const SbMediaAudioSampleType sink_sample_type_;
   const int bytes_per_frame_;
 
-  scoped_ptr<AudioResampler> resampler_;
+  std::unique_ptr<AudioResampler> resampler_;
   optional<int> decoder_sample_rate_;
   AudioTimeStretcher time_stretcher_;
 
@@ -181,7 +182,7 @@ class AudioRendererPcm : public AudioRenderer,
   // and can thus avoid doing a full reset.
   bool first_input_written_ = false;
 
-  scoped_ptr<AudioRendererSink> audio_renderer_sink_;
+  unique_ptr_alias<AudioRendererSink> audio_renderer_sink_;
   bool is_eos_reached_on_sink_thread_ = false;
   bool is_playing_on_sink_thread_ = false;
   int64_t frames_in_buffer_on_sink_thread_ = 0;
diff --git a/starboard/shared/starboard/player/filter/audio_resampler.h b/starboard/shared/starboard/player/filter/audio_resampler.h
index 3aeaa4f7657f..3dded5a9791a 100644
--- a/starboard/shared/starboard/player/filter/audio_resampler.h
+++ b/starboard/shared/starboard/player/filter/audio_resampler.h
@@ -15,6 +15,8 @@
 #ifndef STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_RESAMPLER_H_
 #define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_RESAMPLER_H_
 
+#include <memory>
+
 #include "starboard/common/ref_counted.h"
 #include "starboard/common/scoped_ptr.h"
 #include "starboard/media.h"
@@ -57,7 +59,7 @@ class AudioResampler {
   // The |output_cb| will be called whenever there is resampled data ready.  It
   // is always called asynchronously on |job_queue| and then the user of
   // AudioResampler can call Read() to read the next chunk of resampled data.
-  static scoped_ptr<AudioResampler> Create(
+  static std::unique_ptr<AudioResampler> Create(
       SbMediaAudioSampleType source_sample_type,
       SbMediaAudioFrameStorageType source_storage_type,
       int source_sample_rate,
diff --git a/starboard/shared/starboard/player/filter/audio_resampler_impl.cc b/starboard/shared/starboard/player/filter/audio_resampler_impl.cc
index b0fa87466bd6..5592b78629e8 100644
--- a/starboard/shared/starboard/player/filter/audio_resampler_impl.cc
+++ b/starboard/shared/starboard/player/filter/audio_resampler_impl.cc
@@ -71,7 +71,7 @@ class AudioResamplerImpl : public AudioResampler {
 }  // namespace
 
 // static
-scoped_ptr<AudioResampler> AudioResampler::Create(
+std::unique_ptr<AudioResampler> AudioResampler::Create(
     SbMediaAudioSampleType source_sample_type,
     SbMediaAudioFrameStorageType source_storage_type,
     int source_sample_rate,
@@ -79,7 +79,7 @@ scoped_ptr<AudioResampler> AudioResampler::Create(
     SbMediaAudioFrameStorageType destination_storage_type,
     int destination_sample_rate,
     int channels) {
-  return scoped_ptr<AudioResampler>(new AudioResamplerImpl(
+  return std::unique_ptr<AudioResampler>(new AudioResamplerImpl(
       source_sample_type, source_storage_type, source_sample_rate,
       destination_sample_type, destination_storage_type,
       destination_sample_rate, channels));
diff --git a/starboard/shared/starboard/player/filter/audio_time_stretcher.h b/starboard/shared/starboard/player/filter/audio_time_stretcher.h
index 67472062f470..29e79220f107 100644
--- a/starboard/shared/starboard/player/filter/audio_time_stretcher.h
+++ b/starboard/shared/starboard/player/filter/audio_time_stretcher.h
@@ -35,6 +35,8 @@
 #ifndef STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_TIME_STRETCHER_H_
 #define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_TIME_STRETCHER_H_
 
+#include <memory>
+
 #include "starboard/common/ref_counted.h"
 #include "starboard/common/scoped_ptr.h"
 #include "starboard/shared/internal_only.h"
@@ -193,11 +195,11 @@ class AudioTimeStretcher {
   scoped_refptr<DecodedAudio> wsola_output_;
 
   // Overlap-and-add window.
-  scoped_array<float> ola_window_;
+  std::unique_ptr<float[]> ola_window_;
 
   // Transition window, used to update |optimal_block_| by a weighted sum of
   // |optimal_block_| and |target_block_|.
-  scoped_array<float> transition_window_;
+  std::unique_ptr<float[]> transition_window_;
 
   // Auxiliary variables to avoid allocation in every iteration.
 
diff --git a/starboard/shared/starboard/player/filter/cpu_video_frame.h b/starboard/shared/starboard/player/filter/cpu_video_frame.h
index 7da0ee1a7ded..b31f9068d03a 100644
--- a/starboard/shared/starboard/player/filter/cpu_video_frame.h
+++ b/starboard/shared/starboard/player/filter/cpu_video_frame.h
@@ -15,6 +15,7 @@
 #ifndef STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_CPU_VIDEO_FRAME_H_
 #define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_CPU_VIDEO_FRAME_H_
 
+#include <memory>
 #include <vector>
 
 #include "starboard/common/ref_counted.h"
@@ -84,7 +85,7 @@ class CpuVideoFrame : public VideoFrame {
 
   // The following two variables are valid when the frame contains pixel data.
   std::vector<Plane> planes_;
-  scoped_array<uint8_t> pixel_buffer_;
+  std::unique_ptr<uint8_t[]> pixel_buffer_;
 };
 
 }  // namespace filter
diff --git a/starboard/shared/starboard/player/filter/filter_based_player_worker_handler.cc b/starboard/shared/starboard/player/filter/filter_based_player_worker_handler.cc
index 7273598cb5b1..8de626124c6a 100644
--- a/starboard/shared/starboard/player/filter/filter_based_player_worker_handler.cc
+++ b/starboard/shared/starboard/player/filter/filter_based_player_worker_handler.cc
@@ -115,7 +115,7 @@ HandlerResult FilterBasedPlayerWorkerHandler::Init(
   update_player_state_cb_ = update_player_state_cb;
   update_player_error_cb_ = update_player_error_cb;
 
-  scoped_ptr<PlayerComponents::Factory> factory =
+  unique_ptr_alias<PlayerComponents::Factory> factory =
       PlayerComponents::Factory::Create();
   SB_DCHECK(factory);
 
@@ -401,8 +401,7 @@ HandlerResult FilterBasedPlayerWorkerHandler::SetBounds(const Bounds& bounds) {
     bounds_.z_index = bounds.z_index;
     bool bounds_changed = memcmp(&bounds_, &bounds, sizeof(bounds_)) != 0;
     SB_LOG_IF(INFO, bounds_changed)
-        << "Set bounds to "
-        << "x: " << bounds.x << ", y: " << bounds.y
+        << "Set bounds to " << "x: " << bounds.x << ", y: " << bounds.y
         << ", width: " << bounds.width << ", height: " << bounds.height
         << ", z_index: " << bounds.z_index;
 
@@ -518,14 +517,14 @@ void FilterBasedPlayerWorkerHandler::Stop() {
 
   RemoveJobByToken(update_job_token_);
 
-  scoped_ptr<PlayerComponents> player_components;
+  unique_ptr_alias<PlayerComponents> player_components;
   {
     // Set |player_components_| to null with the lock, but we actually destroy
     // it outside of the lock.  This is because the VideoRenderer destructor
     // may post a task to destroy the SbDecodeTarget to the same thread that
     // might call GetCurrentDecodeTarget(), which would try to take this lock.
     ::starboard::ScopedLock lock(player_components_existence_mutex_);
-    player_components = player_components_.Pass();
+    player_components = std::move(player_components_);
     media_time_provider_ = nullptr;
     audio_renderer_ = nullptr;
     video_renderer_ = nullptr;
diff --git a/starboard/shared/starboard/player/filter/filter_based_player_worker_handler.h b/starboard/shared/starboard/player/filter/filter_based_player_worker_handler.h
index 4b9df34a5c86..2021d7deee54 100644
--- a/starboard/shared/starboard/player/filter/filter_based_player_worker_handler.h
+++ b/starboard/shared/starboard/player/filter/filter_based_player_worker_handler.h
@@ -16,6 +16,7 @@
 #define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_FILTER_BASED_PLAYER_WORKER_HANDLER_H_
 
 #include <functional>
+#include <memory>
 #include <string>
 
 #include "starboard/common/scoped_ptr.h"
@@ -91,7 +92,7 @@ class FilterBasedPlayerWorkerHandler : public PlayerWorker::Handler,
   // other accesses are happening from the same thread.
   Mutex player_components_existence_mutex_;
 
-  scoped_ptr<PlayerComponents> player_components_;
+  unique_ptr_alias<PlayerComponents> player_components_;
   // The following three variables cache the return values of member functions
   // of |player_components_|.  Their lifetime is tied to |player_components_|.
   MediaTimeProvider* media_time_provider_ = nullptr;
diff --git a/starboard/shared/starboard/player/filter/interleaved_sinc_resampler.h b/starboard/shared/starboard/player/filter/interleaved_sinc_resampler.h
index c5cc5bf18d03..9382edf1a0e7 100644
--- a/starboard/shared/starboard/player/filter/interleaved_sinc_resampler.h
+++ b/starboard/shared/starboard/player/filter/interleaved_sinc_resampler.h
@@ -22,7 +22,9 @@
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
+#include <memory>
 #include <queue>
+#include <utility>
 
 #include "starboard/common/ref_counted.h"
 #include "starboard/common/scoped_ptr.h"
@@ -73,8 +75,8 @@ class InterleavedSincResampler {
       data_.reset(new float[frames * channel_count]);
       memcpy(data_.get(), data, frames * channel_count * sizeof(float));
     }
-    Buffer(scoped_array<float> data, int frames)
-        : data_(data.Pass()), frames_(frames) {}
+    Buffer(std::unique_ptr<float[]> data, int frames)
+        : data_(std::move(data)), frames_(frames) {}
 
     const float* GetData() const { return data_.get(); }
 
@@ -84,7 +86,7 @@ class InterleavedSincResampler {
 
    private:
     friend class ::starboard::RefCountedThreadSafe<Buffer>;
-    scoped_array<float> data_;
+    std::unique_ptr<float[]> data_;
     int frames_ = 0;
 
     Buffer(const Buffer&) = delete;
diff --git a/starboard/shared/starboard/player/filter/media_time_provider_impl.cc b/starboard/shared/starboard/player/filter/media_time_provider_impl.cc
index f9df61a8bf88..fc935d909b7f 100644
--- a/starboard/shared/starboard/player/filter/media_time_provider_impl.cc
+++ b/starboard/shared/starboard/player/filter/media_time_provider_impl.cc
@@ -14,6 +14,8 @@
 
 #include "starboard/shared/starboard/player/filter/media_time_provider_impl.h"
 
+#include <utility>
+
 #include "starboard/common/log.h"
 
 namespace starboard {
@@ -23,8 +25,8 @@ namespace player {
 namespace filter {
 
 MediaTimeProviderImpl::MediaTimeProviderImpl(
-    scoped_ptr<MonotonicSystemTimeProvider> system_time_provider)
-    : system_time_provider_(system_time_provider.Pass()) {
+    std::unique_ptr<MonotonicSystemTimeProvider> system_time_provider)
+    : system_time_provider_(std::move(system_time_provider)) {
   SB_DCHECK(system_time_provider_);
 }
 
diff --git a/starboard/shared/starboard/player/filter/media_time_provider_impl.h b/starboard/shared/starboard/player/filter/media_time_provider_impl.h
index f783a573b2cc..c800c7edf5c6 100644
--- a/starboard/shared/starboard/player/filter/media_time_provider_impl.h
+++ b/starboard/shared/starboard/player/filter/media_time_provider_impl.h
@@ -15,6 +15,8 @@
 #ifndef STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_MEDIA_TIME_PROVIDER_IMPL_H_
 #define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_MEDIA_TIME_PROVIDER_IMPL_H_
 
+#include <memory>
+
 #include "starboard/common/mutex.h"
 #include "starboard/common/scoped_ptr.h"
 #include "starboard/common/time.h"
@@ -40,7 +42,7 @@ class MediaTimeProviderImpl : public MediaTimeProvider,
   };
 
   explicit MediaTimeProviderImpl(
-      scoped_ptr<MonotonicSystemTimeProvider> system_time_provider);
+      std::unique_ptr<MonotonicSystemTimeProvider> system_time_provider);
 
   void Play() override;
   void Pause() override;
@@ -58,7 +60,7 @@ class MediaTimeProviderImpl : public MediaTimeProvider,
   // should handle this properly.
   int64_t GetCurrentMediaTime_Locked(int64_t* current_time = NULL);
 
-  scoped_ptr<MonotonicSystemTimeProvider> system_time_provider_;
+  std::unique_ptr<MonotonicSystemTimeProvider> system_time_provider_;
 
   Mutex mutex_;
 
diff --git a/starboard/shared/starboard/player/filter/player_components.cc b/starboard/shared/starboard/player/filter/player_components.cc
index 3a2fdd8903f9..6c6eed22dd77 100644
--- a/starboard/shared/starboard/player/filter/player_components.cc
+++ b/starboard/shared/starboard/player/filter/player_components.cc
@@ -14,7 +14,8 @@
 
 #include "starboard/shared/starboard/player/filter/player_components.h"
 
-#include "starboard/common/scoped_ptr.h"
+#include <utility>
+
 #include "starboard/common/time.h"
 #include "starboard/shared/starboard/application.h"
 #include "starboard/shared/starboard/command_line.h"
@@ -50,12 +51,13 @@ class MonotonicSystemTimeProviderImpl : public MonotonicSystemTimeProvider {
 
 class PlayerComponentsImpl : public PlayerComponents {
  public:
-  PlayerComponentsImpl(scoped_ptr<MediaTimeProviderImpl> media_time_provider,
-                       scoped_ptr<AudioRendererPcm> audio_renderer,
-                       scoped_ptr<VideoRendererImpl> video_renderer)
-      : media_time_provider_(media_time_provider.Pass()),
-        audio_renderer_(audio_renderer.Pass()),
-        video_renderer_(video_renderer.Pass()) {
+  PlayerComponentsImpl(
+      std::unique_ptr<MediaTimeProviderImpl> media_time_provider,
+      unique_ptr_alias<AudioRendererPcm> audio_renderer,
+      unique_ptr_alias<VideoRendererImpl> video_renderer)
+      : media_time_provider_(std::move(media_time_provider)),
+        audio_renderer_(std::move(audio_renderer)),
+        video_renderer_(std::move(video_renderer)) {
     SB_DCHECK(media_time_provider_ || audio_renderer_);
     SB_DCHECK(audio_renderer_ || video_renderer_);
   }
@@ -70,9 +72,9 @@ class PlayerComponentsImpl : public PlayerComponents {
 
  private:
   // |media_time_provider_| will only be used when |audio_renderer_| is nullptr.
-  scoped_ptr<MediaTimeProviderImpl> media_time_provider_;
-  scoped_ptr<AudioRendererPcm> audio_renderer_;
-  scoped_ptr<VideoRendererImpl> video_renderer_;
+  std::unique_ptr<MediaTimeProviderImpl> media_time_provider_;
+  unique_ptr_alias<AudioRendererPcm> audio_renderer_;
+  unique_ptr_alias<VideoRendererImpl> video_renderer_;
 };
 
 int AlignUp(int value, int alignment) {
@@ -141,17 +143,17 @@ PlayerComponents::Factory::CreationParameters::CreationParameters(
   this->drm_system_ = that.drm_system_;
 }
 
-scoped_ptr<PlayerComponents> PlayerComponents::Factory::CreateComponents(
+unique_ptr_alias<PlayerComponents> PlayerComponents::Factory::CreateComponents(
     const CreationParameters& creation_parameters,
     std::string* error_message) {
   SB_DCHECK(creation_parameters.audio_codec() != kSbMediaAudioCodecNone ||
             creation_parameters.video_codec() != kSbMediaVideoCodecNone);
   SB_DCHECK(error_message);
 
-  scoped_ptr<AudioDecoder> audio_decoder;
-  scoped_ptr<AudioRendererSink> audio_renderer_sink;
-  scoped_ptr<VideoDecoder> video_decoder;
-  scoped_ptr<VideoRenderAlgorithm> video_render_algorithm;
+  unique_ptr_alias<AudioDecoder> audio_decoder;
+  unique_ptr_alias<AudioRendererSink> audio_renderer_sink;
+  unique_ptr_alias<VideoDecoder> video_decoder;
+  unique_ptr_alias<VideoRenderAlgorithm> video_render_algorithm;
   scoped_refptr<VideoRendererSink> video_renderer_sink;
 
   auto command_line = shared::starboard::Application::Get()->GetCommandLine();
@@ -176,7 +178,7 @@ scoped_ptr<PlayerComponents> PlayerComponents::Factory::CreateComponents(
                              &audio_renderer_sink, &video_decoder,
                              &video_render_algorithm, &video_renderer_sink,
                              error_message)) {
-      return scoped_ptr<PlayerComponents>();
+      return unique_ptr_alias<PlayerComponents>();
     }
     if (use_stub_audio_decoder) {
       SB_DCHECK(!audio_decoder);
@@ -192,9 +194,9 @@ scoped_ptr<PlayerComponents> PlayerComponents::Factory::CreateComponents(
     }
   }
 
-  scoped_ptr<MediaTimeProviderImpl> media_time_provider_impl;
-  scoped_ptr<AudioRendererPcm> audio_renderer;
-  scoped_ptr<VideoRendererImpl> video_renderer;
+  std::unique_ptr<MediaTimeProviderImpl> media_time_provider_impl;
+  unique_ptr_alias<AudioRendererPcm> audio_renderer;
+  unique_ptr_alias<VideoRendererImpl> video_renderer;
 
   if (creation_parameters.audio_codec() != kSbMediaAudioCodecNone) {
     SB_DCHECK(audio_decoder);
@@ -204,10 +206,10 @@ scoped_ptr<PlayerComponents> PlayerComponents::Factory::CreateComponents(
     GetAudioRendererParams(creation_parameters, &max_cached_frames,
                            &min_frames_per_append);
 
-    audio_renderer.reset(
-        new AudioRendererPcm(audio_decoder.Pass(), audio_renderer_sink.Pass(),
-                             creation_parameters.audio_stream_info(),
-                             max_cached_frames, min_frames_per_append));
+    audio_renderer.reset(new AudioRendererPcm(
+        std::move(audio_decoder), std::move(audio_renderer_sink),
+        creation_parameters.audio_stream_info(), max_cached_frames,
+        min_frames_per_append));
   }
 
   if (creation_parameters.video_codec() != kSbMediaVideoCodecNone) {
@@ -218,32 +220,33 @@ scoped_ptr<PlayerComponents> PlayerComponents::Factory::CreateComponents(
     if (audio_renderer) {
       media_time_provider = audio_renderer.get();
     } else {
-      media_time_provider_impl.reset(
-          new MediaTimeProviderImpl(scoped_ptr<MonotonicSystemTimeProvider>(
+      media_time_provider_impl.reset(new MediaTimeProviderImpl(
+          std::unique_ptr<MonotonicSystemTimeProvider>(
               new MonotonicSystemTimeProviderImpl)));
       media_time_provider = media_time_provider_impl.get();
     }
     video_renderer.reset(new VideoRendererImpl(
-        video_decoder.Pass(), media_time_provider,
-        video_render_algorithm.Pass(), video_renderer_sink));
+        std::move(video_decoder), media_time_provider,
+        std::move(video_render_algorithm), video_renderer_sink));
   }
 
   SB_DCHECK(audio_renderer || video_renderer);
-  return scoped_ptr<PlayerComponents>(
-      new PlayerComponentsImpl(media_time_provider_impl.Pass(),
-                               audio_renderer.Pass(), video_renderer.Pass()));
+  return unique_ptr_alias<PlayerComponents>(new PlayerComponentsImpl(
+      std::move(media_time_provider_impl), std::move(audio_renderer),
+      std::move(video_renderer)));
 }
 
 void PlayerComponents::Factory::CreateStubAudioComponents(
     const CreationParameters& creation_parameters,
-    scoped_ptr<AudioDecoder>* audio_decoder,
-    scoped_ptr<AudioRendererSink>* audio_renderer_sink) {
+    unique_ptr_alias<AudioDecoder>* audio_decoder,
+    unique_ptr_alias<AudioRendererSink>* audio_renderer_sink) {
   SB_DCHECK(audio_decoder);
   SB_DCHECK(audio_renderer_sink);
 
   auto decoder_creator = [](const media::AudioStreamInfo& audio_stream_info,
                             SbDrmSystem drm_system) {
-    return scoped_ptr<AudioDecoder>(new StubAudioDecoder(audio_stream_info));
+    return unique_ptr_alias<AudioDecoder>(
+        new StubAudioDecoder(audio_stream_info));
   };
   audio_decoder->reset(new AdaptiveAudioDecoder(
       creation_parameters.audio_stream_info(), creation_parameters.drm_system(),
@@ -253,8 +256,8 @@ void PlayerComponents::Factory::CreateStubAudioComponents(
 
 void PlayerComponents::Factory::CreateStubVideoComponents(
     const CreationParameters& creation_parameters,
-    scoped_ptr<VideoDecoder>* video_decoder,
-    scoped_ptr<VideoRenderAlgorithm>* video_render_algorithm,
+    unique_ptr_alias<VideoDecoder>* video_decoder,
+    unique_ptr_alias<VideoRenderAlgorithm>* video_render_algorithm,
     scoped_refptr<VideoRendererSink>* video_renderer_sink) {
   const int64_t kVideoSinkRenderIntervalUsec = 10'000;  // 10ms
 
diff --git a/starboard/shared/starboard/player/filter/player_components.h b/starboard/shared/starboard/player/filter/player_components.h
index 4990ec47bd03..1c3e9133f872 100644
--- a/starboard/shared/starboard/player/filter/player_components.h
+++ b/starboard/shared/starboard/player/filter/player_components.h
@@ -15,6 +15,7 @@
 #ifndef STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_PLAYER_COMPONENTS_H_
 #define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_PLAYER_COMPONENTS_H_
 
+#include <memory>
 #include <string>
 #include <vector>
 
@@ -154,7 +155,7 @@ class PlayerComponents {
     // TODO: Consider making it return Factory*.
     // Individual platform should implement this function to allow the creation
     // of a Factory instance.
-    static scoped_ptr<Factory> Create();
+    static unique_ptr_alias<Factory> Create();
 
     // Individual implementations must implement this function to indicate which
     // output modes they support.
@@ -162,7 +163,7 @@ class PlayerComponents {
                                     SbMediaVideoCodec codec,
                                     SbDrmSystem drm_system);
 
-    virtual scoped_ptr<PlayerComponents> CreateComponents(
+    virtual unique_ptr_alias<PlayerComponents> CreateComponents(
         const CreationParameters& creation_parameters,
         std::string* error_message);
 
@@ -174,10 +175,10 @@ class PlayerComponents {
     // unit tests to run.
     virtual bool CreateSubComponents(
         const CreationParameters& creation_parameters,
-        scoped_ptr<AudioDecoder>* audio_decoder,
-        scoped_ptr<AudioRendererSink>* audio_renderer_sink,
-        scoped_ptr<VideoDecoder>* video_decoder,
-        scoped_ptr<VideoRenderAlgorithm>* video_render_algorithm,
+        unique_ptr_alias<AudioDecoder>* audio_decoder,
+        unique_ptr_alias<AudioRendererSink>* audio_renderer_sink,
+        unique_ptr_alias<VideoDecoder>* video_decoder,
+        unique_ptr_alias<VideoRenderAlgorithm>* video_render_algorithm,
         scoped_refptr<VideoRendererSink>* video_renderer_sink,
         std::string* error_message) = 0;
 
@@ -186,13 +187,13 @@ class PlayerComponents {
 
     void CreateStubAudioComponents(
         const CreationParameters& creation_parameters,
-        scoped_ptr<AudioDecoder>* audio_decoder,
-        scoped_ptr<AudioRendererSink>* audio_renderer_sink);
+        unique_ptr_alias<AudioDecoder>* audio_decoder,
+        unique_ptr_alias<AudioRendererSink>* audio_renderer_sink);
 
     void CreateStubVideoComponents(
         const CreationParameters& creation_parameters,
-        scoped_ptr<VideoDecoder>* video_decoder,
-        scoped_ptr<VideoRenderAlgorithm>* video_render_algorithm,
+        unique_ptr_alias<VideoDecoder>* video_decoder,
+        unique_ptr_alias<VideoRenderAlgorithm>* video_render_algorithm,
         scoped_refptr<VideoRendererSink>* video_renderer_sink);
 
     // Check AudioRenderer ctor for more details on the parameters.
diff --git a/starboard/shared/starboard/player/filter/stub_audio_decoder.cc b/starboard/shared/starboard/player/filter/stub_audio_decoder.cc
index fa83c8aab5ca..e00c2408ff96 100644
--- a/starboard/shared/starboard/player/filter/stub_audio_decoder.cc
+++ b/starboard/shared/starboard/player/filter/stub_audio_decoder.cc
@@ -154,7 +154,6 @@ void StubAudioDecoder::Reset() {
 
 void StubAudioDecoder::DecodeBuffers(const InputBuffers& input_buffers,
                                      const ConsumedCB& consumed_cb) {
-  SB_DCHECK(decoder_thread_->job_queue()->BelongsToCurrentThread());
   for (const auto& input_buffer : input_buffers) {
     DecodeOneBuffer(input_buffer);
   }
@@ -163,7 +162,6 @@ void StubAudioDecoder::DecodeBuffers(const InputBuffers& input_buffers,
 
 void StubAudioDecoder::DecodeOneBuffer(
     const scoped_refptr<InputBuffer>& input_buffer) {
-  SB_DCHECK(decoder_thread_->job_queue()->BelongsToCurrentThread());
   const int kMaxInputBeforeMultipleDecodedAudios = 4;
 
   if (last_input_buffer_) {
@@ -240,8 +238,6 @@ void StubAudioDecoder::DecodeOneBuffer(
 }
 
 void StubAudioDecoder::DecodeEndOfStream() {
-  SB_DCHECK(decoder_thread_->job_queue()->BelongsToCurrentThread());
-
   if (last_input_buffer_) {
     if (!frames_per_input_) {
       if (codec_ == kSbMediaAudioCodecOpus) {
diff --git a/starboard/shared/starboard/player/filter/stub_audio_decoder.h b/starboard/shared/starboard/player/filter/stub_audio_decoder.h
index 347c23ed5e5a..d9a16777cc20 100644
--- a/starboard/shared/starboard/player/filter/stub_audio_decoder.h
+++ b/starboard/shared/starboard/player/filter/stub_audio_decoder.h
@@ -15,6 +15,7 @@
 #ifndef STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_STUB_AUDIO_DECODER_H_
 #define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_STUB_AUDIO_DECODER_H_
 
+#include <memory>
 #include <queue>
 
 #include "starboard/common/optional.h"
@@ -58,7 +59,7 @@ class StubAudioDecoder : public AudioDecoder, private JobQueue::JobOwner {
   OutputCB output_cb_;
   ErrorCB error_cb_;
 
-  scoped_ptr<starboard::player::JobThread> decoder_thread_;
+  std::unique_ptr<starboard::player::JobThread> decoder_thread_;
   Mutex decoded_audios_mutex_;
   std::queue<scoped_refptr<DecodedAudio> > decoded_audios_;
   scoped_refptr<InputBuffer> last_input_buffer_;
diff --git a/starboard/shared/starboard/player/filter/stub_player_components_factory.cc b/starboard/shared/starboard/player/filter/stub_player_components_factory.cc
index f916ac44eac1..908ba94b3578 100644
--- a/starboard/shared/starboard/player/filter/stub_player_components_factory.cc
+++ b/starboard/shared/starboard/player/filter/stub_player_components_factory.cc
@@ -23,8 +23,9 @@ namespace player {
 namespace filter {
 
 // static
-scoped_ptr<PlayerComponents::Factory> StubPlayerComponentsFactory::Create() {
-  return make_scoped_ptr<PlayerComponents::Factory>(
+unique_ptr_alias<PlayerComponents::Factory>
+StubPlayerComponentsFactory::Create() {
+  return unique_ptr_alias<PlayerComponents::Factory>(
       new StubPlayerComponentsFactory);
 }
 
diff --git a/starboard/shared/starboard/player/filter/stub_player_components_factory.h b/starboard/shared/starboard/player/filter/stub_player_components_factory.h
index 5753f273cdb3..f662ae8df6d3 100644
--- a/starboard/shared/starboard/player/filter/stub_player_components_factory.h
+++ b/starboard/shared/starboard/player/filter/stub_player_components_factory.h
@@ -28,14 +28,14 @@ namespace filter {
 
 class StubPlayerComponentsFactory : public PlayerComponents::Factory {
  public:
-  static scoped_ptr<PlayerComponents::Factory> Create();
+  static unique_ptr_alias<PlayerComponents::Factory> Create();
 
   bool CreateSubComponents(
       const CreationParameters& creation_parameters,
-      scoped_ptr<AudioDecoder>* audio_decoder,
-      scoped_ptr<AudioRendererSink>* audio_renderer_sink,
-      scoped_ptr<VideoDecoder>* video_decoder,
-      scoped_ptr<VideoRenderAlgorithm>* video_render_algorithm,
+      unique_ptr_alias<AudioDecoder>* audio_decoder,
+      unique_ptr_alias<AudioRendererSink>* audio_renderer_sink,
+      unique_ptr_alias<VideoDecoder>* video_decoder,
+      unique_ptr_alias<VideoRenderAlgorithm>* video_render_algorithm,
       scoped_refptr<VideoRendererSink>* video_renderer_sink,
       std::string* error_message) override {
     SB_DCHECK(error_message);
diff --git a/starboard/shared/starboard/player/filter/stub_video_decoder.cc b/starboard/shared/starboard/player/filter/stub_video_decoder.cc
index 21b07accc1ce..fc8f2e4b2c72 100644
--- a/starboard/shared/starboard/player/filter/stub_video_decoder.cc
+++ b/starboard/shared/starboard/player/filter/stub_video_decoder.cc
@@ -82,7 +82,6 @@ SbDecodeTarget StubVideoDecoder::GetCurrentDecodeTarget() {
 }
 
 void StubVideoDecoder::DecodeBuffers(const InputBuffers& input_buffers) {
-  SB_DCHECK(decoder_thread_->job_queue()->BelongsToCurrentThread());
   for (const auto& input_buffer : input_buffers) {
     auto& video_sample_info = input_buffer->video_sample_info();
     if (video_sample_info.is_key_frame) {
@@ -120,8 +119,6 @@ void StubVideoDecoder::DecodeBuffers(const InputBuffers& input_buffers) {
 }
 
 void StubVideoDecoder::DecodeEndOfStream() {
-  SB_DCHECK(decoder_thread_->job_queue()->BelongsToCurrentThread());
-
   // If there are any remaining frames we need to output, send them all out
   // before writing EOS.
   for (const auto time : output_frame_timestamps_) {
diff --git a/starboard/shared/starboard/player/filter/stub_video_decoder.h b/starboard/shared/starboard/player/filter/stub_video_decoder.h
index 513a49ec6942..9c03557f2cc0 100644
--- a/starboard/shared/starboard/player/filter/stub_video_decoder.h
+++ b/starboard/shared/starboard/player/filter/stub_video_decoder.h
@@ -15,6 +15,7 @@
 #ifndef STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_STUB_VIDEO_DECODER_H_
 #define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_STUB_VIDEO_DECODER_H_
 
+#include <memory>
 #include <set>
 
 #include "starboard/shared/internal_only.h"
@@ -55,7 +56,7 @@ class StubVideoDecoder : public VideoDecoder, private JobQueue::JobOwner {
   DecoderStatusCB decoder_status_cb_;
   media::VideoStreamInfo video_stream_info_;
 
-  scoped_ptr<starboard::player::JobThread> decoder_thread_;
+  std::unique_ptr<starboard::player::JobThread> decoder_thread_;
   // std::set<> keeps frame timestamps sorted in ascending order.
   std::set<int64_t> output_frame_timestamps_;
   // Used to determine when to send kBufferFull in DecodeOneBuffer().
diff --git a/starboard/shared/starboard/player/filter/testing/adaptive_audio_decoder_test.cc b/starboard/shared/starboard/player/filter/testing/adaptive_audio_decoder_test.cc
index c5d5cd842d43..05af0b599064 100644
--- a/starboard/shared/starboard/player/filter/testing/adaptive_audio_decoder_test.cc
+++ b/starboard/shared/starboard/player/filter/testing/adaptive_audio_decoder_test.cc
@@ -97,7 +97,7 @@ class AdaptiveAudioDecoderTest
       ASSERT_GT(dmp_reader->number_of_audio_buffers(), 0);
     }
 
-    scoped_ptr<AudioRendererSink> audio_renderer_sink;
+    unique_ptr_alias<AudioRendererSink> audio_renderer_sink;
     ASSERT_TRUE(CreateAudioComponents(using_stub_decoder_,
                                       dmp_readers_[0]->audio_stream_info(),
                                       &audio_decoder_, &audio_renderer_sink));
@@ -278,7 +278,7 @@ class AdaptiveAudioDecoderTest
   bool using_stub_decoder_;
 
   JobQueue job_queue_;
-  scoped_ptr<AudioDecoder> audio_decoder_;
+  unique_ptr_alias<AudioDecoder> audio_decoder_;
 
   Mutex event_queue_mutex_;
   std::deque<Event> event_queue_;
diff --git a/starboard/shared/starboard/player/filter/testing/audio_channel_layout_mixer_test.cc b/starboard/shared/starboard/player/filter/testing/audio_channel_layout_mixer_test.cc
index 16c953787b72..e85b02be6ebb 100644
--- a/starboard/shared/starboard/player/filter/testing/audio_channel_layout_mixer_test.cc
+++ b/starboard/shared/starboard/player/filter/testing/audio_channel_layout_mixer_test.cc
@@ -176,7 +176,7 @@ std::string GetAudioChannelLayoutMixerTestConfigName(
 }
 
 TEST_P(AudioChannelLayoutMixerTest, MixToMono) {
-  scoped_ptr<AudioChannelLayoutMixer> mixer =
+  std::unique_ptr<AudioChannelLayoutMixer> mixer =
       AudioChannelLayoutMixer::Create(sample_type_, storage_type_, 1);
   ASSERT_TRUE(mixer);
 
@@ -215,7 +215,7 @@ TEST_P(AudioChannelLayoutMixerTest, MixToMono) {
 }
 
 TEST_P(AudioChannelLayoutMixerTest, MixToStereo) {
-  scoped_ptr<AudioChannelLayoutMixer> mixer =
+  std::unique_ptr<AudioChannelLayoutMixer> mixer =
       AudioChannelLayoutMixer::Create(sample_type_, storage_type_, 2);
   ASSERT_TRUE(mixer);
 
@@ -254,7 +254,7 @@ TEST_P(AudioChannelLayoutMixerTest, MixToStereo) {
 }
 
 TEST_P(AudioChannelLayoutMixerTest, MixToQuad) {
-  scoped_ptr<AudioChannelLayoutMixer> mixer =
+  std::unique_ptr<AudioChannelLayoutMixer> mixer =
       AudioChannelLayoutMixer::Create(sample_type_, storage_type_, 4);
   ASSERT_TRUE(mixer);
 
@@ -298,7 +298,7 @@ TEST_P(AudioChannelLayoutMixerTest, MixToQuad) {
 }
 
 TEST_P(AudioChannelLayoutMixerTest, MixToFivePointOne) {
-  scoped_ptr<AudioChannelLayoutMixer> mixer =
+  std::unique_ptr<AudioChannelLayoutMixer> mixer =
       AudioChannelLayoutMixer::Create(sample_type_, storage_type_, 6);
   ASSERT_TRUE(mixer);
 
diff --git a/starboard/shared/starboard/player/filter/testing/audio_decoder_benchmark.cc b/starboard/shared/starboard/player/filter/testing/audio_decoder_benchmark.cc
index d5df498507e2..9057a7195e14 100644
--- a/starboard/shared/starboard/player/filter/testing/audio_decoder_benchmark.cc
+++ b/starboard/shared/starboard/player/filter/testing/audio_decoder_benchmark.cc
@@ -110,8 +110,8 @@ class AudioDecoderHelper {
   size_t current_input_buffer_index_ = 0;
   bool end_of_stream_decoded_ = false;
 
-  scoped_ptr<AudioDecoder> audio_decoder_;
-  scoped_ptr<AudioRendererSink> audio_renderer_sink_;
+  unique_ptr_alias<AudioDecoder> audio_decoder_;
+  unique_ptr_alias<AudioRendererSink> audio_renderer_sink_;
 };
 
 }  // namespace
diff --git a/starboard/shared/starboard/player/filter/testing/audio_decoder_test.cc b/starboard/shared/starboard/player/filter/testing/audio_decoder_test.cc
index 48ce9672c074..cc120c957030 100644
--- a/starboard/shared/starboard/player/filter/testing/audio_decoder_test.cc
+++ b/starboard/shared/starboard/player/filter/testing/audio_decoder_test.cc
@@ -122,9 +122,10 @@ class AudioDecoderTest
  protected:
   enum Event { kConsumed, kOutput, kError };
 
-  void CreateComponents(const media::AudioStreamInfo& audio_stream_info,
-                        scoped_ptr<AudioDecoder>* audio_decoder,
-                        scoped_ptr<AudioRendererSink>* audio_renderer_sink) {
+  void CreateComponents(
+      const media::AudioStreamInfo& audio_stream_info,
+      unique_ptr_alias<AudioDecoder>* audio_decoder,
+      unique_ptr_alias<AudioRendererSink>* audio_renderer_sink) {
     if (CreateAudioComponents(using_stub_decoder_, audio_stream_info,
                               audio_decoder, audio_renderer_sink)) {
       SB_CHECK(*audio_decoder);
@@ -482,8 +483,8 @@ class AudioDecoderTest
 
   JobQueue job_queue_;
   VideoDmpReader dmp_reader_;
-  scoped_ptr<AudioDecoder> audio_decoder_;
-  scoped_ptr<AudioRendererSink> audio_renderer_sink_;
+  unique_ptr_alias<AudioDecoder> audio_decoder_;
+  unique_ptr_alias<AudioRendererSink> audio_renderer_sink_;
 
   bool can_accept_more_input_ = true;
   scoped_refptr<InputBuffer> last_input_buffer_;
@@ -515,8 +516,8 @@ TEST_P(AudioDecoderTest, MultiDecoders) {
   const int kDecodersToCreate = 100;
   const int kMinimumNumberOfExtraDecodersRequired = 3;
 
-  scoped_ptr<AudioDecoder> audio_decoders[kDecodersToCreate];
-  scoped_ptr<AudioRendererSink> audio_renderer_sinks[kDecodersToCreate];
+  unique_ptr_alias<AudioDecoder> audio_decoders[kDecodersToCreate];
+  unique_ptr_alias<AudioRendererSink> audio_renderer_sinks[kDecodersToCreate];
 
   for (int i = 0; i < kDecodersToCreate; ++i) {
     CreateComponents(dmp_reader_.audio_stream_info(), &audio_decoders[i],
diff --git a/starboard/shared/starboard/player/filter/testing/audio_renderer_internal_test.cc b/starboard/shared/starboard/player/filter/testing/audio_renderer_internal_test.cc
index 58a9555232cd..bbb23b74fda9 100644
--- a/starboard/shared/starboard/player/filter/testing/audio_renderer_internal_test.cc
+++ b/starboard/shared/starboard/player/filter/testing/audio_renderer_internal_test.cc
@@ -116,8 +116,8 @@ class AudioRendererTest : public ::testing::Test {
     const int kMaxCachedFrames = 256 * 1024;
     const int kMaxFramesPerAppend = 16384;
     audio_renderer_.reset(new AudioRendererPcm(
-        make_scoped_ptr<AudioDecoder>(audio_decoder_),
-        make_scoped_ptr<AudioRendererSink>(audio_renderer_sink_),
+        unique_ptr_alias<AudioDecoder>(audio_decoder_),
+        unique_ptr_alias<AudioRendererSink>(audio_renderer_sink_),
         GetDefaultAudioStreamInfo(), kMaxCachedFrames, kMaxFramesPerAppend));
     audio_renderer_->Initialize(
         std::bind(&AudioRendererTest::OnError, this),
@@ -235,7 +235,7 @@ class AudioRendererTest : public ::testing::Test {
   AudioDecoder::ConsumedCB consumed_cb_;
   bool prerolled_ = true;
 
-  scoped_ptr<AudioRendererPcm> audio_renderer_;
+  std::unique_ptr<AudioRendererPcm> audio_renderer_;
   MockAudioDecoder* audio_decoder_;
   MockAudioRendererSink* audio_renderer_sink_;
   AudioRendererSink::RenderCallback* renderer_callback_;
diff --git a/starboard/shared/starboard/player/filter/testing/audio_resampler_test.cc b/starboard/shared/starboard/player/filter/testing/audio_resampler_test.cc
index ec992f456355..2f502a47afdd 100644
--- a/starboard/shared/starboard/player/filter/testing/audio_resampler_test.cc
+++ b/starboard/shared/starboard/player/filter/testing/audio_resampler_test.cc
@@ -118,7 +118,7 @@ class AudioResamplerTest
 };
 
 TEST_P(AudioResamplerTest, SunnyDay) {
-  scoped_ptr<AudioResampler> resampler = AudioResampler::Create(
+  std::unique_ptr<AudioResampler> resampler = AudioResampler::Create(
       source_sample_type_, source_storage_type_, source_sample_rate_,
       destination_sample_type_, destination_storage_type_,
       destination_sample_rate_, channels_);
diff --git a/starboard/shared/starboard/player/filter/testing/media_time_provider_impl_test.cc b/starboard/shared/starboard/player/filter/testing/media_time_provider_impl_test.cc
index cc291a27058f..cdfe805ea60a 100644
--- a/starboard/shared/starboard/player/filter/testing/media_time_provider_impl_test.cc
+++ b/starboard/shared/starboard/player/filter/testing/media_time_provider_impl_test.cc
@@ -84,7 +84,7 @@ class MediaTimeProviderImplTest : public ::testing::Test {
         // is passed to and owned by |media_time_provider_impl_|, so the tests
         // can adjust expectation on it.  This is safe in the context of the
         // tests.
-        media_time_provider_impl_(make_scoped_ptr<MonotonicSystemTimeProvider>(
+        media_time_provider_impl_(std::unique_ptr<MonotonicSystemTimeProvider>(
             system_time_provider_)) {
     media_time_provider_impl_.SetPlaybackRate(1.0);
   }
diff --git a/starboard/shared/starboard/player/filter/testing/player_components_test.cc b/starboard/shared/starboard/player/filter/testing/player_components_test.cc
index e4726bef7f2c..ebed3c9828d6 100644
--- a/starboard/shared/starboard/player/filter/testing/player_components_test.cc
+++ b/starboard/shared/starboard/player/filter/testing/player_components_test.cc
@@ -85,7 +85,7 @@ class PlayerComponentsTest
           video_filename_.c_str(), VideoDmpReader::kEnableReadOnDemand));
     }
 
-    scoped_ptr<PlayerComponents::Factory> factory =
+    unique_ptr_alias<PlayerComponents::Factory> factory =
         PlayerComponents::Factory::Create();
     string error_message;
     if (audio_reader_ && video_reader_) {
@@ -484,7 +484,7 @@ class PlayerComponentsTest
   FakeGraphicsContextProvider fake_graphics_context_provider_;
   unique_ptr<VideoDmpReader> audio_reader_;
   unique_ptr<VideoDmpReader> video_reader_;
-  scoped_ptr<PlayerComponents> player_components_;
+  unique_ptr_alias<PlayerComponents> player_components_;
   double playback_rate_ = 1.0;
   int audio_index_ = 0;
   int video_index_ = 0;
diff --git a/starboard/shared/starboard/player/filter/testing/test_util.cc b/starboard/shared/starboard/player/filter/testing/test_util.cc
index 831d7c163af0..54709f84d1c3 100644
--- a/starboard/shared/starboard/player/filter/testing/test_util.cc
+++ b/starboard/shared/starboard/player/filter/testing/test_util.cc
@@ -215,10 +215,11 @@ std::vector<VideoTestParam> GetSupportedVideoTests() {
   return test_params;
 }
 
-bool CreateAudioComponents(bool using_stub_decoder,
-                           const media::AudioStreamInfo& audio_stream_info,
-                           scoped_ptr<AudioDecoder>* audio_decoder,
-                           scoped_ptr<AudioRendererSink>* audio_renderer_sink) {
+bool CreateAudioComponents(
+    bool using_stub_decoder,
+    const media::AudioStreamInfo& audio_stream_info,
+    unique_ptr_alias<AudioDecoder>* audio_decoder,
+    unique_ptr_alias<AudioRendererSink>* audio_renderer_sink) {
   SB_CHECK(audio_decoder);
   SB_CHECK(audio_renderer_sink);
 
@@ -228,7 +229,7 @@ bool CreateAudioComponents(bool using_stub_decoder,
   PlayerComponents::Factory::CreationParameters creation_parameters(
       audio_stream_info);
 
-  scoped_ptr<PlayerComponents::Factory> factory;
+  unique_ptr_alias<PlayerComponents::Factory> factory;
   if (using_stub_decoder) {
     factory = StubPlayerComponentsFactory::Create();
   } else {
diff --git a/starboard/shared/starboard/player/filter/testing/test_util.h b/starboard/shared/starboard/player/filter/testing/test_util.h
index 73fd92f4f339..7e4ad9732854 100644
--- a/starboard/shared/starboard/player/filter/testing/test_util.h
+++ b/starboard/shared/starboard/player/filter/testing/test_util.h
@@ -56,10 +56,11 @@ std::vector<const char*> GetSupportedAudioTestFiles(
     const char* extra_mime_attributes = "");
 std::vector<VideoTestParam> GetSupportedVideoTests();
 
-bool CreateAudioComponents(bool using_stub_decoder,
-                           const media::AudioStreamInfo& audio_stream_info,
-                           scoped_ptr<AudioDecoder>* audio_decoder,
-                           scoped_ptr<AudioRendererSink>* audio_renderer_sink);
+bool CreateAudioComponents(
+    bool using_stub_decoder,
+    const media::AudioStreamInfo& audio_stream_info,
+    unique_ptr_alias<AudioDecoder>* audio_decoder,
+    unique_ptr_alias<AudioRendererSink>* audio_renderer_sink);
 
 ::testing::AssertionResult AlmostEqualTime(int64_t time1, int64_t time2);
 
diff --git a/starboard/shared/starboard/player/filter/testing/video_decoder_test.cc b/starboard/shared/starboard/player/filter/testing/video_decoder_test.cc
index f0951b8e2a4a..83fb1200828a 100644
--- a/starboard/shared/starboard/player/filter/testing/video_decoder_test.cc
+++ b/starboard/shared/starboard/player/filter/testing/video_decoder_test.cc
@@ -132,7 +132,7 @@ TEST_P(VideoDecoderTest, ThreeMoreDecoders) {
   // Create three more decoders for each supported combinations.
   const int kDecodersToCreate = 3;
 
-  scoped_ptr<PlayerComponents::Factory> factory =
+  unique_ptr_alias<PlayerComponents::Factory> factory =
       PlayerComponents::Factory::Create();
 
   SbPlayerOutputMode kOutputModes[] = {kSbPlayerOutputModeDecodeToTexture,
@@ -149,8 +149,8 @@ TEST_P(VideoDecoderTest, ThreeMoreDecoders) {
         if (PlayerComponents::Factory::OutputModeSupported(
                 output_mode, video_codec, kSbDrmSystemInvalid)) {
           SbPlayerPrivate players[kDecodersToCreate];
-          scoped_ptr<VideoDecoder> video_decoders[kDecodersToCreate];
-          scoped_ptr<VideoRenderAlgorithm>
+          unique_ptr_alias<VideoDecoder> video_decoders[kDecodersToCreate];
+          unique_ptr_alias<VideoRenderAlgorithm>
               video_render_algorithms[kDecodersToCreate];
           scoped_refptr<VideoRendererSink>
               video_renderer_sinks[kDecodersToCreate];
diff --git a/starboard/shared/starboard/player/filter/testing/video_decoder_test_fixture.cc b/starboard/shared/starboard/player/filter/testing/video_decoder_test_fixture.cc
index a343df605bb4..1d39ff8c0ec8 100644
--- a/starboard/shared/starboard/player/filter/testing/video_decoder_test_fixture.cc
+++ b/starboard/shared/starboard/player/filter/testing/video_decoder_test_fixture.cc
@@ -92,7 +92,7 @@ void VideoDecoderTestFixture::Initialize() {
       fake_graphics_context_provider_->decoder_target_provider(), nullptr);
   ASSERT_EQ(creation_parameters.max_video_input_size(), max_video_input_size);
 
-  scoped_ptr<PlayerComponents::Factory> factory;
+  unique_ptr_alias<PlayerComponents::Factory> factory;
   if (using_stub_decoder_) {
     factory = StubPlayerComponentsFactory::Create();
   } else {
diff --git a/starboard/shared/starboard/player/filter/testing/video_decoder_test_fixture.h b/starboard/shared/starboard/player/filter/testing/video_decoder_test_fixture.h
index 3894825ffaf0..5bf2ca4dc47e 100644
--- a/starboard/shared/starboard/player/filter/testing/video_decoder_test_fixture.h
+++ b/starboard/shared/starboard/player/filter/testing/video_decoder_test_fixture.h
@@ -129,7 +129,7 @@ class VideoDecoderTestFixture {
   void UseInvalidDataForInput(size_t index, uint8_t byte_to_fill) {
     invalid_inputs_[index] = byte_to_fill;
   }
-  const scoped_ptr<VideoDecoder>& video_decoder() const {
+  const unique_ptr_alias<VideoDecoder>& video_decoder() const {
     return video_decoder_;
   }
   const video_dmp::VideoDmpReader& dmp_reader() const { return dmp_reader_; }
@@ -157,14 +157,14 @@ class VideoDecoderTestFixture {
   ::starboard::testing::FakeGraphicsContextProvider*
       fake_graphics_context_provider_;
   video_dmp::VideoDmpReader dmp_reader_;
-  scoped_ptr<VideoDecoder> video_decoder_;
+  unique_ptr_alias<VideoDecoder> video_decoder_;
 
   bool need_more_input_ = true;
   std::set<int64_t> outstanding_inputs_;
   std::deque<scoped_refptr<VideoFrame>> decoded_frames_;
 
   SbPlayerPrivate player_;
-  scoped_ptr<VideoRenderAlgorithm> video_render_algorithm_;
+  unique_ptr_alias<VideoRenderAlgorithm> video_render_algorithm_;
   scoped_refptr<VideoRendererSink> video_renderer_sink_;
 
   bool end_of_stream_written_ = false;
diff --git a/starboard/shared/starboard/player/filter/tools/audio_dmp_player.cc b/starboard/shared/starboard/player/filter/tools/audio_dmp_player.cc
index 6869fe0f6bf3..64c6e603ae5e 100644
--- a/starboard/shared/starboard/player/filter/tools/audio_dmp_player.cc
+++ b/starboard/shared/starboard/player/filter/tools/audio_dmp_player.cc
@@ -12,6 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+#include <memory>
 #include <string>
 
 #include "starboard/common/log.h"
@@ -28,7 +29,6 @@
 
 namespace {
 
-using starboard::scoped_ptr;
 using starboard::shared::starboard::player::InputBuffer;
 using starboard::shared::starboard::player::InputBuffers;
 using starboard::shared::starboard::player::JobThread;
@@ -42,10 +42,10 @@ const int kJobThreadStackSize = SB_MEDIA_PLAYER_THREAD_STACK_SIZE;
 const int kJobThreadStackSize = 0;
 #endif  // SB_MEDIA_PLAYER_THREAD_STACK_SIZE
 
-scoped_ptr<VideoDmpReader> s_video_dmp_reader;
-scoped_ptr<PlayerComponents> s_player_components;
+std::unique_ptr<VideoDmpReader> s_video_dmp_reader;
+starboard::unique_ptr_alias<PlayerComponents> s_player_components;
 int s_audio_sample_index;
-scoped_ptr<JobThread> s_job_thread;
+std::unique_ptr<JobThread> s_job_thread;
 int64_t s_duration;
 
 static void DeallocateSampleFunc(SbPlayer player,
@@ -101,7 +101,7 @@ void EndedCB() {
 void Start(const char* filename) {
   SB_LOG(INFO) << "Loading " << filename;
   s_video_dmp_reader.reset(new VideoDmpReader(filename));
-  scoped_ptr<PlayerComponents::Factory> factory =
+  starboard::unique_ptr_alias<PlayerComponents::Factory> factory =
       PlayerComponents::Factory::Create();
   PlayerComponents::Factory::CreationParameters creation_parameters(
       s_video_dmp_reader->audio_stream_info());
diff --git a/starboard/shared/starboard/player/filter/video_renderer_internal_impl.cc b/starboard/shared/starboard/player/filter/video_renderer_internal_impl.cc
index fd31dc6f80be..bae367bbc297 100644
--- a/starboard/shared/starboard/player/filter/video_renderer_internal_impl.cc
+++ b/starboard/shared/starboard/player/filter/video_renderer_internal_impl.cc
@@ -16,6 +16,7 @@
 
 #include <algorithm>
 #include <functional>
+#include <utility>
 
 #include "starboard/common/time.h"
 
@@ -34,14 +35,15 @@ const int64_t kSeekTimeoutRetryInterval = 25'000;  // 25ms
 
 }  // namespace
 
-VideoRendererImpl::VideoRendererImpl(scoped_ptr<VideoDecoder> decoder,
-                                     MediaTimeProvider* media_time_provider,
-                                     scoped_ptr<VideoRenderAlgorithm> algorithm,
-                                     scoped_refptr<VideoRendererSink> sink)
+VideoRendererImpl::VideoRendererImpl(
+    unique_ptr_alias<VideoDecoder> decoder,
+    MediaTimeProvider* media_time_provider,
+    unique_ptr_alias<VideoRenderAlgorithm> algorithm,
+    scoped_refptr<VideoRendererSink> sink)
     : media_time_provider_(media_time_provider),
-      algorithm_(algorithm.Pass()),
+      algorithm_(std::move(algorithm)),
       sink_(sink),
-      decoder_(decoder.Pass()),
+      decoder_(std::move(decoder)),
       end_of_stream_written_(false),
       ended_cb_called_(false),
       need_more_input_(true),
diff --git a/starboard/shared/starboard/player/filter/video_renderer_internal_impl.h b/starboard/shared/starboard/player/filter/video_renderer_internal_impl.h
index c292b0c59f5f..bc7ff00bb837 100644
--- a/starboard/shared/starboard/player/filter/video_renderer_internal_impl.h
+++ b/starboard/shared/starboard/player/filter/video_renderer_internal_impl.h
@@ -16,6 +16,7 @@
 #define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_VIDEO_RENDERER_INTERNAL_IMPL_H_
 
 #include <list>
+#include <memory>
 
 #include "starboard/common/atomic.h"
 #include "starboard/common/log.h"
@@ -46,9 +47,9 @@ class VideoRendererImpl : public VideoRenderer, private JobQueue::JobOwner {
  public:
   // All of the functions are called on the PlayerWorker thread unless marked
   // otherwise.
-  VideoRendererImpl(scoped_ptr<VideoDecoder> decoder,
+  VideoRendererImpl(unique_ptr_alias<VideoDecoder> decoder,
                     MediaTimeProvider* media_time_provider,
-                    scoped_ptr<VideoRenderAlgorithm> algorithm,
+                    unique_ptr_alias<VideoRenderAlgorithm> algorithm,
                     scoped_refptr<VideoRendererSink> sink);
   ~VideoRendererImpl() override;
 
@@ -84,9 +85,9 @@ class VideoRendererImpl : public VideoRenderer, private JobQueue::JobOwner {
   void OnSeekTimeout();
 
   MediaTimeProvider* const media_time_provider_;
-  scoped_ptr<VideoRenderAlgorithm> algorithm_;
+  unique_ptr_alias<VideoRenderAlgorithm> algorithm_;
   scoped_refptr<VideoRendererSink> sink_;
-  scoped_ptr<VideoDecoder> decoder_;
+  unique_ptr_alias<VideoDecoder> decoder_;
 
   PrerolledCB prerolled_cb_;
   EndedCB ended_cb_;
diff --git a/starboard/shared/starboard/player/filter/wsola_internal.cc b/starboard/shared/starboard/player/filter/wsola_internal.cc
index ad4e1bf9243c..bae7adb65d99 100644
--- a/starboard/shared/starboard/player/filter/wsola_internal.cc
+++ b/starboard/shared/starboard/player/filter/wsola_internal.cc
@@ -30,7 +30,6 @@
 #include <memory>
 
 #include "starboard/common/log.h"
-#include "starboard/common/scoped_ptr.h"
 #include "starboard/memory.h"
 
 #if SB_IS(ARCH_X86) || SB_IS(ARCH_X64)
@@ -196,7 +195,7 @@ int DecimatedSearch(int decimation,
   int channels = search_segment->channels();
   int block_size = target_block->frames();
   int num_candidate_blocks = search_segment->frames() - (block_size - 1);
-  scoped_array<float> dot_prod(new float[channels]);
+  std::unique_ptr<float[]> dot_prod(new float[channels]);
   float similarity[3];  // Three elements for cubic interpolation.
 
   int n = 0;
@@ -275,7 +274,7 @@ int FullSearch(int low_limit,
                const float* energy_candidate_blocks) {
   int channels = search_block->channels();
   int block_size = target_block->frames();
-  scoped_array<float> dot_prod(new float[channels]);
+  std::unique_ptr<float[]> dot_prod(new float[channels]);
 
   float best_similarity = std::numeric_limits<float>::min();
   int optimal_index = 0;
@@ -321,8 +320,8 @@ int OptimalIndex(const scoped_refptr<DecodedAudio>& search_block,
   // heuristically based on experiments.
   const int kSearchDecimation = 5;
 
-  scoped_array<float> energy_target_block(new float[channels]);
-  scoped_array<float> energy_candidate_blocks(
+  std::unique_ptr<float[]> energy_target_block(new float[channels]);
+  std::unique_ptr<float[]> energy_candidate_blocks(
       new float[channels * num_candidate_blocks]);
 
   // Energy of all candid frames.
diff --git a/starboard/shared/starboard/player/job_thread.h b/starboard/shared/starboard/player/job_thread.h
index 2ad61b465d71..e49b65ab9384 100644
--- a/starboard/shared/starboard/player/job_thread.h
+++ b/starboard/shared/starboard/player/job_thread.h
@@ -15,6 +15,7 @@
 #ifndef STARBOARD_SHARED_STARBOARD_PLAYER_JOB_THREAD_H_
 #define STARBOARD_SHARED_STARBOARD_PLAYER_JOB_THREAD_H_
 
+#include <memory>
 #include <utility>
 
 #include "starboard/common/log.h"
@@ -88,7 +89,7 @@ class JobThread {
   void RunLoop();
 
   SbThread thread_;
-  scoped_ptr<JobQueue> job_queue_;
+  std::unique_ptr<JobQueue> job_queue_;
 };
 
 }  // namespace player
diff --git a/starboard/shared/starboard/player/player_create.cc b/starboard/shared/starboard/player/player_create.cc
index 1e16806db637..d3f721aa1463 100644
--- a/starboard/shared/starboard/player/player_create.cc
+++ b/starboard/shared/starboard/player/player_create.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include <string>
+#include <utility>
 
 #include "starboard/player.h"
 
@@ -210,12 +211,12 @@ SbPlayer SbPlayerCreate(SbWindow window,
 
   UpdateActiveSessionPlatformPlaybackState(kPlaying);
 
-  starboard::scoped_ptr<PlayerWorker::Handler> handler(
+  starboard::unique_ptr_alias<PlayerWorker::Handler> handler(
       new FilterBasedPlayerWorkerHandler(creation_param, provider));
 
   SbPlayer player = SbPlayerPrivate::CreateInstance(
       audio_codec, video_codec, sample_deallocate_func, decoder_status_func,
-      player_status_func, player_error_func, context, handler.Pass());
+      player_status_func, player_error_func, context, std::move(handler));
 
 #if SB_PLAYER_ENABLE_VIDEO_DUMPER
   using ::starboard::shared::starboard::player::video_dmp::VideoDmpWriter;
diff --git a/starboard/shared/starboard/player/player_internal.cc b/starboard/shared/starboard/player/player_internal.cc
index 4e67ee0161d6..8dcd52133c97 100644
--- a/starboard/shared/starboard/player/player_internal.cc
+++ b/starboard/shared/starboard/player/player_internal.cc
@@ -51,12 +51,12 @@ SbPlayerPrivate::SbPlayerPrivate(
     SbPlayerStatusFunc player_status_func,
     SbPlayerErrorFunc player_error_func,
     void* context,
-    starboard::scoped_ptr<PlayerWorker::Handler> player_worker_handler)
+    starboard::unique_ptr_alias<PlayerWorker::Handler> player_worker_handler)
     : sample_deallocate_func_(sample_deallocate_func),
       context_(context),
       media_time_updated_at_(starboard::CurrentMonotonicTime()) {
-  worker_ = starboard::make_scoped_ptr(PlayerWorker::CreateInstance(
-      audio_codec, video_codec, player_worker_handler.Pass(),
+  worker_ = std::unique_ptr<PlayerWorker>(PlayerWorker::CreateInstance(
+      audio_codec, video_codec, std::move(player_worker_handler),
       std::bind(&SbPlayerPrivate::UpdateMediaInfo, this, _1, _2, _3, _4),
       decoder_status_func, player_status_func, player_error_func, this,
       context));
@@ -75,11 +75,11 @@ SbPlayerPrivate* SbPlayerPrivate::CreateInstance(
     SbPlayerStatusFunc player_status_func,
     SbPlayerErrorFunc player_error_func,
     void* context,
-    starboard::scoped_ptr<PlayerWorker::Handler> player_worker_handler) {
+    starboard::unique_ptr_alias<PlayerWorker::Handler> player_worker_handler) {
   SbPlayerPrivate* ret = new SbPlayerPrivate(
       audio_codec, video_codec, sample_deallocate_func, decoder_status_func,
       player_status_func, player_error_func, context,
-      player_worker_handler.Pass());
+      std::move(player_worker_handler));
 
   if (ret && ret->worker_) {
     return ret;
diff --git a/starboard/shared/starboard/player/player_internal.h b/starboard/shared/starboard/player/player_internal.h
index 8f036b5b0b48..e58c668d6388 100644
--- a/starboard/shared/starboard/player/player_internal.h
+++ b/starboard/shared/starboard/player/player_internal.h
@@ -15,6 +15,7 @@
 #ifndef STARBOARD_SHARED_STARBOARD_PLAYER_PLAYER_INTERNAL_H_
 #define STARBOARD_SHARED_STARBOARD_PLAYER_PLAYER_INTERNAL_H_
 
+#include <memory>
 #include <utility>
 #include <vector>
 
@@ -45,7 +46,7 @@ struct SbPlayerPrivate {
       SbPlayerStatusFunc player_status_func,
       SbPlayerErrorFunc player_error_func,
       void* context,
-      starboard::scoped_ptr<PlayerWorker::Handler> player_worker_handler);
+      starboard::unique_ptr_alias<PlayerWorker::Handler> player_worker_handler);
 
   void Seek(int64_t seek_to_time, int ticket);
   template <typename PlayerSampleInfo>
@@ -83,7 +84,7 @@ struct SbPlayerPrivate {
       SbPlayerStatusFunc player_status_func,
       SbPlayerErrorFunc player_error_func,
       void* context,
-      starboard::scoped_ptr<PlayerWorker::Handler> player_worker_handler);
+      starboard::unique_ptr_alias<PlayerWorker::Handler> player_worker_handler);
 
   SbPlayerPrivate(const SbPlayerPrivate&) = delete;
   SbPlayerPrivate& operator=(const SbPlayerPrivate&) = delete;
@@ -111,7 +112,7 @@ struct SbPlayerPrivate {
   // we may extrapolate the media time in GetInfo().
   bool is_progressing_ = false;
 
-  starboard::scoped_ptr<PlayerWorker> worker_;
+  std::unique_ptr<PlayerWorker> worker_;
 
   starboard::Mutex audio_configurations_mutex_;
   std::vector<SbMediaAudioConfiguration> audio_configurations_;
diff --git a/starboard/shared/starboard/player/player_worker.cc b/starboard/shared/starboard/player/player_worker.cc
index bc2cdb3e549b..72b1b68cb40a 100644
--- a/starboard/shared/starboard/player/player_worker.cc
+++ b/starboard/shared/starboard/player/player_worker.cc
@@ -15,6 +15,7 @@
 #include "starboard/shared/starboard/player/player_worker.h"
 
 #include <string>
+#include <utility>
 
 #include "starboard/common/condition_variable.h"
 #include "starboard/common/instance_counter.h"
@@ -64,7 +65,7 @@ struct ThreadParam {
 PlayerWorker* PlayerWorker::CreateInstance(
     SbMediaAudioCodec audio_codec,
     SbMediaVideoCodec video_codec,
-    scoped_ptr<Handler> handler,
+    unique_ptr_alias<Handler> handler,
     UpdateMediaInfoCB update_media_info_cb,
     SbPlayerDecoderStatusFunc decoder_status_func,
     SbPlayerStatusFunc player_status_func,
@@ -72,7 +73,7 @@ PlayerWorker* PlayerWorker::CreateInstance(
     SbPlayer player,
     void* context) {
   PlayerWorker* ret =
-      new PlayerWorker(audio_codec, video_codec, handler.Pass(),
+      new PlayerWorker(audio_codec, video_codec, std::move(handler),
                        update_media_info_cb, decoder_status_func,
                        player_status_func, player_error_func, player, context);
 
@@ -99,7 +100,7 @@ PlayerWorker::~PlayerWorker() {
 
 PlayerWorker::PlayerWorker(SbMediaAudioCodec audio_codec,
                            SbMediaVideoCodec video_codec,
-                           scoped_ptr<Handler> handler,
+                           unique_ptr_alias<Handler> handler,
                            UpdateMediaInfoCB update_media_info_cb,
                            SbPlayerDecoderStatusFunc decoder_status_func,
                            SbPlayerStatusFunc player_status_func,
@@ -109,7 +110,7 @@ PlayerWorker::PlayerWorker(SbMediaAudioCodec audio_codec,
     : thread_(kSbThreadInvalid),
       audio_codec_(audio_codec),
       video_codec_(video_codec),
-      handler_(handler.Pass()),
+      handler_(std::move(handler)),
       update_media_info_cb_(update_media_info_cb),
       decoder_status_func_(decoder_status_func),
       player_status_func_(player_status_func),
diff --git a/starboard/shared/starboard/player/player_worker.h b/starboard/shared/starboard/player/player_worker.h
index 9b48f1bea20e..8ba7279a5b88 100644
--- a/starboard/shared/starboard/player/player_worker.h
+++ b/starboard/shared/starboard/player/player_worker.h
@@ -120,7 +120,7 @@ class PlayerWorker {
   static PlayerWorker* CreateInstance(
       SbMediaAudioCodec audio_codec,
       SbMediaVideoCodec video_codec,
-      scoped_ptr<Handler> handler,
+      unique_ptr_alias<Handler> handler,
       UpdateMediaInfoCB update_media_info_cb,
       SbPlayerDecoderStatusFunc decoder_status_func,
       SbPlayerStatusFunc player_status_func,
@@ -181,7 +181,7 @@ class PlayerWorker {
  private:
   PlayerWorker(SbMediaAudioCodec audio_codec,
                SbMediaVideoCodec video_codec,
-               scoped_ptr<Handler> handler,
+               unique_ptr_alias<Handler> handler,
                UpdateMediaInfoCB update_media_info_cb,
                SbPlayerDecoderStatusFunc decoder_status_func,
                SbPlayerStatusFunc player_status_func,
@@ -216,11 +216,11 @@ class PlayerWorker {
   void UpdateDecoderState(SbMediaType type, SbPlayerDecoderState state);
 
   SbThread thread_;
-  scoped_ptr<JobQueue> job_queue_;
+  std::unique_ptr<JobQueue> job_queue_;
 
   SbMediaAudioCodec audio_codec_;
   SbMediaVideoCodec video_codec_;
-  scoped_ptr<Handler> handler_;
+  unique_ptr_alias<Handler> handler_;
   UpdateMediaInfoCB update_media_info_cb_;
 
   SbPlayerDecoderStatusFunc decoder_status_func_;