Always run PolicyWatcher on UI thread in It2Me host.

remoting/host/policy_watcher_unittest.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.
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
@@ skipping 24 matching lines @@
 
 class PolicyWatcherTest : public testing::Test {
  public:
   PolicyWatcherTest() : message_loop_(base::MessageLoop::TYPE_IO) {}
 
   void SetUp() override {
     message_loop_proxy_ = base::MessageLoopProxy::current();
 
     // Retaining a raw pointer to keep control over policy contents.
     policy_loader_ = new policy::FakeAsyncPolicyLoader(message_loop_proxy_);
-    policy_watcher_ = PolicyWatcher::CreateFromPolicyLoader(
-        message_loop_proxy_, make_scoped_ptr(policy_loader_));
+    policy_watcher_ =
+        PolicyWatcher::CreateFromPolicyLoader(make_scoped_ptr(policy_loader_));
 
     nat_true_.SetBoolean(policy::key::kRemoteAccessHostFirewallTraversal, true);
     nat_false_.SetBoolean(policy::key::kRemoteAccessHostFirewallTraversal,
                           false);
     nat_one_.SetInteger(policy::key::kRemoteAccessHostFirewallTraversal, 1);
     domain_empty_.SetString(policy::key::kRemoteAccessHostDomain,
                             std::string());
     domain_full_.SetString(policy::key::kRemoteAccessHostDomain, kHostDomain);
     SetDefaults(nat_true_others_default_);
     nat_true_others_default_.SetBoolean(
@@ skipping 74 matching lines @@
  protected:
   void StartWatching() {
     policy_watcher_->StartWatching(
         base::Bind(&MockPolicyCallback::OnPolicyUpdate,
                    base::Unretained(&mock_policy_callback_)),
         base::Bind(&MockPolicyCallback::OnPolicyError,
                    base::Unretained(&mock_policy_callback_)));
     base::RunLoop().RunUntilIdle();
   }
 
-  void StopWatching() {
-    EXPECT_CALL(*this, PostPolicyWatcherShutdown()).Times(1);
-    policy_watcher_->StopWatching(base::Bind(
-        &PolicyWatcherTest::PostPolicyWatcherShutdown, base::Unretained(this)));
-    base::RunLoop().RunUntilIdle();
-  }
-
   void SetPolicies(const base::DictionaryValue& dict) {
     // Copy |dict| into |policy_bundle|.
     policy::PolicyNamespace policy_namespace =
         policy::PolicyNamespace(policy::POLICY_DOMAIN_CHROME, std::string());
     policy::PolicyBundle policy_bundle;
     policy::PolicyMap& policy_map = policy_bundle.Get(policy_namespace);
     policy_map.LoadFrom(&dict, policy::POLICY_LEVEL_MANDATORY,
                         policy::POLICY_SCOPE_MACHINE);
 
     // Simulate a policy file/registry/preference update.
@@ skipping 92 matching lines @@
   }
   return equal;
 }
 
 TEST_F(PolicyWatcherTest, None) {
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 
   SetPolicies(empty_);
   StartWatching();
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, NatTrue) {
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 
   SetPolicies(nat_true_);
   StartWatching();
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, NatFalse) {
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_false_others_default_)));
 
   SetPolicies(nat_false_);
   StartWatching();
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, NatOne) {
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_false_others_default_)));
 
   SetPolicies(nat_one_);
   StartWatching();
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, DomainEmpty) {
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&domain_empty_others_default_)));
 
   SetPolicies(domain_empty_);
   StartWatching();
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, DomainFull) {
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&domain_full_others_default_)));
 
   SetPolicies(domain_full_);
   StartWatching();
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, NatNoneThenTrue) {
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 
   SetPolicies(empty_);
   StartWatching();
   SetPolicies(nat_true_);
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, NatNoneThenTrueThenTrue) {
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 
   SetPolicies(empty_);
   StartWatching();
   SetPolicies(nat_true_);
   SetPolicies(nat_true_);
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, NatNoneThenTrueThenTrueThenFalse) {
   testing::InSequence sequence;
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_false_)));
 
   SetPolicies(empty_);
   StartWatching();
   SetPolicies(nat_true_);
   SetPolicies(nat_true_);
   SetPolicies(nat_false_);
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, NatNoneThenFalse) {
   testing::InSequence sequence;
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_false_)));
 
   SetPolicies(empty_);
   StartWatching();
   SetPolicies(nat_false_);
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, NatNoneThenFalseThenTrue) {
   testing::InSequence sequence;
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_false_)));
   EXPECT_CALL(mock_policy_callback_, OnPolicyUpdatePtr(IsPolicies(&nat_true_)));
 
   SetPolicies(empty_);
   StartWatching();
   SetPolicies(nat_false_);
   SetPolicies(nat_true_);
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, ChangeOneRepeatedlyThenTwo) {
   testing::InSequence sequence;
   EXPECT_CALL(
       mock_policy_callback_,
       OnPolicyUpdatePtr(IsPolicies(&nat_true_domain_empty_others_default_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&domain_full_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_false_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&domain_empty_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_domain_full_)));
 
   SetPolicies(nat_true_domain_empty_);
   StartWatching();
   SetPolicies(nat_true_domain_full_);
   SetPolicies(nat_false_domain_full_);
   SetPolicies(nat_false_domain_empty_);
   SetPolicies(nat_true_domain_full_);
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, FilterUnknownPolicies) {
   testing::InSequence sequence;
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 
   SetPolicies(empty_);
   StartWatching();
   SetPolicies(unknown_policies_);
   SetPolicies(empty_);
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, DebugOverrideNatPolicy) {
 #if !defined(NDEBUG)
   EXPECT_CALL(
       mock_policy_callback_,
       OnPolicyUpdatePtr(IsPolicies(&nat_false_overridden_others_default_)));
 #else
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
 #endif
 
   SetPolicies(nat_true_and_overridden_);
   StartWatching();
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, PairingFalseThenTrue) {
   testing::InSequence sequence;
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&pairing_false_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&pairing_true_)));
 
   SetPolicies(empty_);
   StartWatching();
   SetPolicies(pairing_false_);
   SetPolicies(pairing_true_);
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, GnubbyAuth) {
   testing::InSequence sequence;
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&gnubby_auth_false_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&gnubby_auth_true_)));
 
   SetPolicies(empty_);
   StartWatching();
   SetPolicies(gnubby_auth_false_);
   SetPolicies(gnubby_auth_true_);
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, Relay) {
   testing::InSequence sequence;
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&relay_false_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&relay_true_)));
 
   SetPolicies(empty_);
   StartWatching();
   SetPolicies(relay_false_);
   SetPolicies(relay_true_);
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, UdpPortRange) {
   testing::InSequence sequence;
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&nat_true_others_default_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&port_range_full_)));
   EXPECT_CALL(mock_policy_callback_,
               OnPolicyUpdatePtr(IsPolicies(&port_range_empty_)));
 
   SetPolicies(empty_);
   StartWatching();
   SetPolicies(port_range_full_);
   SetPolicies(port_range_empty_);
