Remove the managed banner from the Chrome settings UI

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>
 
@@ skipping 23 matching lines @@
 #include "policy/policy_constants.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::Return;
 
 namespace policy {
 
 namespace {
 
-const char* kSettingsPages[] = {
-  "chrome://settings-frame",
-  "chrome://settings-frame/searchEngines",
-  "chrome://settings-frame/passwords",
-  "chrome://settings-frame/autofill",
-  "chrome://settings-frame/content",
-  "chrome://settings-frame/homePageOverlay",
-  "chrome://settings-frame/languages",
-#if defined(OS_CHROMEOS)
-  "chrome://settings-frame/accounts",
-#endif
-};
+const char kMainSettingsPage[] = "chrome://settings-frame";
 
 const char kCrosSettingsPrefix[] = "cros.";
 
 // Contains the details of a single test case verifying that the controlled
 // setting indicators for a pref affected by a policy work correctly. This is
 // part of the data loaded from chrome/test/data/policy/policy_test_cases.json.
 class IndicatorTestCase {
  public:
   IndicatorTestCase(const base::DictionaryValue& policy,
                     const std::string& value,
@@ skipping 100 matching lines @@
       return false;
 #endif
     return IsOsSupported();
   }
 
   const PolicyMap& test_policy() const { return test_policy_; }
   void SetTestPolicy(const PolicyMap& policy) {
     test_policy_.CopyFrom(policy);
   }
 
-  const std::vector<GURL>& settings_pages() const { return settings_pages_; }
-  void AddSettingsPage(const GURL& url) { settings_pages_.push_back(url); }
-
   const ScopedVector<PrefMapping>& pref_mappings() const {
     return pref_mappings_;
   }
   void AddPrefMapping(PrefMapping* pref_mapping) {
     pref_mappings_.push_back(pref_mapping);
   }
 
  private:
   std::string name_;
   bool is_official_only_;
   bool can_be_recommended_;
   std::vector<std::string> supported_os_;
   PolicyMap test_policy_;
-  std::vector<GURL> settings_pages_;
   ScopedVector<PrefMapping> pref_mappings_;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyTestCase);
 };
 
 // Parses all policy test cases and makes then available in a map.
 class PolicyTestCases {
  public:
   typedef std::map<std::string, PolicyTestCase*> PolicyTestCaseMap;
   typedef PolicyTestCaseMap::const_iterator iterator;
@@ skipping 60 matching lines @@
         if (os_list->GetString(i, &os))
           policy_test_case->AddSupportedOs(os);
       }
     }
     const base::DictionaryValue* policy_dict = NULL;
     if (policy_test_dict->GetDictionary("test_policy", &policy_dict)) {
       PolicyMap policy;
       policy.LoadFrom(policy_dict, POLICY_LEVEL_MANDATORY, POLICY_SCOPE_USER);
       policy_test_case->SetTestPolicy(policy);
     }
-    const base::ListValue* settings_pages = NULL;
-    if (policy_test_dict->GetList("settings_pages", &settings_pages)) {
-      for (size_t i = 0; i < settings_pages->GetSize(); ++i) {
-        std::string page;
-        if (settings_pages->GetString(i, &page))
-          policy_test_case->AddSettingsPage(GURL(page));
-      }
-    }
     const base::ListValue* pref_mappings = NULL;
     if (policy_test_dict->GetList("pref_mappings", &pref_mappings)) {
       for (size_t i = 0; i < pref_mappings->GetSize(); ++i) {
         const base::DictionaryValue* pref_mapping_dict = NULL;
         std::string pref;
         if (!pref_mappings->GetDictionary(i, &pref_mapping_dict) ||
             !pref_mapping_dict->GetString("pref", &pref)) {
           ADD_FAILURE() << "Malformed pref_mappings entry in "
                         << "policy_test_cases.json.";
           continue;
@@ skipping 30 matching lines @@
       }
     }
     return policy_test_case;
   }
 
   PolicyTestCaseMap* policy_test_cases_;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyTestCases);
 };
 
