Convert //components/proximity_auth from scoped_ptr to std::unique_ptr

components/proximity_auth/webui/proximity_auth_webui_handler.cc

 // Copyright 2015 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 "components/proximity_auth/webui/proximity_auth_webui_handler.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/base64url.h"
 #include "base/bind.h"
 #include "base/i18n/time_formatting.h"
+#include "base/memory/ptr_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/time/default_clock.h"
 #include "base/time/default_tick_clock.h"
 #include "base/values.h"
 #include "components/prefs/pref_service.h"
 #include "components/proximity_auth/ble/pref_names.h"
 #include "components/proximity_auth/bluetooth_connection_finder.h"
 #include "components/proximity_auth/cryptauth/cryptauth_enrollment_manager.h"
 #include "components/proximity_auth/cryptauth/proto/cryptauth_api.pb.h"
 #include "components/proximity_auth/cryptauth/secure_message_delegate.h"
@@ skipping 21 matching lines @@
 
 // Keys in the JSON representation of a SyncState object for enrollment or
 // device sync.
 const char kSyncStateLastSuccessTime[] = "lastSuccessTime";
 const char kSyncStateNextRefreshTime[] = "nextRefreshTime";
 const char kSyncStateRecoveringFromFailure[] = "recoveringFromFailure";
 const char kSyncStateOperationInProgress[] = "operationInProgress";
 
 // Converts |log_message| to a raw dictionary value used as a JSON argument to
 // JavaScript functions.
