Remove ScopedVector from chrome/browser/.

chrome/browser/policy/policy_prefs_browsertest.cc

 // Copyright (c) 2012 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 <algorithm>
 #include <cstdlib>
 #include <map>
 #include <memory>
 #include <sstream>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
-#include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
@@ skipping 92 matching lines @@
   const std::string& indicator_test_url() const { return indicator_test_url_; }
 
   const std::string& indicator_test_setup_js() const {
     return indicator_test_setup_js_;
   }
 
   const std::string& indicator_selector() const {
     return indicator_selector_;
   }
 
-  const ScopedVector<IndicatorTestCase>& indicator_test_cases() const {
+  const std::vector<std::unique_ptr<IndicatorTestCase>>& indicator_test_cases()
+      const {
     return indicator_test_cases_;
   }
-  void AddIndicatorTestCase(IndicatorTestCase* test_case) {
-    indicator_test_cases_.push_back(test_case);
+  void AddIndicatorTestCase(std::unique_ptr<IndicatorTestCase> test_case) {
+    indicator_test_cases_.push_back(std::move(test_case));
   }
 
  private:
   const std::string pref_;
   const bool is_local_state_;
   const bool check_for_mandatory_;
   const bool check_for_recommended_;
   const std::string indicator_test_url_;
   const std::string indicator_test_setup_js_;
   const std::string indicator_selector_;
-  ScopedVector<IndicatorTestCase> indicator_test_cases_;
+  std::vector<std::unique_ptr<IndicatorTestCase>> indicator_test_cases_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefMapping);
 };
 
 // Contains the testing details for a single policy. This is part of the data
 // loaded from chrome/test/data/policy/policy_test_cases.json.
 class PolicyTestCase {
  public:
   PolicyTestCase(const std::string& name,
                  bool is_official_only,
@@ skipping 35 matching lines @@
 #endif
     return IsOsSupported();
   }
 
   const base::DictionaryValue& test_policy() const { return test_policy_; }
   void SetTestPolicy(const base::DictionaryValue& policy) {
     test_policy_.Clear();
     test_policy_.MergeDictionary(&policy);
   }
 
-  const ScopedVector<PrefMapping>& pref_mappings() const {
+  const std::vector<std::unique_ptr<PrefMapping>>& pref_mappings() const {
     return pref_mappings_;
   }
-  void AddPrefMapping(PrefMapping* pref_mapping) {
-    pref_mappings_.push_back(pref_mapping);
+  void AddPrefMapping(std::unique_ptr<PrefMapping> pref_mapping) {
+    pref_mappings_.push_back(std::move(pref_mapping));
   }
 
   const std::string& indicator_selector() const { return indicator_selector_; }
 
  private:
   std::string name_;
   bool is_official_only_;
   bool can_be_recommended_;
   std::vector<std::string> supported_os_;
   base::DictionaryValue test_policy_;
-  ScopedVector<PrefMapping> pref_mappings_;
+  std::vector<std::unique_ptr<PrefMapping>> pref_mappings_;
   std::string indicator_selector_;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyTestCase);
 };
 
 // Parses all policy test cases and makes them available in a map.
 class PolicyTestCases {
  public:
   typedef std::vector<PolicyTestCase*> PolicyTestCaseVector;
   typedef std::map<std::string, PolicyTestCaseVector> PolicyTestCaseMap;
@@ skipping 101 matching lines @@
         bool check_for_recommended = true;
         pref_mapping_dict->GetBoolean("check_for_recommended",
                                       &check_for_recommended);
         std::string indicator_test_url;
         pref_mapping_dict->GetString("indicator_test_url", &indicator_test_url);
         std::string indicator_test_setup_js;
         pref_mapping_dict->GetString("indicator_test_setup_js",
                                      &indicator_test_setup_js);
         std::string indicator_selector;
         pref_mapping_dict->GetString("indicator_selector", &indicator_selector);
-        PrefMapping* pref_mapping = new PrefMapping(pref,
-                                                    is_local_state,
-                                                    check_for_mandatory,
-                                                    check_for_recommended,
-                                                    indicator_test_url,
-                                                    indicator_test_setup_js,
-                                                    indicator_selector);
+        auto pref_mapping = base::MakeUnique<PrefMapping>(
+            pref, is_local_state, check_for_mandatory, check_for_recommended,
+            indicator_test_url, indicator_test_setup_js, indicator_selector);
         const base::ListValue* indicator_tests = NULL;
         if (pref_mapping_dict->GetList("indicator_tests", &indicator_tests)) {
           for (size_t i = 0; i < indicator_tests->GetSize(); ++i) {
             const base::DictionaryValue* indicator_test_dict = NULL;
             const base::DictionaryValue* policy = NULL;
             if (!indicator_tests->GetDictionary(i, &indicator_test_dict) ||
                 !indicator_test_dict->GetDictionary("policy", &policy)) {
               ADD_FAILURE() << "Malformed indicator_tests entry in "
                             << "policy_test_cases.json.";
               continue;
             }
             std::string value;
             indicator_test_dict->GetString("value", &value);
             bool readonly = false;
             indicator_test_dict->GetBoolean("readonly", &readonly);
             pref_mapping->AddIndicatorTestCase(
-                new IndicatorTestCase(*policy, value, readonly));
+                base::MakeUnique<IndicatorTestCase>(*policy, value, readonly));
           }
         }
-        policy_test_case->AddPrefMapping(pref_mapping);
+        policy_test_case->AddPrefMapping(std::move(pref_mapping));
       }
     }
     return policy_test_case;
   }
 
   PolicyTestCaseMap policy_test_cases_;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyTestCases);
 };
 
