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

components/wifi_sync/wifi_credential_syncable_service_unittest.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/wifi_sync/wifi_credential_syncable_service.h"
 
 #include <stdint.h>
+
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
+#include "base/memory/ptr_util.h"
 #include "base/time/time.h"
 #include "base/tracked_objects.h"
 #include "components/wifi_sync/wifi_config_delegate.h"
 #include "components/wifi_sync/wifi_credential.h"
 #include "components/wifi_sync/wifi_security_class.h"
 #include "sync/api/attachments/attachment_id.h"
 #include "sync/api/fake_sync_change_processor.h"
 #include "sync/api/sync_change.h"
 #include "sync/api/sync_data.h"
 #include "sync/api/sync_error.h"
@@ skipping 36 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(FakeWifiConfigDelegate);
 };
 
 // Unit tests for WifiCredentialSyncableService.
 class WifiCredentialSyncableServiceTest : public testing::Test {
  protected:
   WifiCredentialSyncableServiceTest()
       : config_delegate_(new FakeWifiConfigDelegate()),
         change_processor_(nullptr) {
     syncable_service_.reset(
-        new WifiCredentialSyncableService(make_scoped_ptr(config_delegate_)));
+        new WifiCredentialSyncableService(base::WrapUnique(config_delegate_)));
   }
 
   // Wrappers for methods in WifiCredentialSyncableService.
   syncer::SyncError ProcessSyncChanges(
       const syncer::SyncChangeList& change_list) {
     return syncable_service_->ProcessSyncChanges(FROM_HERE, change_list);
   }
   bool AddToSyncedNetworks(const std::string& item_id,
                            const WifiCredential& credential) {
     return syncable_service_->AddToSyncedNetworks(item_id, credential);
   }
 
   // Returns the number of change requests received by
   // |change_processor_|.
   int change_processor_changes_size() {
     CHECK(change_processor_);
     return change_processor_->changes().size();
   }
 
   // Returns the number of times AddToLocalNetworks has been called on
   // |config_delegate_|.
   unsigned int config_delegate_add_count() {
     return config_delegate_->add_count();
   }
 
   // Returns a new WifiCredential constructed from the given parameters.
   WifiCredential MakeCredential(const std::string& ssid,
                                 WifiSecurityClass security_class,
                                 const std::string& passphrase) {
-    scoped_ptr<WifiCredential> credential = WifiCredential::Create(
+    std::unique_ptr<WifiCredential> credential = WifiCredential::Create(
         WifiCredential::MakeSsidBytesForTest(ssid), security_class, passphrase);
     CHECK(credential);
     return *credential;
   }
 
   // Returns a new EntitySpecifics protobuf, with the
   // wifi_credential_specifics fields populated with the given
   // parameters.
   sync_pb::EntitySpecifics MakeWifiCredentialSpecifics(
       const std::string& ssid,
@@ skipping 21 matching lines @@
     return syncer::SyncChange(
         FROM_HERE, syncer::SyncChange::ACTION_ADD,
         syncer::SyncData::CreateRemoteData(
             sync_item_id,
             MakeWifiCredentialSpecifics(ssid, security_class, passphrase),
             base::Time(), syncer::AttachmentIdList(),
             syncer::AttachmentServiceProxyForTest::Create()));
   }
 
   void StartSyncing() {
-    scoped_ptr<FakeSyncChangeProcessor> change_processor(
+    std::unique_ptr<FakeSyncChangeProcessor> change_processor(
         new FakeSyncChangeProcessor());
     change_processor_ = change_processor.get();
     syncable_service_->MergeDataAndStartSyncing(
         syncer::WIFI_CREDENTIALS, syncer::SyncDataList(),
         std::move(change_processor),
-        make_scoped_ptr(new SyncErrorFactoryMock()));
+        base::WrapUnique(new SyncErrorFactoryMock()));
   }
 
  private:
-  scoped_ptr<WifiCredentialSyncableService> syncable_service_;
+  std::unique_ptr<WifiCredentialSyncableService> syncable_service_;
   FakeWifiConfigDelegate* config_delegate_;    // Owned by |syncable_service_|
   FakeSyncChangeProcessor* change_processor_;  // Owned by |syncable_service_|
 
   DISALLOW_COPY_AND_ASSIGN(WifiCredentialSyncableServiceTest);
 };
 
 }  // namespace
 
 TEST_F(WifiCredentialSyncableServiceTest, ProcessSyncChangesNotStarted) {
   syncer::SyncError sync_error(ProcessSyncChanges(syncer::SyncChangeList()));
@@ skipping 170 matching lines @@
           MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, "")));
   EXPECT_EQ(1, change_processor_changes_size());
   EXPECT_FALSE(
       AddToSyncedNetworks(
           "fake-item-id",
           MakeCredential(kSsidNonUtf8, SECURITY_CLASS_NONE, "")));
   EXPECT_EQ(1, change_processor_changes_size());
 }
 
 }  // namespace wifi_sync