Add controlled setting indicators for content settings

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 <algorithm>
 #include <map>
 #include <sstream>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stl_util.h"
+#include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/policy/browser_policy_connector.h"
 #include "chrome/browser/policy/mock_configuration_policy_provider.h"
 #include "chrome/browser/policy/policy_map.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/test/base/in_process_browser_test.h"
@@ skipping 67 matching lines @@
   bool can_be_recommended() const { return can_be_recommended_; }
   void set_can_be_recommended(bool can_be_recommended) {
     can_be_recommended_ = can_be_recommended;
   }
 
   const PolicyMap& test_policy() const { return test_policy_; }
   void set_test_policy(const PolicyMap& policy) {
     test_policy_.CopyFrom(policy);
   }
 
+  const std::wstring& indicator_test_setup_js() const {
+    return indicator_test_setup_js_;
+  }
+  void set_indicator_test_setup_js(const std::string& indicator_test_setup_js) {
+    indicator_test_setup_js_ = ASCIIToWide(indicator_test_setup_js);
+  }
+
+  const std::string& indicator_selector() const { return indicator_selector_; }
+  void set_indicator_selector(const std::string& indicator_selector) {
+    indicator_selector_ = 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);
   }
 
   const std::vector<GURL>& settings_pages() const { return settings_pages_; }
   void AddSettingsPage(const GURL& url) { settings_pages_.push_back(url); }
 
@@ skipping 27 matching lines @@
       return false;
 #endif
     return IsOsSupported();
   }
 
  private:
   std::string name_;
   std::string pref_;
   bool can_be_recommended_;
   PolicyMap test_policy_;
+  std::wstring indicator_test_setup_js_;
+  std::string indicator_selector_;
   ScopedVector<IndicatorTestCase> indicator_test_cases_;
   std::vector<GURL> settings_pages_;
   std::vector<std::string> supported_os_;
   bool is_local_state_;
   bool official_only_;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyTestCase);
 };
 
 // Parses all the test cases and makes then available in a map.
@@ skipping 57 matching lines @@
       test_case->set_pref(pref);
     bool flag = false;
     if (dict->GetBoolean("can_be_recommended", &flag))
       test_case->set_can_be_recommended(flag);
     const base::DictionaryValue* policy_dict = NULL;
     if (dict->GetDictionary("test_policy", &policy_dict)) {
       PolicyMap policies;
       policies.LoadFrom(policy_dict, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
       test_case->set_test_policy(policies);
     }
+    std::string indicator_test_setup_js;
+    if (dict->GetString("indicator_test_setup_js", &indicator_test_setup_js))
+      test_case->set_indicator_test_setup_js(indicator_test_setup_js);
+    std::string indicator_selector;
+    if (dict->GetString("indicator_selector", &indicator_selector))
+      test_case->set_indicator_selector(indicator_selector);
     const base::ListValue* indicator_tests = NULL;
     if (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)) {
           continue;
         }
         std::string value;
