Improve documentation for special-purpose policy providers.

components/policy/core/common/schema_registry_tracking_policy_provider_unittest.cc

Index: components/policy/core/common/schema_registry_tracking_policy_provider_unittest.cc
diff --git a/components/policy/core/common/forwarding_policy_provider_unittest.cc b/components/policy/core/common/schema_registry_tracking_policy_provider_unittest.cc
similarity index 66%
rename from components/policy/core/common/forwarding_policy_provider_unittest.cc
rename to components/policy/core/common/schema_registry_tracking_policy_provider_unittest.cc
index e546206790dea360ebe02450be08189c3cf8003c..c90d2eaf1823fba1062b1c0b6973ca57a19c18b8 100644
--- a/components/policy/core/common/forwarding_policy_provider_unittest.cc
+++ b/components/policy/core/common/schema_registry_tracking_policy_provider_unittest.cc
@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "components/policy/core/common/forwarding_policy_provider.h"
+#include "components/policy/core/common/schema_registry_tracking_policy_provider.h"
 
 #include <string>
 
@@ -17,9 +17,9 @@
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-using testing::_;
 using testing::Mock;
 using testing::Return;
+using testing::_;
 
 namespace policy {
 
@@ -35,17 +35,18 @@ const char kTestSchema[] =
 
 }  // namespace
 
