Convert //media/cast from scoped_ptr to std::unique_ptr

media/cast/cast_sender_impl.cc

 // Copyright 2013 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/cast/cast_sender_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 38 matching lines @@
   }
 
  protected:
   ~LocalVideoFrameInput() final {}
 
  private:
   friend class base::RefCountedThreadSafe<LocalVideoFrameInput>;
 
   const scoped_refptr<CastEnvironment> cast_environment_;
   const base::WeakPtr<VideoSender> video_sender_;
-  const scoped_ptr<VideoFrameFactory> video_frame_factory_;
+  const std::unique_ptr<VideoFrameFactory> video_frame_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalVideoFrameInput);
 };
 
 // The LocalAudioFrameInput class posts all incoming audio frames to the main
 // cast thread for processing. Therefore frames can be inserted from any thread.
 class LocalAudioFrameInput : public AudioFrameInput {
  public:
   LocalAudioFrameInput(scoped_refptr<CastEnvironment> cast_environment,
                        base::WeakPtr<AudioSender> audio_sender)
       : cast_environment_(cast_environment), audio_sender_(audio_sender) {}
 
-  void InsertAudio(scoped_ptr<AudioBus> audio_bus,
+  void InsertAudio(std::unique_ptr<AudioBus> audio_bus,
                    const base::TimeTicks& recorded_time) final {
     cast_environment_->PostTask(CastEnvironment::MAIN,
                                 FROM_HERE,
                                 base::Bind(&AudioSender::InsertAudio,
                                            audio_sender_,
                                            base::Passed(&audio_bus),
                                            recorded_time));
   }
 
  protected:
   ~LocalAudioFrameInput() final {}
 
  private:
   friend class base::RefCountedThreadSafe<LocalAudioFrameInput>;
 
   scoped_refptr<CastEnvironment> cast_environment_;
   base::WeakPtr<AudioSender> audio_sender_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalAudioFrameInput);
 };
 
-scoped_ptr<CastSender> CastSender::Create(
+std::unique_ptr<CastSender> CastSender::Create(
     scoped_refptr<CastEnvironment> cast_environment,
     CastTransport* const transport_sender) {
   CHECK(cast_environment.get());
-  return scoped_ptr<CastSender>(
+  return std::unique_ptr<CastSender>(
       new CastSenderImpl(cast_environment, transport_sender));
 }
 
 CastSenderImpl::CastSenderImpl(scoped_refptr<CastEnvironment> cast_environment,
                                CastTransport* const transport_sender)
     : cast_environment_(cast_environment),
       transport_sender_(transport_sender),
       weak_factory_(this) {
   CHECK(cast_environment.get());
 }
@@ skipping 87 matching lines @@
   DCHECK(cast_environment_->CurrentlyOn(CastEnvironment::MAIN));
   if (status == STATUS_INITIALIZED && !video_frame_input_) {
     video_frame_input_ =
         new LocalVideoFrameInput(cast_environment_, video_sender_->AsWeakPtr());
   }
   status_change_cb.Run(status);
 }
 
 }  // namespace cast
 }  // namespace media