Convert //remoting to use std::unique_ptr

remoting/test/protocol_perftest.cc

 // Copyright 2014 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 <utility>
 
 #include "base/base64.h"
 #include "base/files/file_util.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/base/test_data_directory.h"
 #include "net/url_request/url_request_context_getter.h"
@@ skipping 57 matching lines @@
 
 class FakeCursorShapeStub : public protocol::CursorShapeStub {
  public:
   FakeCursorShapeStub() {}
   ~FakeCursorShapeStub() override {}
 
   // protocol::CursorShapeStub interface.
   void SetCursorShape(const protocol::CursorShapeInfo& cursor_shape) override{};
 };
 
-scoped_ptr<webrtc::DesktopFrame> DoDecodeFrame(
+std::unique_ptr<webrtc::DesktopFrame> DoDecodeFrame(
     VideoDecoder* decoder,
     VideoPacket* packet,
-    scoped_ptr<webrtc::DesktopFrame> frame) {
+    std::unique_ptr<webrtc::DesktopFrame> frame) {
   if (!decoder->DecodePacket(*packet, frame.get()))
     frame.reset();
   return frame;
 }
 
 }  // namespace
 
 class ProtocolPerfTest
     : public testing::Test,
       public testing::WithParamInterface<NetworkPerformanceParams>,
@@ skipping 45 matching lines @@
   protocol::CursorShapeStub* GetCursorShapeStub() override {
     return &cursor_shape_stub_;
   }
 
   // VideoRenderer interface.
   void OnSessionConfig(const protocol::SessionConfig& config) override {}
   protocol::VideoStub* GetVideoStub() override { return this; }
   protocol::FrameConsumer* GetFrameConsumer() override { return this; }
 
   // protocol::VideoStub interface.
