Make extensions developer mode adhere to policy

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>
@@ skipping 83 matching lines @@
 };
 
 // Contains the testing details for a single pref affected by a policy. This is
 // part of the data loaded from chrome/test/data/policy/policy_test_cases.json.
 class PrefMapping {
  public:
   PrefMapping(const std::string& pref,
               bool is_local_state,
               bool check_for_mandatory,
               bool check_for_recommended,
+              const std::string& indicator_test_url,
               const std::string& indicator_test_setup_js,
               const std::string& indicator_selector)
       : pref_(pref),
         is_local_state_(is_local_state),
         check_for_mandatory_(check_for_mandatory),
         check_for_recommended_(check_for_recommended),
+        indicator_test_url_(indicator_test_url),
         indicator_test_setup_js_(indicator_test_setup_js),
         indicator_selector_(indicator_selector) {}
   ~PrefMapping() {}
 
   const std::string& pref() const { return pref_; }
 
   bool is_local_state() const { return is_local_state_; }
 
   bool check_for_mandatory() const { return check_for_mandatory_; }
 
   bool check_for_recommended() const { return check_for_recommended_; }
 
+  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 {
     return indicator_test_cases_;
   }
   void AddIndicatorTestCase(IndicatorTestCase* test_case) {
     indicator_test_cases_.push_back(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_;
 
   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 {
@@ skipping 59 matching lines @@
   bool is_official_only_;
   bool can_be_recommended_;
   std::vector<std::string> supported_os_;
   base::DictionaryValue test_policy_;
   ScopedVector<PrefMapping> pref_mappings_;
   std::string indicator_selector_;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyTestCase);
 };
 
-// Parses all policy test cases and makes then available in a map.
+// 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;
   typedef PolicyTestCaseMap::const_iterator iterator;
 
   PolicyTestCases() {
     base::FilePath path = ui_test_utils::GetTestFilePath(
         base::FilePath(FILE_PATH_LITERAL("policy")),
         base::FilePath(FILE_PATH_LITERAL("policy_test_cases.json")));
@@ skipping 88 matching lines @@
           continue;
         }
         bool is_local_state = false;
         pref_mapping_dict->GetBoolean("local_state", &is_local_state);
         bool check_for_mandatory = true;
         pref_mapping_dict->GetBoolean("check_for_mandatory",
                                       &check_for_mandatory);
         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);
         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 "
@@ skipping 337 matching lines @@
             (*pref_mapping)->indicator_test_cases();
         if (indicator_test_cases.empty())
           continue;
 
         if (!(*pref_mapping)->indicator_test_setup_js().empty()) {
           ASSERT_TRUE(content::ExecuteScript(
               browser()->tab_strip_model()->GetActiveWebContents(),
               (*pref_mapping)->indicator_test_setup_js()));
         }
 
+        // Note: 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 there should ever be many of these, we could consider grouping

[Andrew T Wilson (Slow), 2016/12/04 14:54:54]

For whatever reason, I don't actually understand what you're saying in this
comment. I can't tell if it's just because I'm being stupid or not.

[pmarko, 2016/12/07 16:12:11]

I've tried to make it understandable, PTAL.

+        // tests by indicator_test_url and only navigate to the URL once for
+        // many tests.
+        if (!(*pref_mapping)->indicator_test_url().empty()) {
+          ui_test_utils::NavigateToURL(
+              browser(),
+              GURL((*pref_mapping)->indicator_test_url()));
+        }
+
         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_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();
@@ skipping 43 matching lines @@
           // when a value is recommended by policy and the user has overridden
           // the recommendation.
           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());
         }
+
+        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