Add source column to chrome://policy showing the origins of policies.

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/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/run_loop.h"
@@ skipping 23 matching lines @@
 #include "url/gurl.h"
 
 using testing::Return;
 using testing::_;
 
 namespace {
 
 std::vector<std::string> PopulateExpectedPolicy(
     const std::string& name,
     const std::string& value,
+    const std::string& source,
     const policy::PolicyMap::Entry* metadata,
     bool unknown) {
   std::vector<std::string> expected_policy;
 
   // Populate expected scope.
   if (metadata) {
     expected_policy.push_back(l10n_util::GetStringUTF8(
         metadata->scope == policy::POLICY_SCOPE_MACHINE ?
             IDS_POLICY_SCOPE_DEVICE : IDS_POLICY_SCOPE_USER));
   } else {
     expected_policy.push_back(std::string());
   }
 
   // Populate expected level.
   if (metadata) {
     expected_policy.push_back(l10n_util::GetStringUTF8(
         metadata->level == policy::POLICY_LEVEL_RECOMMENDED ?
             IDS_POLICY_LEVEL_RECOMMENDED : IDS_POLICY_LEVEL_MANDATORY));
   } else {
     expected_policy.push_back(std::string());
   }
+  // Populate expected source name.
+  expected_policy.push_back(source);
 
   // Populate expected policy name.
   expected_policy.push_back(name);
 
   // Populate expected policy value.
   expected_policy.push_back(value);
 
   // Populate expected status.
   if (unknown)
     expected_policy.push_back(l10n_util::GetStringUTF8(IDS_POLICY_UNKNOWN));
@@ skipping 36 matching lines @@
 PolicyUITest::~PolicyUITest() {
 }
 
 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();
+  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"));
 
   // 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');"
@@ skipping 46 matching lines @@
 
   // 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(), NULL, false));
+        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) {
   // 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"));
   restore_on_startup_urls->Append(new base::StringValue("bbb"));
   restore_on_startup_urls->Append(new base::StringValue("ccc"));
   values.Set(policy::key::kRestoreOnStartupURLs,
              policy::POLICY_LEVEL_MANDATORY,
              policy::POLICY_SCOPE_USER,
+             policy::POLICY_SOURCE_CLOUD,
              restore_on_startup_urls,
              NULL);
   expected_values[policy::key::kRestoreOnStartupURLs] = "aaa,bbb,ccc";
   values.Set(policy::key::kHomepageLocation,
              policy::POLICY_LEVEL_MANDATORY,
              policy::POLICY_SCOPE_MACHINE,
+             policy::POLICY_SOURCE_CLOUD,
              new base::StringValue("http://google.com"),
              NULL);
   expected_values[policy::key::kHomepageLocation] = "http://google.com";
   values.Set(policy::key::kRestoreOnStartup,
              policy::POLICY_LEVEL_RECOMMENDED,
              policy::POLICY_SCOPE_USER,
+             policy::POLICY_SOURCE_CLOUD,
              new base::FundamentalValue(4),
              NULL);
   expected_values[policy::key::kRestoreOnStartup] = "4";
   values.Set(policy::key::kShowHomeButton,
              policy::POLICY_LEVEL_RECOMMENDED,
              policy::POLICY_SCOPE_MACHINE,
+             policy::POLICY_SOURCE_CLOUD,
              new base::FundamentalValue(true),
              NULL);
   expected_values[policy::key::kShowHomeButton] = "true";
   // Set the value of a policy that does not exist.
   const std::string kUnknownPolicy = "NoSuchThing";
   values.Set(kUnknownPolicy,
              policy::POLICY_LEVEL_MANDATORY,
              policy::POLICY_SCOPE_USER,
+             policy::POLICY_SOURCE_PLATFORM,
              new base::FundamentalValue(true),
              NULL);
   expected_values[kUnknownPolicy] = "true";
   UpdateProviderPolicy(values);
 
   // Expect that the policy table contains, in order:
   // * All known policies whose value has been set, in alphabetical order.
   // * The unknown policy.
   // * All known policies whose value has not been set, in alphabetical order.
   std::vector<std::vector<std::string> > expected_policies;
   size_t first_unset_position = 0;
   policy::Schema chrome_schema =
       policy::Schema::Wrap(policy::GetChromeSchemaData());
   ASSERT_TRUE(chrome_schema.valid());
   for (policy::Schema::Iterator props = chrome_schema.GetPropertiesIterator();
        !props.IsAtEnd(); props.Advance()) {
     std::map<std::string, std::string>::const_iterator it =
         expected_values.find(props.key());
     const std::string value =
         it == expected_values.end() ? std::string() : it->second;
+    const std::string source =
+        it == expected_values.end() ? std::string() : "Cloud";
     const policy::PolicyMap::Entry* metadata = values.Get(props.key());
     expected_policies.insert(
         metadata ? expected_policies.begin() + first_unset_position++ :
                    expected_policies.end(),
-        PopulateExpectedPolicy(props.key(), value, metadata, false));
+        PopulateExpectedPolicy(props.key(), value, source, metadata, false));
   }
   expected_policies.insert(
       expected_policies.begin() + first_unset_position++,
       PopulateExpectedPolicy(kUnknownPolicy,
                              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));
@@ skipping 31 matching lines @@
                                 0);
 
   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(), NULL, false));
+        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(), NULL, false));
+      newly_added_policy_name, std::string(), std::string(), nullptr, false));
 
   // Verify if policy UI includes policy that extension have.
   VerifyPolicies(expected_policies);
 }