-  void ProcessVideoPacket(scoped_ptr<VideoPacket> packet,
+  void ProcessVideoPacket(std::unique_ptr<VideoPacket> packet,
                           const base::Closure& done) override {
     if (packet->data().empty()) {
       // Ignore keep-alive packets
       done.Run();
       return;
     }
 
     if (packet->format().has_screen_width() &&
         packet->format().has_screen_height()) {
       frame_size_.set(packet->format().screen_width(),
                       packet->format().screen_height());
     }
 
-    scoped_ptr<webrtc::DesktopFrame> frame(
+    std::unique_ptr<webrtc::DesktopFrame> frame(
         new webrtc::BasicDesktopFrame(frame_size_));
     base::PostTaskAndReplyWithResult(
         decode_thread_.task_runner().get(), FROM_HERE,
         base::Bind(&DoDecodeFrame, video_decoder_.get(), packet.get(),
                    base::Passed(&frame)),
         base::Bind(&ProtocolPerfTest::OnFrameDecoded, base::Unretained(this),
                    base::Passed(&packet), done));
   }
 
-  void OnFrameDecoded(scoped_ptr<VideoPacket> packet,
+  void OnFrameDecoded(std::unique_ptr<VideoPacket> packet,
                       const base::Closure& done,
-                      scoped_ptr<webrtc::DesktopFrame> frame) {
+                      std::unique_ptr<webrtc::DesktopFrame> frame) {
     last_video_packet_ = std::move(packet);
     DrawFrame(std::move(frame), done);
   }
 
   // protocol::FrameConsumer interface.
-  scoped_ptr<webrtc::DesktopFrame> AllocateFrame(
+  std::unique_ptr<webrtc::DesktopFrame> AllocateFrame(
       const webrtc::DesktopSize& size) override {
-    return make_scoped_ptr(new webrtc::BasicDesktopFrame(size));
+    return base::WrapUnique(new webrtc::BasicDesktopFrame(size));
   }
 
-  void DrawFrame(scoped_ptr<webrtc::DesktopFrame> frame,
+  void DrawFrame(std::unique_ptr<webrtc::DesktopFrame> frame,
                  const base::Closure& done) override {
     last_video_frame_ = std::move(frame);
     if (!on_frame_task_.is_null())
       on_frame_task_.Run();
     if (!done.is_null())
       done.Run();
   }
 
   protocol::FrameConsumer::PixelFormat GetPixelFormat() override {
     return FORMAT_BGRA;
@@ skipping 17 matching lines @@
 
     ASSERT_TRUE(client_connected_ && host_connected_);
   }
 
   void OnHostConnectedMainThread() {
     host_connected_ = true;
     if (client_connected_)
       connecting_loop_->Quit();
   }
 
-  scoped_ptr<webrtc::DesktopFrame> ReceiveFrame() {
+  std::unique_ptr<webrtc::DesktopFrame> ReceiveFrame() {
     last_video_frame_.reset();
 
     waiting_frames_loop_.reset(new base::RunLoop());
     on_frame_task_ = waiting_frames_loop_->QuitClosure();
     waiting_frames_loop_->Run();
 
     EXPECT_TRUE(last_video_frame_);
     return std::move(last_video_frame_);
   }
 
@@ skipping 66 matching lines @@
     DCHECK(host_thread_.task_runner()->BelongsToCurrentThread());
 
     jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
 
     host_signaling_.reset(new FakeSignalStrategy(kHostJid));
     host_signaling_->ConnectTo(client_signaling_.get());
 
     protocol::NetworkSettings network_settings(
         protocol::NetworkSettings::NAT_TRAVERSAL_OUTGOING);
 
-    scoped_ptr<FakePortAllocatorFactory> port_allocator_factory(
+    std::unique_ptr<FakePortAllocatorFactory> port_allocator_factory(
         new FakePortAllocatorFactory(fake_network_dispatcher_));
     port_allocator_factory->socket_factory()->SetBandwidth(
         GetParam().bandwidth, GetParam().max_buffers);
     port_allocator_factory->socket_factory()->SetLatency(
         GetParam().latency_average, GetParam().latency_stddev);
     port_allocator_factory->socket_factory()->set_out_of_order_rate(
         GetParam().out_of_order_rate);
     scoped_refptr<protocol::TransportContext> transport_context(
         new protocol::TransportContext(
             host_signaling_.get(), std::move(port_allocator_factory), nullptr,
             network_settings, protocol::TransportRole::SERVER));
-    scoped_ptr<protocol::SessionManager> session_manager(
+    std::unique_ptr<protocol::SessionManager> session_manager(
         new protocol::JingleSessionManager(host_signaling_.get()));
     session_manager->set_protocol_config(protocol_config_->Clone());
 
     // Encoder runs on a separate thread, main thread is used for everything
     // else.
     host_.reset(new ChromotingHost(
         &desktop_environment_factory_, std::move(session_manager),
         transport_context, host_thread_.task_runner(),
         encode_thread_.task_runner()));
 
     base::FilePath certs_dir(net::GetTestCertsDirectory());
 
     std::string host_cert;
     ASSERT_TRUE(base::ReadFileToString(
         certs_dir.AppendASCII("unittest.selfsigned.der"), &host_cert));
 
     base::FilePath key_path = certs_dir.AppendASCII("unittest.key.bin");
     std::string key_string;
     ASSERT_TRUE(base::ReadFileToString(key_path, &key_string));
     std::string key_base64;
     base::Base64Encode(key_string, &key_base64);
     scoped_refptr<RsaKeyPair> key_pair = RsaKeyPair::FromString(key_base64);
     ASSERT_TRUE(key_pair.get());
 
     std::string host_pin_hash =
         protocol::GetSharedSecretHash(kHostId, kHostPin);
-    scoped_ptr<protocol::AuthenticatorFactory> auth_factory =
+    std::unique_ptr<protocol::AuthenticatorFactory> auth_factory =
         protocol::Me2MeHostAuthenticatorFactory::CreateWithPin(
             true, kHostOwner, host_cert, key_pair, "", host_pin_hash, nullptr);
     host_->SetAuthenticatorFactory(std::move(auth_factory));
 
     host_->AddStatusObserver(this);
     host_->Start(kHostOwner);
 
     message_loop_.PostTask(FROM_HERE,
                            base::Bind(&ProtocolPerfTest::StartClientAfterHost,
                                       base::Unretained(this)));
   }
 
   void StartClientAfterHost() {
     client_signaling_->ConnectTo(host_signaling_.get());
 
     protocol::NetworkSettings network_settings(
         protocol::NetworkSettings::NAT_TRAVERSAL_OUTGOING);
 
     // Initialize client.
     client_context_.reset(
         new ClientContext(base::ThreadTaskRunnerHandle::Get()));
 
-    scoped_ptr<FakePortAllocatorFactory> port_allocator_factory(
+    std::unique_ptr<FakePortAllocatorFactory> port_allocator_factory(
         new FakePortAllocatorFactory(fake_network_dispatcher_));
     port_allocator_factory->socket_factory()->SetBandwidth(
         GetParam().bandwidth, GetParam().max_buffers);
     port_allocator_factory->socket_factory()->SetLatency(
         GetParam().latency_average, GetParam().latency_stddev);
     port_allocator_factory->socket_factory()->set_out_of_order_rate(
         GetParam().out_of_order_rate);
     scoped_refptr<protocol::TransportContext> transport_context(
         new protocol::TransportContext(
             host_signaling_.get(), std::move(port_allocator_factory), nullptr,
@@ skipping 28 matching lines @@
     StartHostAndClient(webrtc, protocol::ChannelConfig::CODEC_VP8);
     ASSERT_NO_FATAL_FAILURE(WaitConnected());
 
     base::TimeDelta total_latency_big_frames;
     int big_frame_count = 0;
     base::TimeDelta total_latency_small_frames;
     int small_frame_count = 0;
 
     int last_frame_id = -1;
     for (int i = 0; i < 30; ++i) {
-      scoped_ptr<webrtc::DesktopFrame> frame = ReceiveFrame();
+      std::unique_ptr<webrtc::DesktopFrame> frame = ReceiveFrame();
       test::CyclicFrameGenerator::FrameInfo frame_info =
           frame_generator->IdentifyFrame(frame.get());
       base::TimeDelta latency = base::TimeTicks::Now() - frame_info.timestamp;
 
       if (frame_info.frame_id > last_frame_id) {
         last_frame_id = frame_info.frame_id;
 
         switch (frame_info.type) {
           case test::CyclicFrameGenerator::FrameType::EMPTY:
             NOTREACHED();
@@ skipping 28 matching lines @@
   scoped_refptr<FakeNetworkDispatcher> fake_network_dispatcher_;
 
   base::Thread host_thread_;
   base::Thread capture_thread_;
   base::Thread encode_thread_;
   base::Thread decode_thread_;
   FakeDesktopEnvironmentFactory desktop_environment_factory_;
 
   FakeCursorShapeStub cursor_shape_stub_;
 
-  scoped_ptr<protocol::CandidateSessionConfig> protocol_config_;
+  std::unique_ptr<protocol::CandidateSessionConfig> protocol_config_;
 
-  scoped_ptr<FakeSignalStrategy> host_signaling_;
-  scoped_ptr<FakeSignalStrategy> client_signaling_;
+  std::unique_ptr<FakeSignalStrategy> host_signaling_;
+  std::unique_ptr<FakeSignalStrategy> client_signaling_;
 
-  scoped_ptr<ChromotingHost> host_;
-  scoped_ptr<ClientContext> client_context_;
-  scoped_ptr<ChromotingClient> client_;
+  std::unique_ptr<ChromotingHost> host_;
+  std::unique_ptr<ClientContext> client_context_;
+  std::unique_ptr<ChromotingClient> client_;
   webrtc::DesktopSize frame_size_;
-  scoped_ptr<VideoDecoder> video_decoder_;
+  std::unique_ptr<VideoDecoder> video_decoder_;
 
-  scoped_ptr<base::RunLoop> connecting_loop_;
-  scoped_ptr<base::RunLoop> waiting_frames_loop_;
+  std::unique_ptr<base::RunLoop> connecting_loop_;
+  std::unique_ptr<base::RunLoop> waiting_frames_loop_;
 
   bool client_connected_;
   bool host_connected_;
 
   base::Closure on_frame_task_;
 
-  scoped_ptr<VideoPacket> last_video_packet_;
-  scoped_ptr<webrtc::DesktopFrame> last_video_frame_;
+  std::unique_ptr<VideoPacket> last_video_packet_;
+  std::unique_ptr<webrtc::DesktopFrame> last_video_frame_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ProtocolPerfTest);
 };
 
 INSTANTIATE_TEST_CASE_P(
     NoDelay,
     ProtocolPerfTest,
     ::testing::Values(NetworkPerformanceParams(0, 0, 0, 0, 0.0)));
 
@@ skipping 46 matching lines @@
 
 // Frame generator that rewrites the whole screen every 60th frame. Should only
 // be used with the VERBATIM codec as the allocated frame may contain arbitrary
 // data.
 class IntermittentChangeFrameGenerator
     : public base::RefCountedThreadSafe<IntermittentChangeFrameGenerator> {
  public:
   IntermittentChangeFrameGenerator()
       : frame_index_(0) {}
 
-  scoped_ptr<webrtc::DesktopFrame> GenerateFrame(
+  std::unique_ptr<webrtc::DesktopFrame> GenerateFrame(
       webrtc::SharedMemoryFactory* shared_memory_factory) {
     const int kWidth = 1000;
     const int kHeight = kIntermittentFrameSize / kWidth / 4;
 
     bool fresh_frame = false;
     if (frame_index_ % 60 == 0 || !current_frame_) {
       current_frame_.reset(webrtc::SharedDesktopFrame::Wrap(
           new webrtc::BasicDesktopFrame(webrtc::DesktopSize(kWidth, kHeight))));
       fresh_frame = true;
     }
     ++frame_index_;
 
-    scoped_ptr<webrtc::DesktopFrame> result(current_frame_->Share());
+    std::unique_ptr<webrtc::DesktopFrame> result(current_frame_->Share());
     result->mutable_updated_region()->Clear();
     if (fresh_frame) {
       result->mutable_updated_region()->AddRect(
           webrtc::DesktopRect::MakeXYWH(0, 0, kWidth, kHeight));
     }
     return result;
   }
 
  private:
   ~IntermittentChangeFrameGenerator() {}
   friend class base::RefCountedThreadSafe<IntermittentChangeFrameGenerator>;
 
   int frame_index_;
-  scoped_ptr<webrtc::SharedDesktopFrame> current_frame_;
+  std::unique_ptr<webrtc::SharedDesktopFrame> current_frame_;
 
   DISALLOW_COPY_AND_ASSIGN(IntermittentChangeFrameGenerator);
 };
 
 TEST_P(ProtocolPerfTest, IntermittentChanges) {
   desktop_environment_factory_.set_frame_generator(
       base::Bind(&IntermittentChangeFrameGenerator::GenerateFrame,
                  new IntermittentChangeFrameGenerator()));
 
   StartHostAndClient(false, protocol::ChannelConfig::CODEC_VERBATIM);
@@ skipping 26 matching lines @@
 
 TEST_P(ProtocolPerfTest, TotalLatencyIce) {
   MeasureTotalLatency(false);
 }
 
 TEST_P(ProtocolPerfTest, TotalLatencyWebrtc) {
   MeasureTotalLatency(true);
 }
 
 }  // namespace remoting