WebRTC's scoped_ptr and scoped_ptr.h are going away, so stop using them

remoting/host/desktop_session_agent.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 "remoting/host/desktop_session_agent.h"
 
 #include <utility>
 
 #include "base/files/file_util.h"
 #include "base/logging.h"
@@ skipping 99 matching lines @@
 };
 
 class SharedMemoryFactoryImpl : public webrtc::SharedMemoryFactory {
  public:
   typedef base::Callback<void(std::unique_ptr<IPC::Message> message)>
       SendMessageCallback;
 
   SharedMemoryFactoryImpl(const SendMessageCallback& send_message_callback)
       : send_message_callback_(send_message_callback) {}
 
-  rtc::scoped_ptr<webrtc::SharedMemory> CreateSharedMemory(
+  std::unique_ptr<webrtc::SharedMemory> CreateSharedMemory(
       size_t size) override {
     base::Closure release_buffer_callback =
         base::Bind(send_message_callback_,
                    base::Passed(base::WrapUnique(
                        new ChromotingDesktopNetworkMsg_ReleaseSharedBuffer(
                            next_shared_buffer_id_))));
     std::unique_ptr<SharedMemoryImpl> buffer = SharedMemoryImpl::Create(
         size, next_shared_buffer_id_, release_buffer_callback);
     if (buffer) {
       // |next_shared_buffer_id_| starts from 1 and incrementing it by 2 makes
       // sure it is always odd and therefore zero is never used as a valid
       // buffer ID.
       //
       // It is very unlikely (though theoretically possible) to allocate the
       // same ID for two different buffers due to integer overflow. It should
       // take about a year of allocating 100 new buffers every second.
       // Practically speaking it never happens.
       next_shared_buffer_id_ += 2;
 
       send_message_callback_.Run(
           base::WrapUnique(new ChromotingDesktopNetworkMsg_CreateSharedBuffer(
               buffer->id(), buffer->shared_memory()->handle(),
               buffer->size())));
     }
 
-    return rtc::scoped_ptr<webrtc::SharedMemory>(buffer.release());
+    return std::move(buffer);
   }
 
  private:
   int next_shared_buffer_id_ = 1;
   SendMessageCallback send_message_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedMemoryFactoryImpl);
 };
 
 }  // namespace
@@ skipping 151 matching lines @@
   if (delegate_->desktop_environment_factory().SupportsAudioCapture()) {
     audio_capturer_ = desktop_environment_->CreateAudioCapturer();
     audio_capture_task_runner_->PostTask(
         FROM_HERE, base::Bind(&DesktopSessionAgent::StartAudioCapturer, this));
   }
 
   // Start the video capturer and mouse cursor monitor.
   video_capturer_ = desktop_environment_->CreateVideoCapturer();
   video_capturer_->Start(this);
   video_capturer_->SetSharedMemoryFactory(
-      rtc::scoped_ptr<webrtc::SharedMemoryFactory>(new SharedMemoryFactoryImpl(
+      std::unique_ptr<webrtc::SharedMemoryFactory>(new SharedMemoryFactoryImpl(
           base::Bind(&DesktopSessionAgent::SendToNetwork, this))));
   mouse_cursor_monitor_ = desktop_environment_->CreateMouseCursorMonitor();
   mouse_cursor_monitor_->Init(this, webrtc::MouseCursorMonitor::SHAPE_ONLY);
 }
 
 void DesktopSessionAgent::OnCaptureCompleted(webrtc::DesktopFrame* frame) {
   DCHECK(caller_task_runner_->BelongsToCurrentThread());
 
   last_frame_.reset(frame);
 
@@ skipping 249 matching lines @@
   }
 }
 
 void DesktopSessionAgent::StopAudioCapturer() {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
 
   audio_capturer_.reset();
 }
 
 }  // namespace remoting