Convert //remoting to use std::unique_ptr

remoting/client/plugin/chromoting_instance.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/client/plugin/chromoting_instance.h"
 
 #include <nacl_io/nacl_io.h>
 #include <sys/mount.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
 #include "base/values.h"
 #include "crypto/random.h"
 #include "jingle/glue/thread_wrapper.h"
 #include "net/socket/ssl_server_socket.h"
@@ skipping 151 matching lines @@
 
   // Resister this instance to handle debug log messsages.
   RegisterLoggingInstance();
 
   // Initialize random seed for libjingle. It's necessary only with OpenSSL.
   char random_seed[kRandomSeedSize];
   crypto::RandBytes(random_seed, sizeof(random_seed));
   rtc::InitRandom(random_seed, sizeof(random_seed));
 
   // Send hello message.
-  PostLegacyJsonMessage("hello", make_scoped_ptr(new base::DictionaryValue()));
+  PostLegacyJsonMessage("hello", base::WrapUnique(new base::DictionaryValue()));
 }
 
 ChromotingInstance::~ChromotingInstance() {
   DCHECK(plugin_task_runner_->BelongsToCurrentThread());
 
   // Disconnect the client.
   Disconnect();
 
   // Unregister this instance so that debug log messages will no longer be sent
   // to it. This will stop all logging in all Chromoting instances.
@@ skipping 16 matching lines @@
 
   return true;
 }
 
 void ChromotingInstance::HandleMessage(const pp::Var& message) {
   if (!message.is_string()) {
     LOG(ERROR) << "Received a message that is not a string.";
     return;
   }
 
-  scoped_ptr<base::Value> json = base::JSONReader::Read(
+  std::unique_ptr<base::Value> json = base::JSONReader::Read(
       message.AsString(), base::JSON_ALLOW_TRAILING_COMMAS);
   base::DictionaryValue* message_dict = nullptr;
   std::string method;
   base::DictionaryValue* data = nullptr;
   if (!json.get() ||
       !json->GetAsDictionary(&message_dict) ||
       !message_dict->GetString("method", &method) ||
       !message_dict->GetDictionary("data", &data)) {
     LOG(ERROR) << "Received invalid message:" << message.AsString();
     return;
@@ skipping 91 matching lines @@
   // Assume that the decoder failure was caused by the host not encoding video
   // correctly and report it as a protocol error.
   // TODO(sergeyu): Consider using a different error code in case the decoder
   // error was caused by some other problem.
   OnConnectionState(protocol::ConnectionToHost::FAILED,
                     protocol::INCOMPATIBLE_PROTOCOL);
 }
 
 void ChromotingInstance::OnVideoFirstFrameReceived() {
   PostLegacyJsonMessage("onFirstFrameReceived",
-                        make_scoped_ptr(new base::DictionaryValue()));
+                        base::WrapUnique(new base::DictionaryValue()));
 }
 
 void ChromotingInstance::OnVideoFrameDirtyRegion(
     const webrtc::DesktopRegion& dirty_region) {
-  scoped_ptr<base::ListValue> rects_value(new base::ListValue());
+  std::unique_ptr<base::ListValue> rects_value(new base::ListValue());
   for (webrtc::DesktopRegion::Iterator i(dirty_region); !i.IsAtEnd();
        i.Advance()) {
     const webrtc::DesktopRect& rect = i.rect();
-    scoped_ptr<base::ListValue> rect_value(new base::ListValue());
+    std::unique_ptr<base::ListValue> rect_value(new base::ListValue());
     rect_value->AppendInteger(rect.left());
     rect_value->AppendInteger(rect.top());
     rect_value->AppendInteger(rect.width());
     rect_value->AppendInteger(rect.height());
     rects_value->Append(rect_value.release());
   }
 
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->Set("rects", rects_value.release());
   PostLegacyJsonMessage("onDebugRegion", std::move(data));
 }
 
 void ChromotingInstance::OnConnectionState(
     protocol::ConnectionToHost::State state,
     protocol::ErrorCode error) {
   pp::UMAPrivate uma(this);
 
   switch (state) {
@@ skipping 38 matching lines @@
             kFailedSessionDurationHistogram,
             (base::TimeTicks::Now() - connection_connected_time_)
                 .InMilliseconds(),
             kConnectionDurationHistogramMinMinutes,
             kConnectionDurationHistogramMaxMinutes,
             kConnectionDurationHistogramBuckets);
       }
       break;
   }
 
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("state", protocol::ConnectionToHost::StateToString(state));
   data->SetString("error", ConnectionErrorToString(error));
   PostLegacyJsonMessage("onConnectionStatus", std::move(data));
 }
 
 void ChromotingInstance::FetchThirdPartyToken(
     const std::string& host_public_key,
     const std::string& token_url,
     const std::string& scope,
     const protocol::ThirdPartyTokenFetchedCallback& token_fetched_callback) {
   // Once the Session object calls this function, it won't continue the
   // authentication until the callback is called (or connection is canceled).
   // So, it's impossible to reach this with a callback already registered.
   DCHECK(third_party_token_fetched_callback_.is_null());
   third_party_token_fetched_callback_ = token_fetched_callback;
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("tokenUrl", token_url);
   data->SetString("hostPublicKey", host_public_key);
   data->SetString("scope", scope);
   PostLegacyJsonMessage("fetchThirdPartyToken", std::move(data));
 }
 
 void ChromotingInstance::OnConnectionReady(bool ready) {
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetBoolean("ready", ready);
   PostLegacyJsonMessage("onConnectionReady", std::move(data));
 }
 
 void ChromotingInstance::OnRouteChanged(const std::string& channel_name,
                                         const protocol::TransportRoute& route) {
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("channel", channel_name);
   data->SetString("connectionType",
                   protocol::TransportRoute::GetTypeString(route.type));
   PostLegacyJsonMessage("onRouteChanged", std::move(data));
 }
 
 void ChromotingInstance::SetCapabilities(const std::string& capabilities) {
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("capabilities", capabilities);
   PostLegacyJsonMessage("setCapabilities", std::move(data));
 }
 
 void ChromotingInstance::SetPairingResponse(
     const protocol::PairingResponse& pairing_response) {
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("clientId", pairing_response.client_id());
   data->SetString("sharedSecret", pairing_response.shared_secret());
   PostLegacyJsonMessage("pairingResponse", std::move(data));
 }
 
 void ChromotingInstance::DeliverHostMessage(
     const protocol::ExtensionMessage& message) {
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("type", message.type());
   data->SetString("data", message.data());
   PostLegacyJsonMessage("extensionMessage", std::move(data));
 }
 
 void ChromotingInstance::SetDesktopSize(const webrtc::DesktopSize& size,
                                         const webrtc::DesktopVector& dpi) {
   DCHECK(!dpi.is_zero());
 
   mouse_input_filter_.set_output_size(size);
   touch_input_scaler_.set_output_size(size);
 
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("width", size.width());
   data->SetInteger("height", size.height());
   data->SetInteger("x_dpi", dpi.x());
   data->SetInteger("y_dpi", dpi.y());
   PostLegacyJsonMessage("onDesktopSize", std::move(data));
 }
 
 void ChromotingInstance::FetchSecretFromDialog(
     bool pairing_supported,
     const protocol::SecretFetchedCallback& secret_fetched_callback) {
   // Once the Session object calls this function, it won't continue the
   // authentication until the callback is called (or connection is canceled).
   // So, it's impossible to reach this with a callback already registered.
   DCHECK(secret_fetched_callback_.is_null());
   secret_fetched_callback_ = secret_fetched_callback;
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetBoolean("pairingSupported", pairing_supported);
   PostLegacyJsonMessage("fetchPin", std::move(data));
 }
 
 void ChromotingInstance::FetchSecretFromString(
     const std::string& shared_secret,
     bool pairing_supported,
     const protocol::SecretFetchedCallback& secret_fetched_callback) {
   secret_fetched_callback.Run(shared_secret);
 }
 
 protocol::ClipboardStub* ChromotingInstance::GetClipboardStub() {
   // TODO(sergeyu): Move clipboard handling to a separate class.
   // crbug.com/138108
   return this;
 }
 
 protocol::CursorShapeStub* ChromotingInstance::GetCursorShapeStub() {
   return &empty_cursor_filter_;
 }
 
 void ChromotingInstance::InjectClipboardEvent(
     const protocol::ClipboardEvent& event) {
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("mimeType", event.mime_type());
   data->SetString("item", event.data());
   PostLegacyJsonMessage("injectClipboardItem", std::move(data));
 }
 
 void ChromotingInstance::SetCursorShape(
     const protocol::CursorShapeInfo& cursor_shape) {
   // If the delegated cursor is empty then stop rendering a DOM cursor.
   if (IsCursorShapeEmpty(cursor_shape)) {
     PostChromotingMessage("unsetCursorShape", pp::VarDictionary());
@@ skipping 114 matching lines @@
       base::Bind(&ChromotingInstance::UpdateUmaCustomHistogram,
                  weak_factory_.GetWeakPtr(), false),
       base::Bind(&ChromotingInstance::UpdateUmaEnumHistogram,
                  weak_factory_.GetWeakPtr()));
 
   if (!plugin_view_.is_null())
     video_renderer_->OnViewChanged(plugin_view_);
 
   client_.reset(
       new ChromotingClient(&context_, this, video_renderer_.get(),
-                           make_scoped_ptr(new PepperAudioPlayer(this))));
+                           base::WrapUnique(new PepperAudioPlayer(this))));
 
   // Setup the signal strategy.
   signal_strategy_.reset(new DelegatingSignalStrategy(
       local_jid, base::Bind(&ChromotingInstance::SendOutgoingIq,
                             weak_factory_.GetWeakPtr())));
 
   // Create TransportContext.
   scoped_refptr<protocol::TransportContext> transport_context(
       new protocol::TransportContext(
           signal_strategy_.get(),
-          make_scoped_ptr(new PepperPortAllocatorFactory(this)),
-          make_scoped_ptr(new PepperUrlRequestFactory(this)),
+          base::WrapUnique(new PepperPortAllocatorFactory(this)),
+          base::WrapUnique(new PepperUrlRequestFactory(this)),
           protocol::NetworkSettings(
               protocol::NetworkSettings::NAT_TRAVERSAL_FULL),
           protocol::TransportRole::CLIENT));
 