-  StopWatching();
 }
 
 const int kMaxTransientErrorRetries = 5;
 
 TEST_F(PolicyWatcherTest, SingleTransientErrorDoesntTriggerErrorCallback) {
   EXPECT_CALL(mock_policy_callback_, OnPolicyError()).Times(0);
 
   StartWatching();
   SignalTransientErrorForTest();
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, MultipleTransientErrorsTriggerErrorCallback) {
   EXPECT_CALL(mock_policy_callback_, OnPolicyError());
 
   StartWatching();
   for (int i = 0; i < kMaxTransientErrorRetries; i++) {
     SignalTransientErrorForTest();
   }
-  StopWatching();
 }
 
 TEST_F(PolicyWatcherTest, PolicyUpdateResetsTransientErrorsCounter) {
   testing::InSequence s;
   EXPECT_CALL(mock_policy_callback_, OnPolicyUpdatePtr(testing::_));
   EXPECT_CALL(mock_policy_callback_, OnPolicyError()).Times(0);
 
   StartWatching();
   for (int i = 0; i < (kMaxTransientErrorRetries - 1); i++) {
     SignalTransientErrorForTest();
   }
   SetPolicies(nat_true_);
   for (int i = 0; i < (kMaxTransientErrorRetries - 1); i++) {
     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) {
   VLOG(1) << "OnPolicyUpdated callback received the following policies:";
@@ skipping 34 matching lines @@
   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 remoting