Refactor PolicyWatcher to allow mocking

remoting/host/policy_watcher.cc

 // 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.
 
 // Most of this code is copied from:
 //   src/chrome/browser/policy/asynchronous_policy_loader.{h,cc}
 
 #include "remoting/host/policy_watcher.h"
 
 #include <utility>
@@ skipping 29 matching lines @@
 #elif defined(OS_POSIX) && !defined(OS_ANDROID)
 #include "components/policy/core/common/config_dir_policy_loader.h"
 #endif
 
 namespace remoting {
 
 namespace key = ::policy::key;
 
 namespace {
 
+// Watches for changes to the managed remote access host policies.
+class PolicyWatcherImpl : public PolicyWatcher,
+                          private policy::PolicyService::Observer {
+ public:
+  // |policy_service_task_runner| is the task runner where it is safe
+  // to call |policy_service_| methods and where we expect to get callbacks
+  // from |policy_service_|.
+  PolicyWatcherImpl(
+      policy::PolicyService* policy_service,
+      std::unique_ptr<policy::PolicyService> owned_policy_service,
+      std::unique_ptr<policy::ConfigurationPolicyProvider>
+          owned_policy_provider,
+      std::unique_ptr<policy::SchemaRegistry> owned_schema_registry);
+
+  ~PolicyWatcherImpl() override;
+
+  void StartWatching(const PolicyUpdatedCallback& policy_updated_callback,
+                     const PolicyErrorCallback& policy_error_callback) override;
+
+ private:
+  friend class PolicyWatcherTest;
+
+  const policy::Schema* GetPolicySchema() const override;
+  const base::DictionaryValue* GetDefaultValues() const override;
+
+  // Simplifying wrapper around Schema::Normalize.
+  // - Returns false if |dict| is invalid (i.e. contains mistyped policy
+  // values).
+  // - Returns true if |dict| was valid or got normalized.
+  bool NormalizePolicies(base::DictionaryValue* dict);
+
+  // Stores |new_policies| into |old_policies_|.  Returns dictionary with items
+  // from |new_policies| that are different from the old |old_policies_|.
+  std::unique_ptr<base::DictionaryValue> StoreNewAndReturnChangedPolicies(
+      std::unique_ptr<base::DictionaryValue> new_policies);
+
+  // Signals policy error to the registered |PolicyErrorCallback|.
+  void SignalPolicyError();
+
+  // PolicyService::Observer interface.
+  void OnPolicyUpdated(const policy::PolicyNamespace& ns,
+                       const policy::PolicyMap& previous,
+                       const policy::PolicyMap& current) override;
+  void OnPolicyServiceInitialized(policy::PolicyDomain domain) override;
+
+  PolicyUpdatedCallback policy_updated_callback_;
+  PolicyErrorCallback policy_error_callback_;
+
+  std::unique_ptr<base::DictionaryValue> old_policies_;
+  std::unique_ptr<base::DictionaryValue> default_values_;
+
+  policy::PolicyService* policy_service_;
+
+  // Order of fields below is important to ensure destruction takes object
+  // dependencies into account:
+  // - |owned_policy_service_| uses |owned_policy_provider_|
+  // - |owned_policy_provider_| uses |owned_schema_registry_|
+  std::unique_ptr<policy::SchemaRegistry> owned_schema_registry_;
+  std::unique_ptr<policy::ConfigurationPolicyProvider> owned_policy_provider_;
+  std::unique_ptr<policy::PolicyService> owned_policy_service_;
+
+  DISALLOW_COPY_AND_ASSIGN(PolicyWatcherImpl);
+};
+
 // Copies all policy values from one dictionary to another, using values from
 // |default_values| if they are not set in |from|.
 std::unique_ptr<base::DictionaryValue> CopyValuesAndAddDefaults(
     const base::DictionaryValue& from,
     const base::DictionaryValue& default_values) {
   std::unique_ptr<base::DictionaryValue> to(default_values.CreateDeepCopy());
   for (base::DictionaryValue::Iterator i(default_values); !i.IsAtEnd();
        i.Advance()) {
     const base::Value* value = nullptr;
 
@@ skipping 69 matching lines @@
                                  &udp_port_range_string)) {
     if (!PortRange::Parse(udp_port_range_string, &udp_port_range)) {
       return false;
     }
   }
 
   // Report that all the policies were well-formed.
   return true;
 }
 
-}  // namespace
+void CopyDictionaryValue(const base::DictionaryValue& from,
+                         base::DictionaryValue& to,
+                         std::string key) {
+  const base::Value* value;
+  if (from.Get(key, &value)) {
+    to.Set(key, value->CreateDeepCopy());
+  }
+}
 