-  scoped_ptr<protocol::CandidateSessionConfig> config =
+  std::unique_ptr<protocol::CandidateSessionConfig> config =
       protocol::CandidateSessionConfig::CreateDefault();
   if (std::find(experiments_list.begin(), experiments_list.end(), "vp9") !=
       experiments_list.end()) {
     config->set_vp9_experiment_enabled(true);
   }
   client_->set_protocol_config(std::move(config));
 
   // Kick off the connection.
   client_->Start(signal_strategy_.get(), client_auth_config, transport_context,
                  host_jid, capabilities);
@@ skipping 287 matching lines @@
 void ChromotingInstance::PostChromotingMessage(const std::string& method,
                                                const pp::VarDictionary& data) {
   pp::VarDictionary message;
   message.Set(pp::Var("method"), pp::Var(method));
   message.Set(pp::Var("data"), data);
   PostMessage(message);
 }
 
 void ChromotingInstance::PostLegacyJsonMessage(
     const std::string& method,
-    scoped_ptr<base::DictionaryValue> data) {
+    std::unique_ptr<base::DictionaryValue> data) {
   base::DictionaryValue message;
   message.SetString("method", method);
   message.Set("data", data.release());
 
   std::string message_json;
   base::JSONWriter::Write(message, &message_json);
   PostMessage(pp::Var(message_json));
 }
 
 void ChromotingInstance::SendTrappedKey(uint32_t usb_keycode, bool pressed) {
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetInteger("usbKeycode", usb_keycode);
   data->SetBoolean("pressed", pressed);
   PostLegacyJsonMessage("trappedKeyEvent", std::move(data));
 }
 
 void ChromotingInstance::SendOutgoingIq(const std::string& iq) {
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetString("iq", iq);
   PostLegacyJsonMessage("sendOutgoingIq", std::move(data));
 }
 
 void ChromotingInstance::UpdatePerfStatsInUI() {
   // Fetch performance stats from the VideoRenderer and send them to the client
   // for display to users.
-  scoped_ptr<base::DictionaryValue> data(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> data(new base::DictionaryValue());
   data->SetDouble("videoBandwidth", perf_tracker_.video_bandwidth());
   data->SetDouble("videoFrameRate", perf_tracker_.video_frame_rate());
   data->SetDouble("captureLatency", perf_tracker_.video_capture_ms().Average());
   data->SetDouble("maxCaptureLatency", perf_tracker_.video_capture_ms().Max());
   data->SetDouble("encodeLatency", perf_tracker_.video_encode_ms().Average());
   data->SetDouble("maxEncodeLatency", perf_tracker_.video_encode_ms().Max());
   data->SetDouble("decodeLatency", perf_tracker_.video_decode_ms().Average());
   data->SetDouble("maxDecodeLatency", perf_tracker_.video_decode_ms().Max());
   data->SetDouble("renderLatency", perf_tracker_.video_paint_ms().Average());
   data->SetDouble("maxRenderLatency", perf_tracker_.video_paint_ms().Max());
@@ skipping 92 matching lines @@
   if (is_custom_counts_histogram) {
     uma.HistogramCustomCounts(histogram_name, value, histogram_min,
                               histogram_max, histogram_buckets);
   } else {
     uma.HistogramCustomTimes(histogram_name, value, histogram_min,
                              histogram_max, histogram_buckets);
   }
 }
 
 }  // namespace remoting