Flag for Material Design policy construction page

chrome/browser/ui/webui/policy_ui_browsertest.cc

 // Copyright (c) 2013 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 <vector>
 
 #include "base/callback.h"
+#include "base/command_line.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/run_loop.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_system.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "components/policy/core/common/external_data_fetcher.h"
 #include "components/policy/core/common/mock_configuration_policy_provider.h"
 #include "components/policy/core/common/policy_map.h"
 #include "components/policy/core/common/policy_types.h"
 #include "components/policy/core/common/schema.h"
 #include "content/public/browser/web_contents.h"
@@ skipping 54 matching lines @@
     expected_policy.push_back(l10n_util::GetStringUTF8(IDS_POLICY_UNSET));
 
   // Populate expected expanded policy value.
   expected_policy.push_back(value);
 
   return expected_policy;
 }
 
 }  // namespace
 
-class PolicyUITest : public InProcessBrowserTest {
+class PolicyUITest
+    : public InProcessBrowserTest,
+      public testing::WithParamInterface<bool>  {
  public:
   PolicyUITest();
   ~PolicyUITest() override;
 
+  // InProcessBrowserTest:
+  void SetUpCommandLine(base::CommandLine* command_line) override;
+
+  GURL url() const;
+
  protected:
   // InProcessBrowserTest implementation.
   void SetUpInProcessBrowserTestFixture() override;
 
   void UpdateProviderPolicy(const policy::PolicyMap& policy);
 
   void VerifyPolicies(const std::vector<std::vector<std::string> >& expected);
 
  protected:
   policy::MockConfigurationPolicyProvider provider_;
 
  private:
+  bool has_material_design_flag_;
+
   DISALLOW_COPY_AND_ASSIGN(PolicyUITest);
 };
 
-PolicyUITest::PolicyUITest() {
+PolicyUITest::PolicyUITest() : has_material_design_flag_(GetParam()) {
 }
 
 PolicyUITest::~PolicyUITest() {
 }
 
+GURL PolicyUITest::url() const {
+  return GURL(has_material_design_flag_ ?
+                  chrome::kChromeUIPolicyInternalsURL :
+                  chrome::kChromeUIPolicyURL);
+}
+
+void PolicyUITest::SetUpCommandLine(base::CommandLine* command_line) {
+  InProcessBrowserTest::SetUpCommandLine(command_line);
+  if (has_material_design_flag_)
+    command_line->AppendSwitch(switches::kEnableMaterialDesignPolicyPage);
+}
+
 void PolicyUITest::SetUpInProcessBrowserTestFixture() {
   EXPECT_CALL(provider_, IsInitializationComplete(_))
       .WillRepeatedly(Return(true));
   policy::BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_);
 }
 
 void PolicyUITest::UpdateProviderPolicy(const policy::PolicyMap& policy) {
   provider_.UpdateChromePolicy(policy);
   base::RunLoop loop;
   loop.RunUntilIdle();
 }
 
 void PolicyUITest::VerifyPolicies(
     const std::vector<std::vector<std::string> >& expected_policies) {
-  ui_test_utils::NavigateToURL(browser(), GURL("chrome://policy"));
+  ui_test_utils::NavigateToURL(browser(), url());
 
   // Retrieve the text contents of the policy table cells for all policies.
   const std::string javascript =
       "var entries = document.querySelectorAll("
       "    'section.policy-table-section > * > tbody');"
       "var policies = [];"
       "for (var i = 0; i < entries.length; ++i) {"
       "  var items = entries[i].querySelectorAll('tr > td');"
       "  var values = [];"
       "  for (var j = 0; j < items.length; ++j) {"
@@ skipping 27 matching lines @@
     ASSERT_TRUE(actual_policies->GetList(i, &actual_policy));
     ASSERT_EQ(expected_policy.size(), actual_policy->GetSize());
     for (size_t j = 0; j < expected_policy.size(); ++j) {
       std::string value;
       ASSERT_TRUE(actual_policy->GetString(j, &value));
       EXPECT_EQ(expected_policy[j], value);
     }
   }
 }
 
-IN_PROC_BROWSER_TEST_F(PolicyUITest, SendPolicyNames) {
+IN_PROC_BROWSER_TEST_P(PolicyUITest, SendPolicyNames) {
   // Verifies that the names of known policies are sent to the UI and processed
   // there correctly by checking that the policy table contains all policies in
   // the correct order.
 
   // Expect that the policy table contains all known policies in alphabetical
   // order and none of the policies have a set value.
   std::vector<std::vector<std::string> > expected_policies;
   policy::Schema chrome_schema =
       policy::Schema::Wrap(policy::GetChromeSchemaData());
   ASSERT_TRUE(chrome_schema.valid());
   for (policy::Schema::Iterator it = chrome_schema.GetPropertiesIterator();
        !it.IsAtEnd(); it.Advance()) {
     expected_policies.push_back(
         PopulateExpectedPolicy(
             it.key(), std::string(), std::string(), nullptr, false));
   }
 
   // Retrieve the contents of the policy table from the UI and verify that it
   // matches the expectation.
   VerifyPolicies(expected_policies);
 }
 
-IN_PROC_BROWSER_TEST_F(PolicyUITest, SendPolicyValues) {
+IN_PROC_BROWSER_TEST_P(PolicyUITest, SendPolicyValues) {
   // Verifies that policy values are sent to the UI and processed there
   // correctly by setting the values of four known and one unknown policy and
   // checking that the policy table contains the policy names, values and
   // metadata in the correct order.
   policy::PolicyMap values;
   std::map<std::string, std::string> expected_values;
 
   // Set the values of four existing policies.
   base::ListValue* restore_on_startup_urls = new base::ListValue;
   restore_on_startup_urls->Append(new base::StringValue("aaa"));
@@ skipping 67 matching lines @@
                              expected_values[kUnknownPolicy],
                              "Platform",
                              values.Get(kUnknownPolicy),
                              true));
 
   // Retrieve the contents of the policy table from the UI and verify that it
   // matches the expectation.
   VerifyPolicies(expected_policies);
 }
 
-IN_PROC_BROWSER_TEST_F(PolicyUITest, ExtensionLoadAndSendPolicy) {
-  ui_test_utils::NavigateToURL(browser(), GURL(chrome::kChromeUIPolicyURL));
+IN_PROC_BROWSER_TEST_P(PolicyUITest, ExtensionLoadAndSendPolicy) {
+  ui_test_utils::NavigateToURL(browser(), url());
   base::ScopedTempDir temp_dir_;
   ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
   const std::string newly_added_policy_name = "new_policy";
   std::string json_data = "{\"type\": \"object\",\"properties\": {\"" +
                           newly_added_policy_name +
                           "\": { \"type\": \"string\"}}}";
 
   const std::string schema_file = "schema.json";
   base::FilePath schema_path = temp_dir_.path().AppendASCII(schema_file);
@@ skipping 31 matching lines @@
         PopulateExpectedPolicy(
             it.key(), std::string(), std::string(), nullptr, false));
   }
   // Add newly added policy to expected policy list.
   expected_policies.push_back(PopulateExpectedPolicy(
       newly_added_policy_name, std::string(), std::string(), nullptr, false));
 
   // Verify if policy UI includes policy that extension have.
   VerifyPolicies(expected_policies);
 }
+
+INSTANTIATE_TEST_CASE_P(FlaggedPolicyUITest,
+                        PolicyUITest,
+                        testing::Bool());