Convert //components/[u-z]* from scoped_ptr to std::unique_ptr

components/wifi_sync/wifi_credential_syncable_service.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 "components/wifi_sync/wifi_credential_syncable_service.h"
 
 #include <stdint.h>
 #include <utility>
 #include <vector>
 
@@ skipping 89 matching lines @@
 
   return ParseSpecifics(sync_data.GetSpecifics(), raw_credential);
 }
 
 }  // namespace
 
 const syncer::ModelType WifiCredentialSyncableService::kModelType =
     syncer::WIFI_CREDENTIALS;
 
 WifiCredentialSyncableService::WifiCredentialSyncableService(
-    scoped_ptr<WifiConfigDelegate> network_config_delegate)
+    std::unique_ptr<WifiConfigDelegate> network_config_delegate)
     : network_config_delegate_(std::move(network_config_delegate)) {
   DCHECK(network_config_delegate_);
 }
 
 WifiCredentialSyncableService::~WifiCredentialSyncableService() {
 }
 
 syncer::SyncMergeResult WifiCredentialSyncableService::MergeDataAndStartSyncing(
     syncer::ModelType type,
     const syncer::SyncDataList& initial_sync_data,
-    scoped_ptr<syncer::SyncChangeProcessor> sync_processor,
-    scoped_ptr<syncer::SyncErrorFactory> /* error_handler */) {
+    std::unique_ptr<syncer::SyncChangeProcessor> sync_processor,
+    std::unique_ptr<syncer::SyncErrorFactory> /* error_handler */) {
   DCHECK(!sync_processor_.get());
   DCHECK(sync_processor.get());
   DCHECK_EQ(kModelType, type);
 
   sync_processor_ = std::move(sync_processor);
 
   // TODO(quiche): Update local WiFi configuration from |initial_sync_data|.
   // TODO(quiche): Notify upper layers that sync is ready.
   NOTIMPLEMENTED();
 
@@ skipping 25 matching lines @@
   for (const syncer::SyncChange& sync_change : change_list) {
     DCHECK(sync_change.IsValid());
     RawCredentialData raw_credential;
     if (!ParseSyncData(sync_change.sync_data(), &raw_credential)) {
       LOG(WARNING) << "Failed to parse item; skipping "
                    << syncer::SyncChange::ChangeTypeToString(
                           sync_change.change_type());
       continue;
     }
 
-    scoped_ptr<WifiCredential> credential;
+    std::unique_ptr<WifiCredential> credential;
     switch (sync_change.change_type()) {
       case syncer::SyncChange::ACTION_ADD:
         credential = WifiCredential::Create(raw_credential.ssid,
                                             raw_credential.security_class,
                                             raw_credential.passphrase);
         if (!credential)
           LOG(WARNING) << "Failed to create credential; skipping";
         else
           network_config_delegate_->AddToLocalNetworks(*credential);
         break;
@@ skipping 46 matching lines @@
   if (sync_error.IsSet()) {
     LOG(ERROR) << sync_error.ToString();
     return false;
   }
 
   synced_networks_and_passphrases_[network_id] = credential.passphrase();
   return true;
 }
 
 }  // namespace wifi_sync