-void PolicyWatcher::StartWatching(
+void PolicyWatcherImpl::StartWatching(
     const PolicyUpdatedCallback& policy_updated_callback,
     const PolicyErrorCallback& policy_error_callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(!policy_updated_callback.is_null());
   DCHECK(!policy_error_callback.is_null());
   DCHECK(policy_updated_callback_.is_null());
 
   policy_updated_callback_ = policy_updated_callback;
   policy_error_callback_ = policy_error_callback;
 
   // Listen for future policy changes.
   policy_service_->AddObserver(policy::POLICY_DOMAIN_CHROME, this);
 
   // Process current policy state.
   if (policy_service_->IsInitializationComplete(policy::POLICY_DOMAIN_CHROME)) {
     OnPolicyServiceInitialized(policy::POLICY_DOMAIN_CHROME);
   }
 }
 
-void PolicyWatcher::SignalPolicyError() {
+void PolicyWatcherImpl::SignalPolicyError() {
   old_policies_->Clear();
   policy_error_callback_.Run();
 }
 
-PolicyWatcher::PolicyWatcher(
+PolicyWatcherImpl::PolicyWatcherImpl(
     policy::PolicyService* policy_service,
     std::unique_ptr<policy::PolicyService> owned_policy_service,
     std::unique_ptr<policy::ConfigurationPolicyProvider> owned_policy_provider,
     std::unique_ptr<policy::SchemaRegistry> owned_schema_registry)
     : old_policies_(new base::DictionaryValue()),
       default_values_(new base::DictionaryValue()),
       policy_service_(policy_service),
       owned_schema_registry_(std::move(owned_schema_registry)),
       owned_policy_provider_(std::move(owned_policy_provider)),
       owned_policy_service_(std::move(owned_policy_service)) {
@@ skipping 15 matching lines @@
       key::kRemoteAccessHostTokenValidationCertificateIssuer, std::string());
   default_values_->SetBoolean(key::kRemoteAccessHostAllowClientPairing, true);
   default_values_->SetBoolean(key::kRemoteAccessHostAllowGnubbyAuth, true);
   default_values_->SetBoolean(key::kRemoteAccessHostAllowRelayedConnection,
                               true);
   default_values_->SetString(key::kRemoteAccessHostUdpPortRange, "");
   default_values_->SetBoolean(
       key::kRemoteAccessHostAllowUiAccessForRemoteAssistance, false);
 }
 
-PolicyWatcher::~PolicyWatcher() {
+PolicyWatcherImpl::~PolicyWatcherImpl() {
   // Stop observing |policy_service_| if StartWatching() has been called.
   if (!policy_updated_callback_.is_null()) {
     policy_service_->RemoveObserver(policy::POLICY_DOMAIN_CHROME, this);
   }
 
   if (owned_policy_provider_) {
     owned_policy_provider_->Shutdown();
   }
 }
 
-const policy::Schema* PolicyWatcher::GetPolicySchema() const {
+const policy::Schema* PolicyWatcherImpl::GetPolicySchema() const {
   return owned_schema_registry_->schema_map()->GetSchema(GetPolicyNamespace());
 }
 
-bool PolicyWatcher::NormalizePolicies(base::DictionaryValue* policy_dict) {
+const base::DictionaryValue* PolicyWatcherImpl::GetDefaultValues() const {
+  return default_values_.get();
+}
+
+bool PolicyWatcherImpl::NormalizePolicies(base::DictionaryValue* policy_dict) {
   // Allowing unrecognized policy names allows presence of
   // 1) comments (i.e. JSON of the form: { "_comment": "blah", ... }),
   // 2) policies intended for future/newer versions of the host,
   // 3) policies not supported on all OS-s (i.e. RemoteAccessHostMatchUsername
   //    is not supported on Windows and therefore policy_templates.json omits
   //    schema for this policy on this particular platform).
   auto strategy = policy::SCHEMA_ALLOW_UNKNOWN_TOPLEVEL;
 
   std::string path;
   std::string error;
   bool changed = false;
   const policy::Schema* schema = GetPolicySchema();
   if (schema->Normalize(policy_dict, strategy, &path, &error, &changed)) {
     if (changed) {
       LOG(WARNING) << "Unknown (unrecognized or unsupported) policy: " << path
                    << ": " << error;
     }
     return true;
   } else {
     LOG(ERROR) << "Invalid policy contents: " << path << ": " << error;
     return false;
   }
 }
 
-namespace {
-void CopyDictionaryValue(const base::DictionaryValue& from,
-                         base::DictionaryValue& to,
-                         std::string key) {
-  const base::Value* value;
-  if (from.Get(key, &value)) {
-    to.Set(key, value->CreateDeepCopy());
-  }
-}
-}  // namespace
-
 std::unique_ptr<base::DictionaryValue>
-PolicyWatcher::StoreNewAndReturnChangedPolicies(
+PolicyWatcherImpl::StoreNewAndReturnChangedPolicies(
     std::unique_ptr<base::DictionaryValue> new_policies) {
   // Find the changed policies.
   std::unique_ptr<base::DictionaryValue> changed_policies(
       new base::DictionaryValue());
   base::DictionaryValue::Iterator iter(*new_policies);
   while (!iter.IsAtEnd()) {
     base::Value* old_policy;
     if (!(old_policies_->Get(iter.key(), &old_policy) &&
           old_policy->Equals(&iter.value()))) {
       changed_policies->Set(iter.key(), iter.value().CreateDeepCopy());
@@ skipping 13 matching lines @@
     CopyDictionaryValue(*new_policies, *changed_policies,
                         key::kRemoteAccessHostTokenValidationCertificateIssuer);
   }
 
   // Save the new policies.
   old_policies_.swap(new_policies);
 
   return changed_policies;
 }
 
-void PolicyWatcher::OnPolicyUpdated(const policy::PolicyNamespace& ns,
-                                    const policy::PolicyMap& previous,
-                                    const policy::PolicyMap& current) {
+void PolicyWatcherImpl::OnPolicyUpdated(const policy::PolicyNamespace& ns,
+                                        const policy::PolicyMap& previous,
+                                        const policy::PolicyMap& current) {
   std::unique_ptr<base::DictionaryValue> new_policies =
       CopyChromotingPoliciesIntoDictionary(current);
 
   // Check for mistyped values and get rid of unknown policies.
   if (!NormalizePolicies(new_policies.get())) {
     SignalPolicyError();
     return;
   }
 
   // Use default values for any missing policies.
@@ skipping 10 matching lines @@
   // Verify that we are calling the callback with valid policies.
   if (!VerifyWellformedness(*changed_policies)) {
     SignalPolicyError();
     return;
   }
 
   // Notify our client of the changed policies.
   policy_updated_callback_.Run(std::move(changed_policies));
 }
 
-void PolicyWatcher::OnPolicyServiceInitialized(policy::PolicyDomain domain) {
+void PolicyWatcherImpl::OnPolicyServiceInitialized(
+    policy::PolicyDomain domain) {
   policy::PolicyNamespace ns = GetPolicyNamespace();
   const policy::PolicyMap& current = policy_service_->GetPolicies(ns);
   OnPolicyUpdated(ns, current, current);
 }
 
+}  // namespace
+
+PolicyWatcher::PolicyWatcher() {}
+PolicyWatcher::~PolicyWatcher() {}
+
 std::unique_ptr<PolicyWatcher> PolicyWatcher::CreateFromPolicyLoader(
     std::unique_ptr<policy::AsyncPolicyLoader> async_policy_loader) {
   std::unique_ptr<policy::SchemaRegistry> schema_registry =
       CreateSchemaRegistry();
   std::unique_ptr<policy::AsyncPolicyProvider> policy_provider(
       new policy::AsyncPolicyProvider(schema_registry.get(),
                                       std::move(async_policy_loader)));
   policy_provider->Init(schema_registry.get());
 
   policy::PolicyServiceImpl::Providers providers;
   providers.push_back(policy_provider.get());
   std::unique_ptr<policy::PolicyService> policy_service(
       new policy::PolicyServiceImpl(providers));
 
   policy::PolicyService* borrowed_policy_service = policy_service.get();
-  return base::WrapUnique(new PolicyWatcher(
+  return base::WrapUnique(new PolicyWatcherImpl(
       borrowed_policy_service, std::move(policy_service),
       std::move(policy_provider), std::move(schema_registry)));
 }
 
 std::unique_ptr<PolicyWatcher> PolicyWatcher::Create(
     policy::PolicyService* policy_service,
     const scoped_refptr<base::SingleThreadTaskRunner>& file_task_runner) {
 #if defined(OS_CHROMEOS)
   // On Chrome OS the PolicyService is owned by the browser.
   DCHECK(policy_service);
@@ skipping 31 matching lines @@
       CreateSchemaRegistry()));
 #else
 #error OS that is not yet supported by PolicyWatcher code.
 #endif
 
   return PolicyWatcher::CreateFromPolicyLoader(std::move(policy_loader));
 #endif  // !(OS_CHROMEOS)
 }
 
 }  // namespace remoting