@@ skipping 45 matching lines @@
       L"    continue;"
       L"  if (window.getComputedStyle(banners[i]).display != 'none')"
       L"    visible = true;"
       L"}"
       L"domAutomationController.send(visible);",
       &result));
   return result;
 }
 
 void VerifyControlledSettingIndicators(Browser* browser,
-                                       const std::string& pref,
+                                       const std::string& selector,
                                        const std::string& value,
                                        const std::string& controlled_by,
                                        bool readonly) {
   std::wstringstream javascript;
   javascript << "var nodes = document.querySelectorAll("
-             << "    'span.controlled-setting-indicator["
-             << "        pref=\"" << pref.c_str() << "\"]');"
+             << "    'span.controlled-setting-indicator"
+             <<          selector.c_str() << "');"
              << "var indicators = [];"
              << "for (var i = 0; i < nodes.length; i++) {"
              << "  var node = nodes[i];"
              << "  var indicator = {};"
              << "  indicator.value = node.value || '';"
              << "  indicator.controlledBy = node.controlledBy || '';"
              << "  indicator.readOnly = node.readOnly || false;"
              << "  indicator.visible ="
              << "      window.getComputedStyle(node).display != 'none';"
              << "  indicators.push(indicator)"
              << "}"
              << "domAutomationController.send(JSON.stringify(indicators));";
   content::WebContents* contents = chrome::GetActiveWebContents(browser);
   std::string json;
-  // Retrieve the state of all controlled setting indicators for |pref| as JSON.
+  // Retrieve the state of all controlled setting indicators matching the
+  // |selector| as JSON.
   ASSERT_TRUE(content::ExecuteJavaScriptAndExtractString(
       contents->GetRenderViewHost(), L"", javascript.str(), &json));
   scoped_ptr<base::Value> value_ptr(base::JSONReader::Read(json));
   const base::ListValue* indicators = NULL;
   ASSERT_TRUE(value_ptr.get());
   ASSERT_TRUE(value_ptr->GetAsList(&indicators));
   // Verify that controlled setting indicators representing |value| are visible
   // and have the correct state while those not representing |value| are
   // invisible.
+  if (!controlled_by.empty()) {
+    EXPECT_GT(indicators->GetSize(), 0u)
+        << "Expected to find at least one controlled setting indicator.";
+  }
   for (base::ListValue::const_iterator indicator = indicators->begin();
        indicator != indicators->end(); ++indicator) {
     const base::DictionaryValue* properties = NULL;
     ASSERT_TRUE((*indicator)->GetAsDictionary(&properties));
     std::string indicator_value;
     std::string indicator_controlled_by;
     bool indicator_readonly;
     bool indicator_visible;
     EXPECT_TRUE(properties->GetString("value", &indicator_value));
     EXPECT_TRUE(properties->GetString("controlledBy",
@@ skipping 149 matching lines @@
   if (!policy_test_case->IsSupported() || indicator_test_cases.empty())
     return;
   LOG(INFO) << "Testing policy: " << policy_test_case->name();
 
   PrefService* prefs = policy_test_case->is_local_state() ?
       g_browser_process->local_state() : browser()->profile()->GetPrefs();
   // The preference must have been registered.
   const PrefService::Preference* pref =
       prefs->FindPreference(policy_test_case->pref_name());
   ASSERT_TRUE(pref);
+
   ui_test_utils::NavigateToURL(browser(), GURL(kSettingsPages[0]));
+  if (!policy_test_case->indicator_test_setup_js().empty()) {
+    ASSERT_TRUE(content::ExecuteJavaScript(
+        chrome::GetActiveWebContents(browser())->GetRenderViewHost(), L"",
+        policy_test_case->indicator_test_setup_js()));
+  }
 
+  std::string indicator_selector = policy_test_case->indicator_selector();
+  if (indicator_selector.empty())
+    indicator_selector = "[pref=\"" + policy_test_case->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.
     PolicyMap policies;
     provider_.UpdateChromePolicy(policies);
-    VerifyControlledSettingIndicators(browser(), policy_test_case->pref(),
+    VerifyControlledSettingIndicators(browser(), indicator_selector,
                                       "", "", false);
     // Check that the appropriate controlled setting indicator is shown when a
     // value is enforced by policy.
     policies.LoadFrom(&(*indicator_test_case)->policy(),
                       POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
     provider_.UpdateChromePolicy(policies);
-    VerifyControlledSettingIndicators(browser(), policy_test_case->pref(),
+    VerifyControlledSettingIndicators(browser(), indicator_selector,
                                       (*indicator_test_case)->value(),
                                       "policy",
                                       (*indicator_test_case)->readonly());
     if (!policy_test_case->can_be_recommended())
-      return;
+      continue;
     // Check that the appropriate controlled setting indicator is shown when a
     // value is recommended by policy and the user has not overridden the
     // recommendation.
     policies.LoadFrom(&(*indicator_test_case)->policy(),
                       POLICY_LEVEL_RECOMMENDED, POLICY_SCOPE_USER);
     provider_.UpdateChromePolicy(policies);
-    VerifyControlledSettingIndicators(browser(), policy_test_case->pref(),
+    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 overriddent the
     // recommendation.
     prefs->Set(policy_test_case->pref_name(), *pref->GetValue());
-    VerifyControlledSettingIndicators(browser(), policy_test_case->pref(),
+    VerifyControlledSettingIndicators(browser(), indicator_selector,
                                       (*indicator_test_case)->value(),
                                       "hasRecommendation",
                                       (*indicator_test_case)->readonly());
     prefs->ClearPref(policy_test_case->pref_name());
   }
 }
 
 INSTANTIATE_TEST_CASE_P(
     PolicyPrefsTestInstance,
     PolicyPrefsTest,
     testing::ValuesIn(GetChromePolicyDefinitionList()->begin,
                       GetChromePolicyDefinitionList()->end));
 
 }  // namespace policy