-scoped_ptr<base::DictionaryValue> LogMessageToDictionary(
+std::unique_ptr<base::DictionaryValue> LogMessageToDictionary(
     const LogBuffer::LogMessage& log_message) {
-  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dictionary(
+      new base::DictionaryValue());
   dictionary->SetString(kLogMessageTextKey, log_message.text);
   dictionary->SetString(
       kLogMessageTimeKey,
       base::TimeFormatTimeOfDayWithMilliseconds(log_message.time));
   dictionary->SetString(kLogMessageFileKey, log_message.file);
   dictionary->SetInteger(kLogMessageLineKey, log_message.line);
   dictionary->SetInteger(kLogMessageSeverityKey,
                          static_cast<int>(log_message.severity));
   return dictionary;
 }
 
 // Keys in the JSON representation of an ExternalDeviceInfo proto.
 const char kExternalDevicePublicKey[] = "publicKey";
 const char kExternalDeviceFriendlyName[] = "friendlyDeviceName";
 const char kExternalDeviceBluetoothAddress[] = "bluetoothAddress";
 const char kExternalDeviceUnlockKey[] = "unlockKey";
 const char kExternalDeviceConnectionStatus[] = "connectionStatus";
 const char kExternalDeviceRemoteState[] = "remoteState";
 
 // The possible values of the |kExternalDeviceConnectionStatus| field.
 const char kExternalDeviceConnected[] = "connected";
 const char kExternalDeviceDisconnected[] = "disconnected";
 const char kExternalDeviceConnecting[] = "connecting";
 
 // Keys in the JSON representation of an IneligibleDevice proto.
 const char kIneligibleDeviceReasons[] = "ineligibilityReasons";
 
 // Creates a SyncState JSON object that can be passed to the WebUI.
-scoped_ptr<base::DictionaryValue> CreateSyncStateDictionary(
+std::unique_ptr<base::DictionaryValue> CreateSyncStateDictionary(
     double last_success_time,
     double next_refresh_time,
     bool is_recovering_from_failure,
     bool is_enrollment_in_progress) {
-  scoped_ptr<base::DictionaryValue> sync_state(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> sync_state(
+      new base::DictionaryValue());
   sync_state->SetDouble(kSyncStateLastSuccessTime, last_success_time);
   sync_state->SetDouble(kSyncStateNextRefreshTime, next_refresh_time);
   sync_state->SetBoolean(kSyncStateRecoveringFromFailure,
                          is_recovering_from_failure);
   sync_state->SetBoolean(kSyncStateOperationInProgress,
                          is_enrollment_in_progress);
   return sync_state;
 }
 
 }  // namespace
@@ skipping 52 matching lines @@
                                     base::Unretained(this)));
 
   web_ui()->RegisterMessageCallback(
       "toggleConnection",
       base::Bind(&ProximityAuthWebUIHandler::ToggleConnection,
                  base::Unretained(this)));
 }
 
 void ProximityAuthWebUIHandler::OnLogMessageAdded(
     const LogBuffer::LogMessage& log_message) {
-  scoped_ptr<base::DictionaryValue> dictionary =
+  std::unique_ptr<base::DictionaryValue> dictionary =
       LogMessageToDictionary(log_message);
   web_ui()->CallJavascriptFunction("LogBufferInterface.onLogMessageAdded",
                                    *dictionary);
 }
 
 void ProximityAuthWebUIHandler::OnLogBufferCleared() {
   web_ui()->CallJavascriptFunction("LogBufferInterface.onLogBufferCleared");
 }
 
 void ProximityAuthWebUIHandler::OnEnrollmentStarted() {
   web_ui()->CallJavascriptFunction(
       "LocalStateInterface.onEnrollmentStateChanged",
       *GetEnrollmentStateDictionary());
 }
 
 void ProximityAuthWebUIHandler::OnEnrollmentFinished(bool success) {
-  scoped_ptr<base::DictionaryValue> enrollment_state =
+  std::unique_ptr<base::DictionaryValue> enrollment_state =
       GetEnrollmentStateDictionary();
   PA_LOG(INFO) << "Enrollment attempt completed with success=" << success
                << ":\n" << *enrollment_state;
   web_ui()->CallJavascriptFunction(
       "LocalStateInterface.onEnrollmentStateChanged", *enrollment_state);
 }
 
 void ProximityAuthWebUIHandler::OnSyncStarted() {
   web_ui()->CallJavascriptFunction(
       "LocalStateInterface.onDeviceSyncStateChanged",
       *GetDeviceSyncStateDictionary());
 }
 
 void ProximityAuthWebUIHandler::OnSyncFinished(
     CryptAuthDeviceManager::SyncResult sync_result,
     CryptAuthDeviceManager::DeviceChangeResult device_change_result) {
-  scoped_ptr<base::DictionaryValue> device_sync_state =
+  std::unique_ptr<base::DictionaryValue> device_sync_state =
       GetDeviceSyncStateDictionary();
   PA_LOG(INFO) << "Device sync completed with result="
                << static_cast<int>(sync_result) << ":\n" << *device_sync_state;
   web_ui()->CallJavascriptFunction(
       "LocalStateInterface.onDeviceSyncStateChanged", *device_sync_state);
 
   if (device_change_result ==
       CryptAuthDeviceManager::DeviceChangeResult::CHANGED) {
-    scoped_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
+    std::unique_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
     PA_LOG(INFO) << "New unlock keys obtained after device sync:\n"
                  << *unlock_keys;
     web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
                                      *unlock_keys);
   }
 }
 
 void ProximityAuthWebUIHandler::OnWebContentsInitialized(
     const base::ListValue* args) {
   if (!web_contents_initialized_) {
@@ skipping 180 matching lines @@
   reachable_phone_flow_.reset();
   base::ListValue device_list;
   for (const auto& external_device : reachable_phones) {
     device_list.Append(ExternalDeviceInfoToDictionary(external_device));
   }
   web_ui()->CallJavascriptFunction("CryptAuthInterface.onGotReachableDevices",
                                    device_list);
 }
 
 void ProximityAuthWebUIHandler::GetLocalState(const base::ListValue* args) {
-  scoped_ptr<base::DictionaryValue> enrollment_state =
+  std::unique_ptr<base::DictionaryValue> enrollment_state =
       GetEnrollmentStateDictionary();
-  scoped_ptr<base::DictionaryValue> device_sync_state =
+  std::unique_ptr<base::DictionaryValue> device_sync_state =
       GetDeviceSyncStateDictionary();
-  scoped_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
+  std::unique_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
 
   PA_LOG(INFO) << "==== Got Local State ====\n"
                << "Enrollment State: \n" << *enrollment_state
                << "Device Sync State: \n" << *device_sync_state
                << "Unlock Keys: \n" << *unlock_keys;
   web_ui()->CallJavascriptFunction("LocalStateInterface.onGotLocalState",
                                    *enrollment_state, *device_sync_state,
                                    *unlock_keys);
 }
 
-scoped_ptr<base::DictionaryValue>
+std::unique_ptr<base::DictionaryValue>
 ProximityAuthWebUIHandler::GetEnrollmentStateDictionary() {
   CryptAuthEnrollmentManager* enrollment_manager =
       proximity_auth_client_->GetCryptAuthEnrollmentManager();
   if (!enrollment_manager)
-    return make_scoped_ptr(new base::DictionaryValue());
+    return base::WrapUnique(new base::DictionaryValue());
 
   return CreateSyncStateDictionary(
       enrollment_manager->GetLastEnrollmentTime().ToJsTime(),
       enrollment_manager->GetTimeToNextAttempt().InMillisecondsF(),
       enrollment_manager->IsRecoveringFromFailure(),
       enrollment_manager->IsEnrollmentInProgress());
 }
 
-scoped_ptr<base::DictionaryValue>
+std::unique_ptr<base::DictionaryValue>
 ProximityAuthWebUIHandler::GetDeviceSyncStateDictionary() {
   CryptAuthDeviceManager* device_manager =
       proximity_auth_client_->GetCryptAuthDeviceManager();
   if (!device_manager)
-    return make_scoped_ptr(new base::DictionaryValue());
+    return base::WrapUnique(new base::DictionaryValue());
 
   return CreateSyncStateDictionary(
       device_manager->GetLastSyncTime().ToJsTime(),
       device_manager->GetTimeToNextAttempt().InMillisecondsF(),
       device_manager->IsRecoveringFromFailure(),
       device_manager->IsSyncInProgress());
 }
 
-scoped_ptr<base::ListValue> ProximityAuthWebUIHandler::GetUnlockKeysList() {
-  scoped_ptr<base::ListValue> unlock_keys(new base::ListValue());
+std::unique_ptr<base::ListValue>
+ProximityAuthWebUIHandler::GetUnlockKeysList() {
+  std::unique_ptr<base::ListValue> unlock_keys(new base::ListValue());
   CryptAuthDeviceManager* device_manager =
       proximity_auth_client_->GetCryptAuthDeviceManager();
   if (!device_manager)
     return unlock_keys;
 
   for (const auto& unlock_key : device_manager->unlock_keys()) {
     unlock_keys->Append(ExternalDeviceInfoToDictionary(unlock_key));
   }
 
   return unlock_keys;
 }
 
 void ProximityAuthWebUIHandler::OnRemoteDevicesLoaded(
     const std::vector<RemoteDevice>& remote_devices) {
   if (remote_devices[0].persistent_symmetric_key.empty()) {
     PA_LOG(ERROR) << "Failed to derive PSK.";
     return;
   }
 
   selected_remote_device_ = remote_devices[0];
   life_cycle_.reset(new RemoteDeviceLifeCycleImpl(selected_remote_device_,
                                                   proximity_auth_client_));
   life_cycle_->AddObserver(this);
   life_cycle_->Start();
 }
 
-scoped_ptr<base::DictionaryValue>
+std::unique_ptr<base::DictionaryValue>
 ProximityAuthWebUIHandler::ExternalDeviceInfoToDictionary(
     const cryptauth::ExternalDeviceInfo& device_info) {
   std::string base64_public_key;
   base::Base64UrlEncode(device_info.public_key(),
                         base::Base64UrlEncodePolicy::INCLUDE_PADDING,
                         &base64_public_key);
 
   // Set the fields in the ExternalDeviceInfo proto.
-  scoped_ptr<base::DictionaryValue> dictionary(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> dictionary(
+      new base::DictionaryValue());
   dictionary->SetString(kExternalDevicePublicKey, base64_public_key);
   dictionary->SetString(kExternalDeviceFriendlyName,
                         device_info.friendly_device_name());
   dictionary->SetString(kExternalDeviceBluetoothAddress,
                         device_info.bluetooth_address());
   dictionary->SetBoolean(kExternalDeviceUnlockKey, device_info.unlock_key());
   dictionary->SetString(kExternalDeviceConnectionStatus,
                         kExternalDeviceDisconnected);
 
   CryptAuthDeviceManager* device_manager =
@@ skipping 22 matching lines @@
       life_cycle_->GetState() ==
           RemoteDeviceLifeCycle::State::SECURE_CHANNEL_ESTABLISHED) {
     connection_status = kExternalDeviceConnected;
   } else if (life_cycle_) {
     connection_status = kExternalDeviceConnecting;
   }
   dictionary->SetString(kExternalDeviceConnectionStatus, connection_status);
 
   // Fill the remote status dictionary.
   if (last_remote_status_update_) {
-    scoped_ptr<base::DictionaryValue> status_dictionary(
+    std::unique_ptr<base::DictionaryValue> status_dictionary(
         new base::DictionaryValue());
     status_dictionary->SetInteger("userPresent",
                                   last_remote_status_update_->user_presence);
     status_dictionary->SetInteger(
         "secureScreenLock",
         last_remote_status_update_->secure_screen_lock_state);
     status_dictionary->SetInteger(
         "trustAgent", last_remote_status_update_->trust_agent_state);
     dictionary->Set(kExternalDeviceRemoteState, std::move(status_dictionary));
   }
 
   return dictionary;
 }
 
-scoped_ptr<base::DictionaryValue>
+std::unique_ptr<base::DictionaryValue>
 ProximityAuthWebUIHandler::IneligibleDeviceToDictionary(
     const cryptauth::IneligibleDevice& ineligible_device) {
-  scoped_ptr<base::ListValue> ineligibility_reasons(new base::ListValue());
+  std::unique_ptr<base::ListValue> ineligibility_reasons(new base::ListValue());
   for (const std::string& reason : ineligible_device.reasons()) {
     ineligibility_reasons->AppendString(reason);
   }
 
-  scoped_ptr<base::DictionaryValue> device_dictionary =
+  std::unique_ptr<base::DictionaryValue> device_dictionary =
       ExternalDeviceInfoToDictionary(ineligible_device.device());
   device_dictionary->Set(kIneligibleDeviceReasons,
                          std::move(ineligibility_reasons));
   return device_dictionary;
 }
 
 void ProximityAuthWebUIHandler::CleanUpRemoteDeviceLifeCycle() {
   PA_LOG(INFO) << "Cleaning up connection to " << selected_remote_device_.name
                << " [" << selected_remote_device_.bluetooth_address << "]";
   life_cycle_.reset();
@@ skipping 30 matching lines @@
     const RemoteStatusUpdate& status_update) {
   PA_LOG(INFO) << "Remote status update:"
                << "\n  user_presence: "
                << static_cast<int>(status_update.user_presence)
                << "\n  secure_screen_lock_state: "
                << static_cast<int>(status_update.secure_screen_lock_state)
                << "\n  trust_agent_state: "
                << static_cast<int>(status_update.trust_agent_state);
 
   last_remote_status_update_.reset(new RemoteStatusUpdate(status_update));
-  scoped_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
+  std::unique_ptr<base::ListValue> unlock_keys = GetUnlockKeysList();
   web_ui()->CallJavascriptFunction("LocalStateInterface.onUnlockKeysChanged",
                                    *unlock_keys);
 }
 
 }  // namespace proximity_auth