Convert //chrome/browser/chromeos from scoped_ptr to std::unique_ptr

chrome/browser/chromeos/policy/network_configuration_updater_unittest.cc

 // Copyright 2013 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 <stddef.h>
+
+#include <memory>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/policy/device_network_configuration_updater.h"
 #include "chrome/browser/chromeos/policy/user_network_configuration_updater.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/settings/scoped_cros_settings_test_helper.h"
 #include "chrome/test/base/testing_profile.h"
 #include "chromeos/network/fake_network_device_handler.h"
 #include "chromeos/network/mock_managed_network_configuration_handler.h"
 #include "chromeos/network/onc/onc_certificate_importer.h"
@@ skipping 111 matching lines @@
     if (expected_onc_certificates_) {
       EXPECT_TRUE(chromeos::onc::test_utils::Equals(
           expected_onc_certificates_.get(), &certificates));
     }
     ++call_count_;
     done_callback.Run(true, onc_trusted_certificates_);
   }
 
  private:
   ::onc::ONCSource expected_onc_source_;
-  scoped_ptr<base::ListValue> expected_onc_certificates_;
+  std::unique_ptr<base::ListValue> expected_onc_certificates_;
   net::CertificateList onc_trusted_certificates_;
   unsigned int call_count_;
 
   DISALLOW_COPY_AND_ASSIGN(FakeCertificateImporter);
 };
 
 const char kFakeONC[] =
     "{ \"NetworkConfigurations\": ["
     "    { \"GUID\": \"{485d6076-dd44-6b6d-69787465725f5040}\","
     "      \"Type\": \"WiFi\","
@@ skipping 52 matching lines @@
   NetworkConfigurationUpdaterTest() : certificate_importer_(NULL) {}
 
   void SetUp() override {
     EXPECT_CALL(provider_, IsInitializationComplete(_))
         .WillRepeatedly(Return(false));
     provider_.Init();
     PolicyServiceImpl::Providers providers;
     providers.push_back(&provider_);
     policy_service_.reset(new PolicyServiceImpl(providers));
 
-    scoped_ptr<base::DictionaryValue> fake_toplevel_onc =
+    std::unique_ptr<base::DictionaryValue> fake_toplevel_onc =
         chromeos::onc::ReadDictionaryFromJson(kFakeONC);
 
     base::ListValue* network_configs = NULL;
     fake_toplevel_onc->GetListWithoutPathExpansion(
         onc::toplevel_config::kNetworkConfigurations, &network_configs);
     AppendAll(*network_configs, &fake_network_configs_);
 
     base::DictionaryValue* global_config = NULL;
     fake_toplevel_onc->GetDictionaryWithoutPathExpansion(
         onc::toplevel_config::kGlobalNetworkConfiguration, &global_config);
@@ skipping 63 matching lines @@
   StrictMock<chromeos::MockManagedNetworkConfigurationHandler>
       network_config_handler_;
   FakeNetworkDeviceHandler network_device_handler_;
   chromeos::ScopedCrosSettingsTestHelper settings_helper_;
 
   // Ownership of certificate_importer_owned_ is passed to the
   // NetworkConfigurationUpdater. When that happens, |certificate_importer_|
   // continues to point to that instance but |certificate_importer_owned_| is
   // released.
   FakeCertificateImporter* certificate_importer_;
-  scoped_ptr<chromeos::onc::CertificateImporter> certificate_importer_owned_;
+  std::unique_ptr<chromeos::onc::CertificateImporter>
+      certificate_importer_owned_;
 
   StrictMock<MockConfigurationPolicyProvider> provider_;
-  scoped_ptr<PolicyServiceImpl> policy_service_;
+  std::unique_ptr<PolicyServiceImpl> policy_service_;
   FakeUser fake_user_;
 
   TestingProfile profile_;
 
-  scoped_ptr<NetworkConfigurationUpdater> network_configuration_updater_;
+  std::unique_ptr<NetworkConfigurationUpdater> network_configuration_updater_;
   content::TestBrowserThreadBundle thread_bundle_;
 };
 
 TEST_F(NetworkConfigurationUpdaterTest, CellularAllowRoaming) {
   // Ignore network config updates.
   EXPECT_CALL(network_config_handler_, SetPolicy(_, _, _, _)).Times(AtLeast(1));
 
   settings_helper_.ReplaceProvider(chromeos::kSignedDataRoamingEnabled);
   settings_helper_.SetBoolean(chromeos::kSignedDataRoamingEnabled, false);
   EXPECT_FALSE(network_device_handler_.allow_roaming_);
 
   CreateNetworkConfigurationUpdaterForDevicePolicy();
   MarkPolicyProviderInitialized();
   settings_helper_.SetBoolean(chromeos::kSignedDataRoamingEnabled, true);
   EXPECT_TRUE(network_device_handler_.allow_roaming_);
 
   settings_helper_.SetBoolean(chromeos::kSignedDataRoamingEnabled, false);
   EXPECT_FALSE(network_device_handler_.allow_roaming_);
 }
 
 TEST_F(NetworkConfigurationUpdaterTest, PolicyIsValidatedAndRepaired) {
-  scoped_ptr<base::DictionaryValue> onc_repaired =
+  std::unique_ptr<base::DictionaryValue> onc_repaired =
       chromeos::onc::test_utils::ReadTestDictionary(
           "repaired_toplevel_partially_invalid.onc");
 
   base::ListValue* network_configs_repaired = NULL;
   onc_repaired->GetListWithoutPathExpansion(
       onc::toplevel_config::kNetworkConfigurations, &network_configs_repaired);
   ASSERT_TRUE(network_configs_repaired);
 
   base::DictionaryValue* global_config_repaired = NULL;
   onc_repaired->GetDictionaryWithoutPathExpansion(
@@ skipping 324 matching lines @@
   EXPECT_EQ(ExpectedImportCertificatesCallCount(),
             certificate_importer_->GetAndResetImportCount());
 }
 
 INSTANTIATE_TEST_CASE_P(NetworkConfigurationUpdaterTestWithParamInstance,
                         NetworkConfigurationUpdaterTestWithParam,
                         testing::Values(key::kDeviceOpenNetworkConfiguration,
                                         key::kOpenNetworkConfiguration));
 
 }  // namespace policy