Convert //third_party from scoped_ptr to std::unique_ptr

third_party/libaddressinput/chromium/chrome_address_validator_unittest.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 "third_party/libaddressinput/chromium/chrome_address_validator.h"
 
 #include <stddef.h>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 36 matching lines @@
 using ::i18n::addressinput::INVALID_FORMAT;
 using ::i18n::addressinput::MISMATCHING_VALUE;
 using ::i18n::addressinput::MISSING_REQUIRED_FIELD;
 using ::i18n::addressinput::UNEXPECTED_FIELD;
 using ::i18n::addressinput::UNKNOWN_VALUE;
 using ::i18n::addressinput::USES_P_O_BOX;
 
 class AddressValidatorTest : public testing::Test, LoadRulesListener {
  protected:
   AddressValidatorTest()
-      : validator_(
-            new AddressValidator(scoped_ptr<Source>(new TestdataSource(true)),
-                                 scoped_ptr<Storage>(new NullStorage),
-                                 this)) {
+      : validator_(new AddressValidator(
+            std::unique_ptr<Source>(new TestdataSource(true)),
+            std::unique_ptr<Storage>(new NullStorage),
+            this)) {
     validator_->LoadRules("US");
   }
 
   virtual ~AddressValidatorTest() {}
 
-  const scoped_ptr<AddressValidator> validator_;
+  const std::unique_ptr<AddressValidator> validator_;
 
  private:
   // LoadRulesListener implementation.
   virtual void OnAddressValidationRulesLoaded(const std::string& country_code,
                                               bool success) override {
     AddressData address_data;
     address_data.region_code = country_code;
     FieldProblemMap dummy;
     AddressValidator::Status status =
         validator_->ValidateAddress(address_data, NULL, &dummy);
     ASSERT_EQ(success, status == AddressValidator::SUCCESS);
   }
 
   DISALLOW_COPY_AND_ASSIGN(AddressValidatorTest);
 };
 
 // Use this test fixture if you're going to use a region with a large set of
 // validation rules. All rules should be loaded in SetUpTestCase().
 class LargeAddressValidatorTest : public testing::Test {
  protected:
   LargeAddressValidatorTest() {}
   virtual ~LargeAddressValidatorTest() {}
 
   static void SetUpTestCase() {
     validator_ =
-        new AddressValidator(scoped_ptr<Source>(new TestdataSource(true)),
-                             scoped_ptr<Storage>(new NullStorage),
-                             NULL);
+        new AddressValidator(std::unique_ptr<Source>(new TestdataSource(true)),
+                             std::unique_ptr<Storage>(new NullStorage), NULL);
     validator_->LoadRules("CN");
     validator_->LoadRules("KR");
     validator_->LoadRules("TW");
   }
 
   static void TearDownTestcase() {
     delete validator_;
     validator_ = NULL;
   }
 
@@ skipping 628 matching lines @@
 }
 
 // Use this test fixture for configuring the number of failed attempts to load
 // rules.
 class FailingAddressValidatorTest : public testing::Test, LoadRulesListener {
  protected:
   // A validator that retries loading rules without delay.
   class TestAddressValidator : public AddressValidator {
    public:
     // Takes ownership of |source| and |storage|.
-    TestAddressValidator(scoped_ptr<::i18n::addressinput::Source> source,
-                         scoped_ptr<::i18n::addressinput::Storage> storage,
+    TestAddressValidator(std::unique_ptr<::i18n::addressinput::Source> source,
+                         std::unique_ptr<::i18n::addressinput::Storage> storage,
                          LoadRulesListener* load_rules_listener)
         : AddressValidator(std::move(source),
                            std::move(storage),
                            load_rules_listener) {}
 
     virtual ~TestAddressValidator() {}
 
    protected:
     virtual base::TimeDelta GetBaseRetryPeriod() const override {
       return base::TimeDelta::FromSeconds(0);
@@ skipping 40 matching lines @@
 
     // The source to use for successful downloads.
     TestdataSource actual_source_;
 
     DISALLOW_COPY_AND_ASSIGN(FailingSource);
   };
 
   FailingAddressValidatorTest()
       : source_(new FailingSource),
         validator_(
-            new TestAddressValidator(scoped_ptr<Source>(source_),
-                                     scoped_ptr<Storage>(new NullStorage),
+            new TestAddressValidator(std::unique_ptr<Source>(source_),
+                                     std::unique_ptr<Storage>(new NullStorage),
                                      this)),
         load_rules_success_(false) {}
 
   virtual ~FailingAddressValidatorTest() {}
 
   FailingSource* source_;  // Owned by |validator_|.
-  scoped_ptr<AddressValidator> validator_;
+  std::unique_ptr<AddressValidator> validator_;
   bool load_rules_success_;
 
  private:
   // LoadRulesListener implementation.
   virtual void OnAddressValidationRulesLoaded(const std::string&,
                                               bool success) override {
     load_rules_success_ = success;
   }
 
   base::MessageLoop ui_;
@@ skipping 59 matching lines @@
   source_->set_failures_number(99);
   validator_->LoadRules("CH");
   validator_->LoadRules("GB");
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(load_rules_success_);
   EXPECT_EQ(16, source_->attempts_number());
 }
 
 }  // namespace autofill