Using PolicyServiceWatcher instead of PolicyWatcherLinux/Win/Mac.

remoting/host/policy_hack/policy_watcher_unittest.cc

 // Copyright (c) 2012 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 <iostream>
+
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "remoting/host/dns_blackhole_checker.h"
 #include "remoting/host/policy_hack/fake_policy_watcher.h"
 #include "remoting/host/policy_hack/mock_policy_callback.h"
 #include "remoting/host/policy_hack/policy_watcher.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 namespace policy_hack {
 
 class PolicyWatcherTest : public testing::Test {
  public:
-  PolicyWatcherTest() {
-  }
+  PolicyWatcherTest() : message_loop_(base::MessageLoop::TYPE_IO) {}
 
   void SetUp() override {
     message_loop_proxy_ = base::MessageLoopProxy::current();
     policy_updated_callback_ = base::Bind(
         &MockPolicyCallback::OnPolicyUpdate,
         base::Unretained(&mock_policy_callback_));
     policy_error_callback_ = base::Bind(
         &MockPolicyCallback::OnPolicyError,
         base::Unretained(&mock_policy_callback_));
     policy_watcher_.reset(new FakePolicyWatcher(message_loop_proxy_));
@@ skipping 407 matching lines @@
   for (int i = 0; i < (kMaxTransientErrorRetries - 1); i++) {
     policy_watcher_->SignalTransientErrorForTest();
   }
   policy_watcher_->SetPolicies(&nat_true_);
   for (int i = 0; i < (kMaxTransientErrorRetries - 1); i++) {
     policy_watcher_->SignalTransientErrorForTest();
   }
   StopWatching();
 }
 
+// Unit tests cannot instantiate PolicyWatcher on ChromeOS
+// (as this requires running inside a browser process).
+#ifndef OS_CHROMEOS
+
+namespace {
+
+void OnPolicyUpdatedDumpPolicy(scoped_ptr<base::DictionaryValue> policies) {
+  if (!VLOG_IS_ON(1)) {
+    return;
+  }
+
+  std::cout << "OnPolicyUpdated callback received the following policies:"
+            << std::endl;
+
+  for (base::DictionaryValue::Iterator iter(*policies); !iter.IsAtEnd();
+       iter.Advance()) {
+    std::cout << iter.key() << " = ";
+    switch (iter.value().GetType()) {
+      case base::Value::Type::TYPE_STRING: {
+        std::string value;
+        CHECK(iter.value().GetAsString(&value));
+        std::cout << "string: " << '"' << value << '"';
+        break;
+      }
+      case base::Value::Type::TYPE_BOOLEAN: {
+        bool value;
+        CHECK(iter.value().GetAsBoolean(&value));
+        std::cout << "boolean: " << (value ? "True" : "False");
+        break;
+      }
+      default: {
+        std::cout << "unrecognized type";
+        break;
+      }
+    }
+    std::cout << std::endl;
+  }
+}
+
+}  // anonymous namespace
+
+// To dump policy contents, run unit tests with the following flags:
+// --gtest_filter=*TestRealChromotingPolicy* -v=1
+TEST_F(PolicyWatcherTest, TestRealChromotingPolicy) {
+  scoped_refptr<base::SingleThreadTaskRunner> task_runner =
+      base::MessageLoop::current()->task_runner();
+  scoped_ptr<PolicyWatcher> policy_watcher(
+      PolicyWatcher::Create(nullptr, task_runner));
+
+  {
+    base::RunLoop run_loop;
+    policy_watcher->StartWatching(base::Bind(OnPolicyUpdatedDumpPolicy),
+                                  base::Bind(base::DoNothing));
+    run_loop.RunUntilIdle();
+  }
+
+  {
+    base::RunLoop run_loop;
+    PolicyWatcher* raw_policy_watcher = policy_watcher.release();
+    raw_policy_watcher->StopWatching(
+        base::Bind(base::IgnoreResult(
+                       &base::SequencedTaskRunner::DeleteSoon<PolicyWatcher>),
+                   task_runner, FROM_HERE, raw_policy_watcher));
+    run_loop.RunUntilIdle();
+  }
+
+  // Today, the only verification offered by this test is:
+  // - Manual verification of policy values dumped by OnPolicyUpdatedDumpPolicy
+  // - Automated verification that nothing crashed
+}
+
+#endif
+
 }  // namespace policy_hack
 }  // namespace remoting