@@ skipping 171 matching lines @@
   PrefService* user_prefs = browser()->profile()->GetPrefs();
 
   const PolicyTestCases test_cases;
   for (PolicyTestCases::iterator policy = test_cases.begin();
        policy != test_cases.end();
        ++policy) {
     for (PolicyTestCases::PolicyTestCaseVector::const_iterator test_case =
              policy->second.begin();
          test_case != policy->second.end();
          ++test_case) {
-      const ScopedVector<PrefMapping>& pref_mappings =
-          (*test_case)->pref_mappings();
+      const auto& pref_mappings = (*test_case)->pref_mappings();
       if (!(*test_case)->IsSupported() || pref_mappings.empty())
         continue;
 
       LOG(INFO) << "Testing policy: " << policy->first;
 
-      for (ScopedVector<PrefMapping>::const_iterator pref_mapping =
-               pref_mappings.begin();
-           pref_mapping != pref_mappings.end();
-           ++pref_mapping) {
+      for (const auto& pref_mapping : pref_mappings) {
         // Skip Chrome OS preferences that use a different backend and cannot be
         // retrieved through the prefs mechanism.
-        if (base::StartsWith((*pref_mapping)->pref(), kCrosSettingsPrefix,
+        if (base::StartsWith(pref_mapping->pref(), kCrosSettingsPrefix,
                              base::CompareCase::SENSITIVE))
           continue;
 
         // Skip preferences that should not be checked when the policy is set to
         // a mandatory value.
-        if (!(*pref_mapping)->check_for_mandatory())
+        if (!pref_mapping->check_for_mandatory())
           continue;
 
         PrefService* prefs =
-            (*pref_mapping)->is_local_state() ? local_state : user_prefs;
+            pref_mapping->is_local_state() ? local_state : user_prefs;
         // The preference must have been registered.
         const PrefService::Preference* pref =
-            prefs->FindPreference((*pref_mapping)->pref().c_str());
+            prefs->FindPreference(pref_mapping->pref().c_str());
         ASSERT_TRUE(pref);
 
         // Verify that setting the policy overrides the pref.
         ClearProviderPolicy();
-        prefs->ClearPref((*pref_mapping)->pref().c_str());
+        prefs->ClearPref(pref_mapping->pref().c_str());
         EXPECT_TRUE(pref->IsDefaultValue());
         EXPECT_TRUE(pref->IsUserModifiable());
         EXPECT_FALSE(pref->IsUserControlled());
         EXPECT_FALSE(pref->IsManaged());
 
         SetProviderPolicy((*test_case)->test_policy(), POLICY_LEVEL_MANDATORY);
         EXPECT_FALSE(pref->IsDefaultValue());
         EXPECT_FALSE(pref->IsUserModifiable());
         EXPECT_FALSE(pref->IsUserControlled());
         EXPECT_TRUE(pref->IsManaged());
@@ skipping 23 matching lines @@
         test_cases.Get(*policy);
     ASSERT_TRUE(policy_test_cases) << "PolicyTestCase not found for "
                                    << *policy;
     for (std::vector<PolicyTestCase*>::const_iterator test_case =
              policy_test_cases->begin();
          test_case != policy_test_cases->end();
          ++test_case) {
       PolicyTestCase* policy_test_case = *test_case;
       if (!policy_test_case->IsSupported())
         continue;
-      const ScopedVector<PrefMapping>& pref_mappings =
-          policy_test_case->pref_mappings();
+      const auto& pref_mappings = policy_test_case->pref_mappings();
       if (policy_test_case->indicator_selector().empty()) {
         bool has_pref_indicator_tests = false;
-        for (ScopedVector<PrefMapping>::const_iterator pref_mapping =
-                 pref_mappings.begin();
-             pref_mapping != pref_mappings.end();
-             ++pref_mapping) {
+        for (const auto& pref_mapping : pref_mappings) {
           PrefService* prefs =
-              (*pref_mapping)->is_local_state() ? local_state : user_prefs;
-          if (prefs->FindPreference((*pref_mapping)->pref()))
-            prefs->ClearPref((*pref_mapping)->pref());
-          if (!(*pref_mapping)->indicator_test_cases().empty()) {
+              pref_mapping->is_local_state() ? local_state : user_prefs;
+          if (prefs->FindPreference(pref_mapping->pref()))
+            prefs->ClearPref(pref_mapping->pref());
+          if (!pref_mapping->indicator_test_cases().empty()) {
             has_pref_indicator_tests = true;
             break;
           }
         }
         if (!has_pref_indicator_tests)
           continue;
       }
 
       LOG(INFO) << "Testing policy: " << *policy;
 
@@ skipping 21 matching lines @@
         // enforced value is removed.
         ClearProviderPolicy();
         VerifyControlledSettingIndicators(
             browser(),
             policy_test_case->indicator_selector(),
             std::string(),
             std::string(),
             false);
       }
 
-      for (ScopedVector<PrefMapping>::const_iterator
-               pref_mapping = pref_mappings.begin();
-           pref_mapping != pref_mappings.end();
-           ++pref_mapping) {
-        const ScopedVector<IndicatorTestCase>& indicator_test_cases =
-            (*pref_mapping)->indicator_test_cases();
+      for (const auto& pref_mapping : pref_mappings) {
+        const auto& indicator_test_cases = pref_mapping->indicator_test_cases();
         if (indicator_test_cases.empty())
           continue;
 
-        if (!(*pref_mapping)->indicator_test_setup_js().empty()) {
+        if (!pref_mapping->indicator_test_setup_js().empty()) {
           ASSERT_TRUE(content::ExecuteScript(
               browser()->tab_strip_model()->GetActiveWebContents(),
-              (*pref_mapping)->indicator_test_setup_js()));
+              pref_mapping->indicator_test_setup_js()));
         }
 
         // A non-empty indicator_test_url is expected to be used in very
         // few cases, so it's currently implemented by navigating to the URL
         // right before the test and navigating back afterwards.
         // If you introduce many test cases with the same non-empty
         // indicator_test_url, this would be inefficient. We could consider
         // navigting to a specific indicator_test_url once for many test cases
         // instead.
-        if (!(*pref_mapping)->indicator_test_url().empty()) {
+        if (!pref_mapping->indicator_test_url().empty()) {
           ui_test_utils::NavigateToURL(
-              browser(), GURL((*pref_mapping)->indicator_test_url()));
+              browser(), GURL(pref_mapping->indicator_test_url()));
         }
 
-        std::string indicator_selector = (*pref_mapping)->indicator_selector();
+        std::string indicator_selector = pref_mapping->indicator_selector();
         if (indicator_selector.empty())
-          indicator_selector = "[pref=\"" + (*pref_mapping)->pref() + "\"]";
-        for (ScopedVector<IndicatorTestCase>::const_iterator
-                 indicator_test_case = indicator_test_cases.begin();
+          indicator_selector = "[pref=\"" + pref_mapping->pref() + "\"]";
+        for (auto indicator_test_case = indicator_test_cases.begin();
              indicator_test_case != indicator_test_cases.end();
              ++indicator_test_case) {
           // Check that no controlled setting indicator is visible when no value
           // is set by policy.
           ClearProviderPolicy();
           VerifyControlledSettingIndicators(browser(),
                                             indicator_selector,
                                             std::string(),
                                             std::string(),
                                             false);
 
-          if ((*pref_mapping)->check_for_mandatory()) {
+          if (pref_mapping->check_for_mandatory()) {
             // Check that the appropriate controlled setting indicator is shown
             // when a value is enforced by policy.
             SetProviderPolicy((*indicator_test_case)->policy(),
                               POLICY_LEVEL_MANDATORY);
 
             VerifyControlledSettingIndicators(
                 browser(),
                 indicator_selector,
                 (*indicator_test_case)->value(),
                 "policy",
                 (*indicator_test_case)->readonly());
           }
 
           if (!policy_test_case->can_be_recommended() ||
-              !(*pref_mapping)->check_for_recommended()) {
+              !pref_mapping->check_for_recommended()) {
             continue;
           }
 
           PrefService* prefs =
-              (*pref_mapping)->is_local_state() ? local_state : user_prefs;
+              pref_mapping->is_local_state() ? local_state : user_prefs;
           // The preference must have been registered.
           const PrefService::Preference* pref =
-              prefs->FindPreference((*pref_mapping)->pref().c_str());
+              prefs->FindPreference(pref_mapping->pref().c_str());
           ASSERT_TRUE(pref);
 
           // Check that the appropriate controlled setting indicator is shown
           // when a value is recommended by policy and the user has not
           // overridden the recommendation.
           SetProviderPolicy((*indicator_test_case)->policy(),
                             POLICY_LEVEL_RECOMMENDED);
           VerifyControlledSettingIndicators(browser(),
                                             indicator_selector,
                                             (*indicator_test_case)->value(),
                                             "recommended",
                                             (*indicator_test_case)->readonly());
           // Check that the appropriate controlled setting indicator is shown
           // when a value is recommended by policy and the user has overridden
           // the recommendation.
-          prefs->Set((*pref_mapping)->pref().c_str(), *pref->GetValue());
+          prefs->Set(pref_mapping->pref().c_str(), *pref->GetValue());
           VerifyControlledSettingIndicators(browser(),
                                             indicator_selector,
                                             (*indicator_test_case)->value(),
                                             "hasRecommendation",
                                             (*indicator_test_case)->readonly());
-          prefs->ClearPref((*pref_mapping)->pref().c_str());
+          prefs->ClearPref(pref_mapping->pref().c_str());
         }
 
-        if (!(*pref_mapping)->indicator_test_url().empty())
+        if (!pref_mapping->indicator_test_url().empty())
           ui_test_utils::NavigateToURL(browser(), GURL(kMainSettingsPage));
       }
     }
   }
 }
 
 INSTANTIATE_TEST_CASE_P(PolicyPrefIndicatorTestInstance,
                         PolicyPrefIndicatorTest,
                         testing::ValuesIn(SplitPoliciesIntoChunks(10)));
 
 }  // namespace policy