Separate OncSource and PolicySource

This CL creates a separate PolicySource enum from the OncSource enum,
improves the documentation of each, and simplifies the code.

This also adds cr_policy_network_behavior_mojo.js for mojo api specific
policy behavior, and adds tests for the old and new behaviors.

Bug: 853953
Change-Id: I6a43247fd2a92db5451e52039f156edb05c56be4
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1717148
Commit-Queue: Steven Bennetts <stevenjb@chromium.org>
Reviewed-by: Alexander Hendrich <hendrich@chromium.org>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Kyle Horimoto <khorimoto@chromium.org>
Cr-Commit-Position: refs/heads/master@{#682068}

chrome/test/data/webui/cr_elements/cr_elements_browsertest.js

@@ -279,6 +279,52 @@ TEST_F('CrElementsPolicyPrefIndicatorTest', 'All', function() {
 });
 
 GEN('#if defined(OS_CHROMEOS)');
+/**
+ * @constructor
+ * @extends {CrElementsBrowserTest}
+ */
+function CrPolicyNetworkBehaviorTest() {}
+
+CrPolicyNetworkBehaviorTest.prototype = {
+  __proto__: CrElementsBrowserTest.prototype,
+
+  /** @override */
+  browsePreload: 'chrome://settings/internet_page/internet_page.html',
+
+  /** @override */
+  extraLibraries: CrElementsBrowserTest.prototype.extraLibraries.concat([
+    'cr_policy_strings.js',
+    'cr_policy_network_behavior_tests.js',
+  ]),
+};
+
+TEST_F('CrPolicyNetworkBehaviorTest', 'All', function() {
+  mocha.run();
+});
+
+/**
+ * @constructor
+ * @extends {CrElementsBrowserTest}
+ */
+function CrPolicyNetworkBehaviorMojoTest() {}
+
+CrPolicyNetworkBehaviorMojoTest.prototype = {
+  __proto__: CrElementsBrowserTest.prototype,
+
+  /** @override */
+  browsePreload: 'chrome://settings/internet_page/internet_page.html',
+
+  /** @override */
+  extraLibraries: CrElementsBrowserTest.prototype.extraLibraries.concat([
+    'cr_policy_strings.js',
+    'cr_policy_network_behavior_mojo_tests.js',
+  ]),
+};
+
+TEST_F('CrPolicyNetworkBehaviorMojoTest', 'All', function() {
+  mocha.run();
+});
+
 /**
  * @constructor
  * @extends {CrElementsBrowserTest}

chrome/test/data/webui/cr_elements/cr_policy_network_behavior_mojo_tests.js

+// Copyright 2019 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.
+
+/** @fileoverview Suite of tests for CrPolicyIndicatorBehavior. */
+suite('CrPolicyNetworkBehaviorMojo', function() {
+  suiteSetup(function() {
+    Polymer({
+      is: 'test-behavior',
+
+      behaviors: [CrPolicyNetworkBehaviorMojo],
+    });
+  });
+
+  let mojom;
+  let testBehavior;
+
+  setup(function() {
+    mojom = chromeos.networkConfig.mojom;
+    PolymerTest.clearBody();
+    testBehavior = document.createElement('test-behavior');
+    document.body.appendChild(testBehavior);
+  });
+
+  test('active', function() {
+    let property = {
+      activeValue: 'foo',
+      policySource: mojom.PolicySource.kNone,
+    };
+    assertFalse(testBehavior.isNetworkPolicyControlled(property));
+    assertFalse(testBehavior.isControlled(property));
+    assertFalse(testBehavior.isExtensionControlled(property));
+    assertTrue(testBehavior.isEditable(property));
+    assertFalse(testBehavior.isNetworkPolicyEnforced(property));
+    assertFalse(testBehavior.isNetworkPolicyRecommended(property));
+  });
+
+
+  test('user_recommended', function() {
+    let property = {
+      activeValue: 'foo',
+      policySource: mojom.PolicySource.kUserPolicyRecommended,
+      policyValue: 'bar',
+    };
+    assertTrue(testBehavior.isNetworkPolicyControlled(property));
+    assertTrue(testBehavior.isControlled(property));
+    assertFalse(testBehavior.isExtensionControlled(property));
+    assertTrue(testBehavior.isEditable(property));
+    assertFalse(testBehavior.isNetworkPolicyEnforced(property));
+    assertTrue(testBehavior.isNetworkPolicyRecommended(property));
+    assertEquals(
+        CrPolicyIndicatorType.USER_POLICY,
+        testBehavior.getPolicyIndicatorType(property));
+  });
+
+  test('device_recommended', function() {
+    let property = {
+      activeValue: 'foo',
+      policySource: mojom.PolicySource.kDevicePolicyRecommended,
+      policyValue: 'bar',
+    };
+    assertTrue(testBehavior.isNetworkPolicyControlled(property));
+    assertTrue(testBehavior.isControlled(property));
+    assertFalse(testBehavior.isExtensionControlled(property));
+    assertTrue(testBehavior.isEditable(property));
+    assertFalse(testBehavior.isNetworkPolicyEnforced(property));
+    assertTrue(testBehavior.isNetworkPolicyRecommended(property));
+    assertEquals(
+        CrPolicyIndicatorType.DEVICE_POLICY,
+        testBehavior.getPolicyIndicatorType(property));
+  });
+
+  test('user_enforced', function() {
+    let property = {
+      activeValue: 'foo',
+      policySource: mojom.PolicySource.kUserPolicyEnforced,
+      policyValue: 'foo',
+    };
+    assertTrue(testBehavior.isNetworkPolicyControlled(property));
+    assertTrue(testBehavior.isControlled(property));
+    assertFalse(testBehavior.isExtensionControlled(property));
+    assertFalse(testBehavior.isEditable(property));
+    assertTrue(testBehavior.isNetworkPolicyEnforced(property));
+    assertFalse(testBehavior.isNetworkPolicyRecommended(property));
+    assertEquals(
+        CrPolicyIndicatorType.USER_POLICY,
+        testBehavior.getPolicyIndicatorType(property));
+  });
+
+  test('device_enforced', function() {
+    let property = {
+      activeValue: 'foo',
+      policySource: mojom.PolicySource.kDevicePolicyEnforced,
+      policyValue: 'foo',
+    };
+    assertTrue(testBehavior.isNetworkPolicyControlled(property));
+    assertTrue(testBehavior.isControlled(property));
+    assertFalse(testBehavior.isExtensionControlled(property));
+    assertFalse(testBehavior.isEditable(property));
+    assertTrue(testBehavior.isNetworkPolicyEnforced(property));
+    assertFalse(testBehavior.isNetworkPolicyRecommended(property));
+    assertEquals(
+        CrPolicyIndicatorType.DEVICE_POLICY,
+        testBehavior.getPolicyIndicatorType(property));
+  });
+
+  test('extension_controlled', function() {
+    let property = {
+      activeValue: 'foo',
+      policySource: mojom.PolicySource.kActiveExtension,
+    };
+    assertFalse(testBehavior.isNetworkPolicyControlled(property));
+    assertTrue(testBehavior.isControlled(property));
+    assertTrue(testBehavior.isExtensionControlled(property));
+    assertFalse(testBehavior.isEditable(property));
+    assertFalse(testBehavior.isNetworkPolicyEnforced(property));
+    assertFalse(testBehavior.isNetworkPolicyRecommended(property));
+
+    assertEquals(
+        CrPolicyIndicatorType.EXTENSION,
+        testBehavior.getPolicyIndicatorType(property));
+  });
+});

chrome/test/data/webui/cr_elements/cr_policy_network_behavior_tests.js

+// Copyright 2019 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.
+
+/** @fileoverview Suite of tests for CrPolicyIndicatorBehavior. */
+suite('CrPolicyNetworkBehavior', function() {
+  suiteSetup(function() {
+    Polymer({
+      is: 'test-behavior',
+
+      behaviors: [CrPolicyNetworkBehavior],
+    });
+  });
+
+  let testBehavior;
+  setup(function() {
+    PolymerTest.clearBody();
+    testBehavior = document.createElement('test-behavior');
+    document.body.appendChild(testBehavior);
+  });
+
+  test('pod', function() {
+    let property = 'foo';
+    assertFalse(testBehavior.isNetworkPolicyControlled(property));
+    assertFalse(testBehavior.isControlled(property));
+    assertFalse(testBehavior.isExtensionControlled(property));
+    assertFalse(testBehavior.isEditable(property));
+    assertFalse(testBehavior.isNetworkPolicyEnforced(property));
+    assertFalse(testBehavior.isNetworkPolicyRecommended(property));
+  });
+
+  test('active', function() {
+    let property = {'Active': 'foo'};
+    assertFalse(testBehavior.isNetworkPolicyControlled(property));
+    assertFalse(testBehavior.isControlled(property));
+    assertFalse(testBehavior.isExtensionControlled(property));
+    assertFalse(testBehavior.isEditable(property));
+    assertFalse(testBehavior.isNetworkPolicyEnforced(property));
+    assertFalse(testBehavior.isNetworkPolicyRecommended(property));
+  });
+
+  test('user_recommended', function() {
+    let properties = {
+      'Source': 'UserPolicy',
+      'a': {
+        'Effective': 'UserSetting',
+        'UserEditable': true,
+        'UserPolicy': 'bar',
+        'UserSetting': 'foo',
+      }
+    };
+    assertTrue(testBehavior.isNetworkPolicyControlled(properties.a));
+    assertTrue(testBehavior.isControlled(properties.a));
+    assertFalse(testBehavior.isExtensionControlled(properties.a));
+    assertTrue(testBehavior.isEditable(properties.a));
+    assertFalse(testBehavior.isNetworkPolicyEnforced(properties.a));
+    assertTrue(testBehavior.isNetworkPolicyRecommended(properties.a));
+    assertEquals(
+        CrPolicyIndicatorType.USER_POLICY,
+        testBehavior.getPolicyIndicatorType_(properties, 'a'));
+  });
+
+  test('device_recommended', function() {
+    let properties = {
+      'Source': 'DevicePolicy',
+      'a': {
+        'Effective': 'DeviceSetting',
+        'DeviceEditable': true,
+        'DevicePolicy': 'bar',
+        'DeviceSetting': 'foo',
+      }
+    };
+    assertTrue(testBehavior.isNetworkPolicyControlled(properties.a));
+    assertTrue(testBehavior.isControlled(properties.a));
+    assertFalse(testBehavior.isExtensionControlled(properties.a));
+    assertTrue(testBehavior.isEditable(properties.a));
+    assertFalse(testBehavior.isNetworkPolicyEnforced(properties.a));
+    assertTrue(testBehavior.isNetworkPolicyRecommended(properties.a));
+    assertEquals(
+        CrPolicyIndicatorType.DEVICE_POLICY,
+        testBehavior.getPolicyIndicatorType_(properties, 'a'));
+  });
+
+  test('user_enforced', function() {
+    let properties = {
+      'Source': 'UserPolicy',
+      'a': {
+        'Effective': 'UserPolicy',
+        'UserEditable': false,
+        'UserPolicy': 'bar',
+      }
+    };
+    assertTrue(testBehavior.isNetworkPolicyControlled(properties.a));
+    assertTrue(testBehavior.isControlled(properties.a));
+    assertFalse(testBehavior.isExtensionControlled(properties.a));
+    assertFalse(testBehavior.isEditable(properties.a));
+    assertTrue(testBehavior.isNetworkPolicyEnforced(properties.a));
+    assertFalse(testBehavior.isNetworkPolicyRecommended(properties.a));
+    assertEquals(
+        CrPolicyIndicatorType.USER_POLICY,
+        testBehavior.getPolicyIndicatorType_(properties, 'a'));
+  });
+
+  test('device_enforced', function() {
+    let properties = {
+      'Source': 'DevicePolicy',
+      'a': {
+        'Effective': 'DevicePolicy',
+        'DeviceEditable': false,
+        'DevicePolicy': 'bar',
+      }
+    };
+    assertTrue(testBehavior.isNetworkPolicyControlled(properties.a));
+    assertTrue(testBehavior.isControlled(properties.a));
+    assertFalse(testBehavior.isExtensionControlled(properties.a));
+    assertFalse(testBehavior.isEditable(properties.a));
+    assertTrue(testBehavior.isNetworkPolicyEnforced(properties.a));
+    assertFalse(testBehavior.isNetworkPolicyRecommended(properties.a));
+    assertEquals(
+        CrPolicyIndicatorType.DEVICE_POLICY,
+        testBehavior.getPolicyIndicatorType_(properties, 'a'));
+  });
+
+  test('extension_controlled', function() {
+    let properties = {
+      'Source': 'UserPolicy',
+      'a': {
+        'Active': 'bar',
+        'Effective': 'ActiveExtension',
+        'UserEditable': false,
+      }
+    };
+    assertFalse(testBehavior.isNetworkPolicyControlled(properties.a));
+    assertTrue(testBehavior.isControlled(properties.a));
+    assertTrue(testBehavior.isExtensionControlled(properties.a));
+    assertFalse(testBehavior.isEditable(properties.a));
+    assertFalse(testBehavior.isNetworkPolicyEnforced(properties.a));
+    assertFalse(testBehavior.isNetworkPolicyRecommended(properties.a));
+
+    // TODO(stevenjb): We should probably show the correct indicator for
+    // extension controlled properties; fix this in the mojo code.
+    assertEquals(
+        CrPolicyIndicatorType.NONE,
+        testBehavior.getPolicyIndicatorType_(properties, 'a'));
+  });
+});

chromeos/services/network_config/cros_network_config_unittest.cc

@@ -80,6 +80,7 @@ class CrosNetworkConfigTest : public testing::Test {
     base::Value wifi2_onc = base::Value::FromUniquePtrValue(
         onc::ReadDictionaryFromJson(base::StringPrintf(
             R"({"GUID": "wifi2_guid", "Type": "WiFi",
+                "Name": "wifi2", "Priority": 0,
                 "WiFi": { "Passphrase": "fake", "SSID": "%s", "HexSSID": "%s",
                           "Security": "WPA-PSK"}})",
             user_policy_ssid.c_str(),
@@ -431,10 +432,6 @@ TEST_F(CrosNetworkConfigTest, GetManagedProperties) {
             properties->connection_state);
   ASSERT_TRUE(properties->wifi);
   EXPECT_EQ(::onc::wifi::kWPA_PSK, properties->wifi->security->active_value);
-  EXPECT_EQ(mojom::OncSource::kUserPolicy,
-            properties->wifi->security->effective_source);
-  EXPECT_EQ(::onc::wifi::kWPA_PSK,
-            *properties->wifi->security->effective_value);
   EXPECT_EQ(100, properties->wifi->signal_strength);
 
   properties = GetManagedProperties("cellular_guid");
@@ -457,7 +454,38 @@ TEST_F(CrosNetworkConfigTest, GetManagedProperties) {
             properties->connection_state);
   ASSERT_TRUE(properties->vpn);
   EXPECT_EQ(::onc::vpn::kTypeL2TP_IPsec, properties->vpn->type->active_value);
-  EXPECT_EQ(mojom::OncSource::kNone, properties->vpn->type->effective_source);
+}
+
+// Test managed property policy values.
+TEST_F(CrosNetworkConfigTest, GetManagedPropertiesPolicy) {
+  mojom::ManagedPropertiesPtr properties = GetManagedProperties("wifi2_guid");
+  ASSERT_TRUE(properties);
+  ASSERT_EQ("wifi2_guid", properties->guid);
+  ASSERT_TRUE(properties->name);
+  EXPECT_EQ("wifi2", properties->name->active_value);
+  EXPECT_EQ(mojom::PolicySource::kUserPolicyEnforced,
+            properties->name->policy_source);
+  EXPECT_EQ("wifi2", properties->name->policy_value);
+  ASSERT_TRUE(properties->priority);
+  EXPECT_EQ(0, properties->priority->active_value);
+  EXPECT_EQ(mojom::PolicySource::kUserPolicyEnforced,
+            properties->priority->policy_source);
+  EXPECT_EQ(0, properties->priority->policy_value);
+
+  ASSERT_EQ(mojom::NetworkType::kWiFi, properties->type);
+  ASSERT_TRUE(properties->wifi);
+  EXPECT_EQ(::onc::wifi::kWPA_PSK, properties->wifi->security->active_value);
+  EXPECT_EQ(mojom::PolicySource::kUserPolicyEnforced,
+            properties->wifi->security->policy_source);
+  EXPECT_EQ(::onc::wifi::kWPA_PSK, *properties->wifi->security->policy_value);
+
+  properties = GetManagedProperties("vpn_guid");
+  ASSERT_TRUE(properties);
+  ASSERT_EQ("vpn_guid", properties->guid);
+  ASSERT_EQ(mojom::NetworkType::kVPN, properties->type);
+  ASSERT_TRUE(properties->vpn);
+  EXPECT_EQ(::onc::vpn::kTypeL2TP_IPsec, properties->vpn->type->active_value);
+  EXPECT_EQ(mojom::PolicySource::kNone, properties->vpn->type->policy_source);
 }
 
 TEST_F(CrosNetworkConfigTest, SetNetworkTypeEnabledState) {

chromeos/services/network_config/public/mojom/cros_network_config.mojom

@@ -64,20 +64,35 @@ enum NetworkType {
   kWiMAX,
 };
 
-// The ONC source for networks. Also used for the source of policy effective
-// values (see Manged{Boolean|Int32|String}).
+// The ONC source for the network configuration, i.e. whether it is stored in
+// the User or Device profile and whether it was configured by policy.
 enum OncSource {
-  // No source indicates that the network is not remembered.
+  // The network is not remembered, or the property is not configurable.
   kNone,
-  // The network configuration is saved in the device profile.
-  kDevice,
-  // The network configuration came from a device policy.
-  kDevicePolicy,
-  // The network configuration is saved in the user profile.
+  // The configuration is saved in the user profile.
   kUser,
-  // The network configuration came from a user policy.
+  // The configuration is saved in the device profile.
+  kDevice,
+  // The configuration came from a user policy and is saved in the user profile.
   kUserPolicy,
-  // Special setting for effective values provided by an active extension.
+  // The configuration came from a device policy and is saved in the device
+  // profile.
+  kDevicePolicy,
+};
+
+// The policy source for property values managed by policy.
+enum PolicySource {
+  // The property is not controlled by policy.
+  kNone,
+  // The property value came from a user policy and is enforced.
+  kUserPolicyEnforced,
+  // The property value came from a device policy and is enforced.
+  kDevicePolicyEnforced,
+  // The property value came from a user policy and is recommended.
+  kUserPolicyRecommended,
+  // The property value came from a device policy and is recommended.
+  kDevicePolicyRecommended,
+  // The property value came from an extension.
   kActiveExtension,
 };
 
@@ -305,44 +320,39 @@ struct PaymentPortalProperties {
 
 // Managed property types. These types all share a common structure.
 // The structure differs from the structure used in //components/onc which
-// relies on optional boolean and integer values, which are unsupported in mojo,
+// relies on optional boolean and integer values which are unsupported in mojo,
 // and provides more detail than is required by the UI.
 
-// active_value: Either the value provided by the configuration manager
-//     (e.g. Shill) if available, or |effective_value|.
-// effective_source: The effective source for the property (see OncSource).
-// effective_value: The value provided by the effective source (e.g. policy).
-// enforced: Whether |effective_value| is enforced by a policy. If false,
-//     |effective_value| is only recommended by the policy.
+// active_value: The value provided by the configuration manager (e.g. Shill).
+//     This will match |policy_value| when |policy_source| is enforced.
+// policy_source: The source of the value provided by policy when available,
+//     or kNone (see PolicySource).
+// policy_value: The value provided by policy when available.
 
 // Fundamental managed types.
 
 struct ManagedBoolean {
   bool active_value;
-  OncSource effective_source = kNone;
-  bool effective_value = false;
-  bool enforced = false;
+  PolicySource policy_source = kNone;
+  bool policy_value = false;
 };
 
 struct ManagedInt32 {
   int32 active_value = 0;
-  OncSource effective_source = kNone;
-  int32 effective_value = 0;
-  bool enforced = false;
+  PolicySource policy_source = kNone;
+  int32 policy_value = 0;
 };
 
 struct ManagedString {
   string active_value;
-  OncSource effective_source = kNone;
-  string? effective_value;
-  bool enforced = false;
+  PolicySource policy_source = kNone;
+  string? policy_value;
 };
 
 struct ManagedStringList {
   array<string> active_value;
-  OncSource effective_source = kNone;
-  array<string>? effective_value;
-  bool enforced = false;
+  PolicySource policy_source = kNone;
+  array<string>? policy_value;
 };
 
 // Specialized managed types.
@@ -359,9 +369,8 @@ struct ManagedApnProperties {
 
 struct ManagedApnList {
   array<ApnProperties> active_value;
-  OncSource effective_source = kNone;
-  array<ApnProperties>? effective_value;
-  bool enforced = false;
+  PolicySource policy_source = kNone;
+  array<ApnProperties>? policy_value;
 };
 
 struct ManagedIssuerSubjectPattern {

extensions/common/api/networking_private.idl

@@ -217,6 +217,7 @@ namespace networkingPrivate {
   dictionary CertificatePattern {
     DOMString[]? EnrollmentURI;
     IssuerSubjectPattern? Issuer;
+    DOMString[]? IssuerCAPEMs;
     DOMString[]? IssuerCARef;
     IssuerSubjectPattern? Subject;
   };

ui/webui/resources/cr_elements/policy/BUILD.gn

@@ -15,6 +15,7 @@ js_type_check("closure_compile") {
   if (is_chromeos) {
     deps += [
       ":cr_policy_network_behavior",
+      ":cr_policy_network_behavior_mojo",
       ":cr_policy_network_indicator",
     ]
   }
@@ -56,6 +57,16 @@ if (is_chromeos) {
     ]
   }
 
+  js_library("cr_policy_network_behavior_mojo") {
+    deps = [
+      ":cr_policy_indicator_behavior",
+      "../../js/chromeos:onc_mojo",
+      "../chromeos/network:cr_onc_types",
+      "//chromeos/services/network_config/public/mojom:mojom_js_library_for_compile",
+      "//ui/webui/resources/cr_components/chromeos/network:mojo_interface_provider",
+    ]
+  }
+
   js_library("cr_policy_network_indicator") {
     deps = [
       ":cr_policy_indicator_behavior",

ui/webui/resources/cr_elements/policy/cr_policy_network_behavior.html

+<link rel="import" href="../../html/polymer.html">
 <link rel="import" href="../chromeos/network/cr_onc_types.html">
+<link rel="import" href="cr_policy_indicator_behavior.html">
 <script src="cr_policy_network_behavior.js"></script>

ui/webui/resources/cr_elements/policy/cr_policy_network_behavior_mojo.html

+<link rel="import" href="../../html/polymer.html">
+<link rel="import" href="cr_policy_indicator_behavior.html">
+<script src="cr_policy_network_behavior_mojo.js"></script>

ui/webui/resources/cr_elements/policy/cr_policy_network_behavior_mojo.js

+// Copyright 2015 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.
+
+/**
+ * @fileoverview Behavior for policy controlled network properties.
+ */
+
+/** @polymerBehavior */
+const CrPolicyNetworkBehaviorMojo = {
+  /**
+   * @param {!OncMojo.ManagedProperty} property
+   * @return {boolean} True if the property is controlled by network policy.
+   */
+  isNetworkPolicyControlled: function(property) {
+    const mojom = chromeos.networkConfig.mojom;
+    return property.policySource != mojom.PolicySource.kNone &&
+        property.policySource != mojom.PolicySource.kActiveExtension;
+  },
+
+  /**
+   * @param {!OncMojo.ManagedProperty} property
+   * @return {boolean} True if the property is controlled by an extension.
+   */
+  isExtensionControlled: function(property) {
+    return property.policySource ==
+        chromeos.networkConfig.mojom.PolicySource.kActiveExtension;
+  },
+
+  /**
+   * @param {!OncMojo.ManagedProperty} property
+   * @return {boolean} True if the network property is controlled by a network
+   *     policy or an extension.
+   */
+  isControlled: function(property) {
+    return property.policySource !=
+        chromeos.networkConfig.mojom.PolicySource.kNone;
+  },
+
+  /**
+   * @param {!OncMojo.ManagedProperty} property
+   * @return {boolean} True if the network property is editable.
+   */
+  isEditable: function(property) {
+    const mojom = chromeos.networkConfig.mojom;
+    return property.policySource != mojom.PolicySource.kUserPolicyEnforced &&
+        property.policySource != mojom.PolicySource.kDevicePolicyEnforced &&
+        property.policySource != mojom.PolicySource.kActiveExtension;
+  },
+
+  /**
+   * @param {!OncMojo.ManagedProperty} property
+   * @return {boolean} True if the network property is enforced by a policy.
+   */
+  isNetworkPolicyEnforced: function(property) {
+    const mojom = chromeos.networkConfig.mojom;
+    return property.policySource == mojom.PolicySource.kUserPolicyEnforced ||
+        property.policySource == mojom.PolicySource.kDevicePolicyEnforced;
+  },
+
+  /**
+   * @param {!CrOnc.ManagedProperty} property
+   * @return {boolean} True if the network property is recommended by a policy.
+   */
+  isNetworkPolicyRecommended: function(property) {
+    const mojom = chromeos.networkConfig.mojom;
+    return property.policySource == mojom.PolicySource.kUserPolicyRecommended ||
+        property.policySource == mojom.PolicySource.kDevicePolicyRecommended;
+  },
+
+  /**
+   * @param {!chromeos.networkConfig.mojom.OncSource} source
+   * @return {boolean}
+   * @protected
+   */
+  isPolicySource: function(source) {
+    return source == chromeos.networkConfig.mojom.OncSource.kDevicePolicy ||
+        source == chromeos.networkConfig.mojom.OncSource.kUserPolicy;
+  },
+
+  /**
+   * @param {!chromeos.networkConfig.mojom.OncSource} source
+   * @return {!CrPolicyIndicatorType}
+   * @private
+   */
+  getIndicatorTypeForSource: function(source) {
+    if (source == chromeos.networkConfig.mojom.OncSource.kDevicePolicy) {
+      return CrPolicyIndicatorType.DEVICE_POLICY;
+    }
+    if (source == chromeos.networkConfig.mojom.OncSource.kUserPolicy) {
+      return CrPolicyIndicatorType.USER_POLICY;
+    }
+    return CrPolicyIndicatorType.NONE;
+  },
+
+  /**
+   * Get policy indicator type for the setting at |path|.
+   * @param {!CrOnc.ManagedProperty} property
+   * @return {CrPolicyIndicatorType}
+   */
+  getPolicyIndicatorType: function(property) {
+    const mojom = chromeos.networkConfig.mojom;
+    if (property.policySource == mojom.PolicySource.kUserPolicyEnforced ||
+        property.policySource == mojom.PolicySource.kUserPolicyRecommended) {
+      return CrPolicyIndicatorType.USER_POLICY;
+    }
+    if (property.policySource == mojom.PolicySource.kDevicePolicyEnforced ||
+        property.policySource == mojom.PolicySource.kDevicePolicyRecommended) {
+      return CrPolicyIndicatorType.DEVICE_POLICY;
+    }
+    if (property.policySource == mojom.PolicySource.kActiveExtension) {
+      return CrPolicyIndicatorType.EXTENSION;
+    }
+    return CrPolicyIndicatorType.NONE;
+  },
+};

ui/webui/resources/cr_elements/policy/cr_policy_network_indicator.html

@@ -3,6 +3,11 @@
 <link rel="import" href="../hidden_style_css.html">
 <link rel="import" href="cr_policy_indicator_behavior.html">
 <link rel="import" href="cr_policy_network_behavior.html">
+<!-- Currently cr_policy_network_behavior_mojo.html is included only for testing
+     in cr_policy_network_behavior_mojo_tests.js which requires the behavior to
+     be loaded from an html file that the browser knows about.
+     TODO(853953): Convert this class to use the mojo API. -->
+<link rel="import" href="cr_policy_network_behavior_mojo.html">
 <link rel="import" href="cr_tooltip_icon.html">
 
 <dom-module id="cr-policy-network-indicator">

ui/webui/resources/cr_elements_resources.grdp

@@ -298,6 +298,14 @@
                file="cr_elements/policy/cr_policy_network_behavior.js"
                type="chrome_html"
                compress="gzip" />
+    <structure name="IDR_CR_ELEMENTS_CR_POLICY_NETWORK_BEHAVIOR_MOJO_HTML"
+               file="cr_elements/policy/cr_policy_network_behavior_mojo.html"
+               type="chrome_html"
+               compress="gzip" />
+    <structure name="IDR_CR_ELEMENTS_CR_POLICY_NETWORK_BEHAVIOR_MOJO_JS"
+               file="cr_elements/policy/cr_policy_network_behavior_mojo.js"
+               type="chrome_html"
+               compress="gzip" />
     <structure name="IDR_CR_ELEMENTS_CR_POLICY_NETWORK_INDICATOR_JS"
                file="cr_elements/policy/cr_policy_network_indicator.js"
                type="chrome_html"

ui/webui/resources/js/chromeos/onc_mojo.js

@@ -632,3 +632,12 @@ OncMojo.DeviceStateProperties;
 
 /** @typedef {chromeos.networkConfig.mojom.NetworkStateProperties} */
 OncMojo.NetworkStateProperties;
+
+/**
+ * @typedef {chromeos.networkConfig.mojom.ManagedBoolean|
+ *           chromeos.networkConfig.mojom.ManagedInt32|
+ *           chromeos.networkConfig.mojom.ManagedString|
+ *           chromeos.networkConfig.mojom.ManagedStringList|
+ *           chromeos.networkConfig.mojom.ManagedApnList}
+ */
+OncMojo.ManagedProperty;