-bool IsBannerVisible(Browser* browser) {
-  content::WebContents* contents = chrome::GetActiveWebContents(browser);
-  bool result = false;
-  EXPECT_TRUE(content::ExecuteJavaScriptAndExtractBool(
-      contents->GetRenderViewHost(),
-      std::wstring(),
-      L"var visible = false;"
-      L"var banners = document.querySelectorAll('.page-banner');"
-      L"for (var i = 0; i < banners.length; i++) {"
-      L"  if (banners[i].parentElement.id == 'templates')"
-      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& selector,
                                        const std::string& value,
                                        const std::string& controlled_by,
                                        bool readonly) {
   std::wstringstream javascript;
   javascript << "var nodes = document.querySelectorAll("
              << "    'span.controlled-setting-indicator"
              <<          selector.c_str() << "');"
              << "var indicators = [];"
@@ skipping 50 matching lines @@
   }
   if (!controlled_by.empty()) {
     EXPECT_TRUE(have_visible_indicators)
         << "Expected to find at least one visible controlled setting "
         << "indicator.";
   }
 }
 
 }  // namespace
 
-// A class of tests parameterized by a settings page URL.
-class PolicyPrefsSettingsBannerTest
+// Base class for tests that change policy and are parameterized with a policy
+// definition.
+class PolicyPrefsTest
     : public InProcessBrowserTest,
