Stop using rtc_make_scoped_ptr

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 124 matching lines @@
       // 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_make_scoped_ptr(buffer.release());
+    return rtc::scoped_ptr<webrtc::SharedMemory>(buffer.release());

[tommi, 2016/04/25 10:24:22]

looks like CreateSharedMemory is only being called from two places and in both
of those places, there's a workaround to translate the return value from
scoped_ptr to std::unique_ptr.  Can we just change the return type and return
buffer here?

[kwiberg-chromium, 2016/04/25 10:41:59]

We could, but changing the return value of an interface function that's used by
WebRTC clients is a multi-step process if we want to give the clients the option
to avoid going through broken states (which we do).

But if we just do what I suggest in this patch set, the problem will go away
naturally, since the WebRTC CL I'm planning to land this week will turn
rtc::scoped pointer into a type alias for std::unique_ptr. After that, what you
asked for (webrtc::SharedMemoryFactory::CreateSharedMemory returning a
std::unique_ptr) will have effectively happened, and call sites such as this one
will be free to just return their unique_ptrs directly. (A simplification that's
actually very likely to happen, given that two weeks later, I'll remove the
rtc::scoped_ptr name entirely, so I'll need to fix all lines that mention it.)

[tommi, 2016/04/25 12:30:26]

ok, sgtm

   }
 
  private:
   int next_shared_buffer_id_ = 1;
   SendMessageCallback send_message_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SharedMemoryFactoryImpl);
 };
 
 }  // namespace
@@ skipping 147 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_make_scoped_ptr(new SharedMemoryFactoryImpl(
+      rtc::scoped_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 245 matching lines @@
   }
 }
 
 void DesktopSessionAgent::StopAudioCapturer() {
   DCHECK(audio_capture_task_runner_->BelongsToCurrentThread());
 
   audio_capturer_.reset();
 }
 
 }  // namespace remoting