-class ForwardingPolicyProviderTest : public testing::Test {
+class SchemaRegistryTrackingPolicyProviderTest : public testing::Test {
  protected:
-  ForwardingPolicyProviderTest() : forwarding_provider_(&mock_provider_) {
+  SchemaRegistryTrackingPolicyProviderTest()
+      : schema_registry_tracking_provider_(&mock_provider_) {
     mock_provider_.Init();
-    forwarding_provider_.Init(&schema_registry_);
-    forwarding_provider_.AddObserver(&observer_);
+    schema_registry_tracking_provider_.Init(&schema_registry_);
+    schema_registry_tracking_provider_.AddObserver(&observer_);
   }
 
-  ~ForwardingPolicyProviderTest() override {
-    forwarding_provider_.RemoveObserver(&observer_);
-    forwarding_provider_.Shutdown();
+  ~SchemaRegistryTrackingPolicyProviderTest() override {
+    schema_registry_tracking_provider_.RemoveObserver(&observer_);
+    schema_registry_tracking_provider_.Shutdown();
     mock_provider_.Shutdown();
   }
 
@@ -60,67 +61,68 @@ class ForwardingPolicyProviderTest : public testing::Test {
   SchemaRegistry schema_registry_;
   MockConfigurationPolicyObserver observer_;
   MockConfigurationPolicyProvider mock_provider_;
-  ForwardingPolicyProvider forwarding_provider_;
+  SchemaRegistryTrackingPolicyProvider schema_registry_tracking_provider_;
 };
 
-TEST_F(ForwardingPolicyProviderTest, Empty) {
+TEST_F(SchemaRegistryTrackingPolicyProviderTest, Empty) {
   EXPECT_FALSE(schema_registry_.IsReady());
-  EXPECT_FALSE(
-      forwarding_provider_.IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS));
+  EXPECT_FALSE(schema_registry_tracking_provider_.IsInitializationComplete(
+      POLICY_DOMAIN_EXTENSIONS));
 
   EXPECT_CALL(mock_provider_, IsInitializationComplete(POLICY_DOMAIN_CHROME))
       .WillOnce(Return(false));
-  EXPECT_FALSE(
-      forwarding_provider_.IsInitializationComplete(POLICY_DOMAIN_CHROME));
+  EXPECT_FALSE(schema_registry_tracking_provider_.IsInitializationComplete(
+      POLICY_DOMAIN_CHROME));
   Mock::VerifyAndClearExpectations(&mock_provider_);
 
   const PolicyBundle empty_bundle;
-  EXPECT_TRUE(forwarding_provider_.policies().Equals(empty_bundle));
+  EXPECT_TRUE(
+      schema_registry_tracking_provider_.policies().Equals(empty_bundle));
 }
 
-TEST_F(ForwardingPolicyProviderTest, ForwardsChromePolicy) {
+TEST_F(SchemaRegistryTrackingPolicyProviderTest, PassOnChromePolicy) {
   PolicyBundle bundle;
   const PolicyNamespace chrome_ns(POLICY_DOMAIN_CHROME, "");
   bundle.Get(chrome_ns).Set("policy",
                             POLICY_LEVEL_MANDATORY,
                             POLICY_SCOPE_USER,
-                            new base::StringValue("value"),
+                            new base::StringValue("visible"),
                             NULL);
 
-  EXPECT_CALL(observer_, OnUpdatePolicy(&forwarding_provider_));
+  EXPECT_CALL(observer_, OnUpdatePolicy(&schema_registry_tracking_provider_));
   scoped_ptr<PolicyBundle> delegate_bundle(new PolicyBundle);
   delegate_bundle->CopyFrom(bundle);
   delegate_bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "xyz"))
       .Set("foo",
            POLICY_LEVEL_MANDATORY,
            POLICY_SCOPE_USER,
-           new base::StringValue("not forwarded"),
+           new base::StringValue("not visible"),
            NULL);
   mock_provider_.UpdatePolicy(delegate_bundle.Pass());
   Mock::VerifyAndClearExpectations(&observer_);
 
-  EXPECT_FALSE(
-      forwarding_provider_.IsInitializationComplete(POLICY_DOMAIN_EXTENSIONS));
-  EXPECT_TRUE(forwarding_provider_.policies().Equals(bundle));
+  EXPECT_FALSE(schema_registry_tracking_provider_.IsInitializationComplete(
+      POLICY_DOMAIN_EXTENSIONS));
+  EXPECT_TRUE(schema_registry_tracking_provider_.policies().Equals(bundle));
 }
 
-TEST_F(ForwardingPolicyProviderTest, RefreshPolicies) {
+TEST_F(SchemaRegistryTrackingPolicyProviderTest, RefreshPolicies) {
   EXPECT_CALL(mock_provider_, RefreshPolicies());
-  forwarding_provider_.RefreshPolicies();
+  schema_registry_tracking_provider_.RefreshPolicies();
   Mock::VerifyAndClearExpectations(&mock_provider_);
 }
 
-TEST_F(ForwardingPolicyProviderTest, SchemaReady) {
-  EXPECT_CALL(observer_, OnUpdatePolicy(&forwarding_provider_));
+TEST_F(SchemaRegistryTrackingPolicyProviderTest, SchemaReady) {
+  EXPECT_CALL(observer_, OnUpdatePolicy(&schema_registry_tracking_provider_));
   schema_registry_.SetReady(POLICY_DOMAIN_CHROME);
   schema_registry_.SetReady(POLICY_DOMAIN_EXTENSIONS);
   Mock::VerifyAndClearExpectations(&observer_);
 
-  EXPECT_TRUE(forwarding_provider_.IsInitializationComplete(
+  EXPECT_TRUE(schema_registry_tracking_provider_.IsInitializationComplete(
       policy::POLICY_DOMAIN_EXTENSIONS));
 }
 
-TEST_F(ForwardingPolicyProviderTest, SchemaReadyWithComponents) {
+TEST_F(SchemaRegistryTrackingPolicyProviderTest, SchemaReadyWithComponents) {
   PolicyMap policy_map;
   policy_map.Set("foo",
                  POLICY_LEVEL_MANDATORY,
@@ -131,7 +133,7 @@ TEST_F(ForwardingPolicyProviderTest, SchemaReadyWithComponents) {
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_CHROME, "")).CopyFrom(policy_map);
   bundle->Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "xyz"))
       .CopyFrom(policy_map);
-  EXPECT_CALL(observer_, OnUpdatePolicy(&forwarding_provider_));
+  EXPECT_CALL(observer_, OnUpdatePolicy(&schema_registry_tracking_provider_));
   mock_provider_.UpdatePolicy(bundle.Pass());
   Mock::VerifyAndClearExpectations(&observer_);
 
@@ -145,29 +147,31 @@ TEST_F(ForwardingPolicyProviderTest, SchemaReadyWithComponents) {
   schema_registry_.SetReady(POLICY_DOMAIN_CHROME);
   Mock::VerifyAndClearExpectations(&mock_provider_);
 
-  EXPECT_FALSE(forwarding_provider_.IsInitializationComplete(
+  EXPECT_FALSE(schema_registry_tracking_provider_.IsInitializationComplete(
       policy::POLICY_DOMAIN_EXTENSIONS));
   PolicyBundle expected_bundle;
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_CHROME, ""))
       .CopyFrom(policy_map);
-  EXPECT_TRUE(forwarding_provider_.policies().Equals(expected_bundle));
+  EXPECT_TRUE(
+      schema_registry_tracking_provider_.policies().Equals(expected_bundle));
 
-  EXPECT_CALL(observer_, OnUpdatePolicy(&forwarding_provider_));
-  forwarding_provider_.OnUpdatePolicy(&mock_provider_);
+  EXPECT_CALL(observer_, OnUpdatePolicy(&schema_registry_tracking_provider_));
+  schema_registry_tracking_provider_.OnUpdatePolicy(&mock_provider_);
   Mock::VerifyAndClearExpectations(&observer_);
 
-  EXPECT_TRUE(forwarding_provider_.IsInitializationComplete(
+  EXPECT_TRUE(schema_registry_tracking_provider_.IsInitializationComplete(
       policy::POLICY_DOMAIN_EXTENSIONS));
   expected_bundle.Get(PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "xyz"))
       .CopyFrom(policy_map);
-  EXPECT_TRUE(forwarding_provider_.policies().Equals(expected_bundle));
+  EXPECT_TRUE(
+      schema_registry_tracking_provider_.policies().Equals(expected_bundle));
 }
 
-TEST_F(ForwardingPolicyProviderTest, DelegateUpdates) {
+TEST_F(SchemaRegistryTrackingPolicyProviderTest, DelegateUpdates) {
   schema_registry_.RegisterComponent(
       PolicyNamespace(POLICY_DOMAIN_EXTENSIONS, "xyz"), CreateTestSchema());
   EXPECT_FALSE(schema_registry_.IsReady());
-  EXPECT_FALSE(forwarding_provider_.IsInitializationComplete(
+  EXPECT_FALSE(schema_registry_tracking_provider_.IsInitializationComplete(
       policy::POLICY_DOMAIN_EXTENSIONS));
 
   PolicyMap policy_map;
@@ -176,8 +180,8 @@ TEST_F(ForwardingPolicyProviderTest, DelegateUpdates) {
                  POLICY_SCOPE_USER,
                  new base::StringValue("omg"),
                  NULL);
-  // Chrome policy updates are forwarded even if the components aren't ready.
-  EXPECT_CALL(observer_, OnUpdatePolicy(&forwarding_provider_));
+  // Chrome policy updates are visible even if the components aren't ready.
+  EXPECT_CALL(observer_, OnUpdatePolicy(&schema_registry_tracking_provider_));
   mock_provider_.UpdateChromePolicy(policy_map);
   Mock::VerifyAndClearExpectations(&observer_);
 
@@ -186,25 +190,25 @@ TEST_F(ForwardingPolicyProviderTest, DelegateUpdates) {
   schema_registry_.SetReady(POLICY_DOMAIN_EXTENSIONS);
   EXPECT_TRUE(schema_registry_.IsReady());
   Mock::VerifyAndClearExpectations(&mock_provider_);
-  EXPECT_FALSE(forwarding_provider_.IsInitializationComplete(
+  EXPECT_FALSE(schema_registry_tracking_provider_.IsInitializationComplete(
       policy::POLICY_DOMAIN_EXTENSIONS));
 
-  // The forwarding provider becomes ready after this refresh completes, and
-  // starts forwarding policy updates after that.
+  // The provider becomes ready after this refresh completes, and policy updates
+  // are visible after that.
   EXPECT_CALL(observer_, OnUpdatePolicy(_));
   mock_provider_.UpdateChromePolicy(policy_map);
   Mock::VerifyAndClearExpectations(&observer_);
 
-  EXPECT_TRUE(forwarding_provider_.IsInitializationComplete(
+  EXPECT_TRUE(schema_registry_tracking_provider_.IsInitializationComplete(
       policy::POLICY_DOMAIN_EXTENSIONS));
 
-  // Keeps forwarding.
+  // Updates continue to be visible.
   EXPECT_CALL(observer_, OnUpdatePolicy(_));
   mock_provider_.UpdateChromePolicy(policy_map);
   Mock::VerifyAndClearExpectations(&observer_);
 }
 
-TEST_F(ForwardingPolicyProviderTest, RemoveAndAddComponent) {
+TEST_F(SchemaRegistryTrackingPolicyProviderTest, RemoveAndAddComponent) {
   EXPECT_CALL(mock_provider_, RefreshPolicies());
   const PolicyNamespace ns(POLICY_DOMAIN_EXTENSIONS, "xyz");
   schema_registry_.SetReady(POLICY_DOMAIN_CHROME);
@@ -224,14 +228,15 @@ TEST_F(ForwardingPolicyProviderTest, RemoveAndAddComponent) {
   EXPECT_CALL(observer_, OnUpdatePolicy(_));
   mock_provider_.UpdatePolicy(copy.Pass());
   Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(forwarding_provider_.policies().Equals(platform_policy));
+  EXPECT_TRUE(
+      schema_registry_tracking_provider_.policies().Equals(platform_policy));
 
   // Now remove that component.
   EXPECT_CALL(observer_, OnUpdatePolicy(_));
   schema_registry_.UnregisterComponent(ns);
   Mock::VerifyAndClearExpectations(&observer_);
   const PolicyBundle empty;
-  EXPECT_TRUE(forwarding_provider_.policies().Equals(empty));
+  EXPECT_TRUE(schema_registry_tracking_provider_.policies().Equals(empty));
 
   // Adding it back should serve the current policies again, even though they
   // haven't changed on the platform provider.
@@ -244,7 +249,8 @@ TEST_F(ForwardingPolicyProviderTest, RemoveAndAddComponent) {
   copy->CopyFrom(platform_policy);
   mock_provider_.UpdatePolicy(copy.Pass());
   Mock::VerifyAndClearExpectations(&observer_);
-  EXPECT_TRUE(forwarding_provider_.policies().Equals(platform_policy));
+  EXPECT_TRUE(
+      schema_registry_tracking_provider_.policies().Equals(platform_policy));
 }
 
 }  // namespace policy