-      public testing::WithParamInterface<const char*> {};
-
-// Base class for tests that change policies.
-class PolicyBaseTest : public InProcessBrowserTest {
+      public testing::WithParamInterface<PolicyDefinitionList::Entry> {
  protected:
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE {
     EXPECT_CALL(provider_, IsInitializationComplete())
         .WillRepeatedly(Return(true));
     BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
   }
 
   PolicyTestCases policy_test_cases_;
   MockConfigurationPolicyProvider provider_;
 };
 
-// A class of tests that change policy and don't need parameters.
-class PolicyPrefsBannerTest : public PolicyBaseTest {};
-
-// A class of tests that change policy and are parameterized with a policy
-// definition.
-class PolicyPrefsTest
-    : public PolicyBaseTest,
-      public testing::WithParamInterface<PolicyDefinitionList::Entry> {};
-
-TEST(PolicyPrefsTest, AllPoliciesHaveATestCase) {
+TEST(PolicyPrefsTestCoverageTest, AllPoliciesHaveATestCase) {
   // Verifies that all known policies have a test case in the JSON file.
   // This test fails when a policy is added to
   // chrome/app/policy/policy_templates.json but a test case is not added to
   // chrome/test/data/policy/policy_test_cases.json.
   PolicyTestCases policy_test_cases;
   const PolicyDefinitionList* list = GetChromePolicyDefinitionList();
   for (const PolicyDefinitionList::Entry* policy = list->begin;
        policy != list->end; ++policy) {
     EXPECT_TRUE(ContainsKey(policy_test_cases.map(), policy->name))
         << "Missing policy test case for: " << policy->name;
   }
 }
 
-IN_PROC_BROWSER_TEST_P(PolicyPrefsSettingsBannerTest, NoPoliciesNoBanner) {
-  // Verifies that the banner isn't shown in the settings UI when no policies
-  // are set.
-  ui_test_utils::NavigateToURL(browser(), GURL(GetParam()));
-  EXPECT_FALSE(IsBannerVisible(browser()));
-}
-
-INSTANTIATE_TEST_CASE_P(PolicyPrefsSettingsBannerTestInstance,
-                        PolicyPrefsSettingsBannerTest,
-                        testing::ValuesIn(kSettingsPages));
-
-IN_PROC_BROWSER_TEST_F(PolicyPrefsBannerTest, TogglePolicyTogglesBanner) {
-  // Verifies that the banner appears and disappears as policies are added and
-  // removed.
-  // |test_case| is just a particular policy that should trigger the banner
-  // on the main settings page.
-  const PolicyTestCase* test_case = policy_test_cases_.Get("ShowHomeButton");
-  ASSERT_TRUE(test_case);
-  // No banner by default.
-  ui_test_utils::NavigateToURL(browser(), GURL(kSettingsPages[0]));
-  EXPECT_FALSE(IsBannerVisible(browser()));
-  // Adding a policy makes the banner show up.
-  provider_.UpdateChromePolicy(test_case->test_policy());
-  EXPECT_TRUE(IsBannerVisible(browser()));
-  // And removing it makes the banner go away.
-  const PolicyMap kNoPolicies;
-  provider_.UpdateChromePolicy(kNoPolicies);
-  EXPECT_FALSE(IsBannerVisible(browser()));
-  // Do it again, just in case.
-  provider_.UpdateChromePolicy(test_case->test_policy());
-  EXPECT_TRUE(IsBannerVisible(browser()));
-  provider_.UpdateChromePolicy(kNoPolicies);
-  EXPECT_FALSE(IsBannerVisible(browser()));
-}
-
 IN_PROC_BROWSER_TEST_P(PolicyPrefsTest, PolicyToPrefsMapping) {
   // Verifies that policies make their corresponding preferences become managed,
   // and that the user can't override that setting.
   const PolicyTestCase* test_case = policy_test_cases_.Get(GetParam().name);
   ASSERT_TRUE(test_case);
   const ScopedVector<PrefMapping>& pref_mappings = test_case->pref_mappings();
   if (!test_case->IsSupported() || pref_mappings.empty())
     return;
   LOG(INFO) << "Testing policy: " << test_case->name();
 
@@ skipping 23 matching lines @@
     EXPECT_FALSE(pref->IsManaged());
 
     provider_.UpdateChromePolicy(test_case->test_policy());
     EXPECT_FALSE(pref->IsDefaultValue());
     EXPECT_FALSE(pref->IsUserModifiable());
     EXPECT_FALSE(pref->IsUserControlled());
     EXPECT_TRUE(pref->IsManaged());
   }
 }
 
-IN_PROC_BROWSER_TEST_P(PolicyPrefsTest, CheckAllPoliciesThatShowTheBanner) {
-  // Verifies that the banner appears for each policy that affects a control
-  // in the settings UI.
-  const PolicyTestCase* test_case = policy_test_cases_.Get(GetParam().name);
-  ASSERT_TRUE(test_case);
-  if (!test_case->IsSupported() || test_case->settings_pages().empty())
-    return;
-  LOG(INFO) << "Testing policy: " << test_case->name();
-
-  const std::vector<GURL>& pages = test_case->settings_pages();
-  for (size_t i = 0; i < pages.size(); ++i) {
-    ui_test_utils::NavigateToURL(browser(), pages[i]);
-    EXPECT_FALSE(IsBannerVisible(browser()));
-    provider_.UpdateChromePolicy(test_case->test_policy());
-    EXPECT_TRUE(IsBannerVisible(browser()));
-    const PolicyMap kNoPolicies;
-    provider_.UpdateChromePolicy(kNoPolicies);
-    EXPECT_FALSE(IsBannerVisible(browser()));
-  }
-}
-
 IN_PROC_BROWSER_TEST_P(PolicyPrefsTest, CheckPolicyIndicators) {
   // Verifies that controlled setting indicators correctly show whether a pref's
   // value is recommended or enforced by a corresponding policy.
   const PolicyTestCase* policy_test_case =
       policy_test_cases_.Get(GetParam().name);
   ASSERT_TRUE(policy_test_case);
   const ScopedVector<PrefMapping>& pref_mappings =
       policy_test_case->pref_mappings();
   if (!policy_test_case->IsSupported() || pref_mappings.empty())
     return;
@@ skipping 13 matching lines @@
 
   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();
     if (indicator_test_cases.empty())
       continue;
 
-    ui_test_utils::NavigateToURL(browser(), GURL(kSettingsPages[0]));
+    ui_test_utils::NavigateToURL(browser(), GURL(kMainSettingsPage));
     if (!(*pref_mapping)->indicator_test_setup_js().empty()) {
       ASSERT_TRUE(content::ExecuteJavaScript(
           chrome::GetActiveWebContents(browser())->GetRenderViewHost(), L"",
           (*pref_mapping)->indicator_test_setup_js()));
     }
 
     std::string indicator_selector = (*pref_mapping)->indicator_selector();
     if (indicator_selector.empty())
       indicator_selector = "[pref=\"" + (*pref_mapping)->pref() + "\"]";
     for (ScopedVector<IndicatorTestCase>::const_iterator
@@ skipping 49 matching lines @@
   }
 }
 
 INSTANTIATE_TEST_CASE_P(
     PolicyPrefsTestInstance,
     PolicyPrefsTest,
     testing::ValuesIn(GetChromePolicyDefinitionList()->begin,
                       GetChromePolicyDefinitionList()->end));
 
 }  // namespace policy