Always run PolicyWatcher on UI thread in It2Me host.

remoting/host/policy_hack/policy_watcher.h

 // 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.
 
 #ifndef REMOTING_HOST_POLICY_HACK_POLICY_WATCHER_H_
 #define REMOTING_HOST_POLICY_HACK_POLICY_WATCHER_H_
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
@@ skipping 58 matching lines @@
       const PolicyErrorCallback& policy_error_callback);
 
   // Should be called after StartWatching() before the object is deleted. Calls
   // should wait for |stopped_callback| to be called before deleting it.
   virtual void StopWatching(const base::Closure& stopped_callback);
 
   // Specify a |policy_service| to borrow (on Chrome OS, from the browser
   // process) or specify nullptr to internally construct and use a new
   // PolicyService (on other OS-es).
   //
-  // When |policy_service| is null, then |task_runner| is used for reading the
-  // policy from files / registry / preferences.  PolicyUpdatedCallback and
-  // PolicyErrorCallback will be called on the same |task_runner|.
-  // |task_runner| should be of TYPE_IO type.
+  // |current_task_runner| refers to the task runner for the current thread. The
+  // PolicyWatcher must only be used on the same thread it's created and it call

[Łukasz Anforowicz, 2015/01/30 05:35:55]

Non-native speaker here, but I think it should be "... it's created *on* and it
*will* call ... ".

[Łukasz Anforowicz, 2015/01/30 17:16:00]

RE: PolicyWatcher must only be used on the same thread

This is definitely true for how it2me and me2me call StartWatching and
StopWatching and I think it means that these 2 methods can be simplified:

*) PolicyWatcher::StartWatching does not have to check if
(!OnPolicyServiceThread()) { ... policy_service_task_runner->PostTask ... } but
can simply do DCHECK(OnPolicyServiceThread()).  

*) StopWatching doesn't need to PostTask and doesn't need |stopped_callback| to
communicate asynchronous completion.

[Sergey Ulanov, 2015/01/30 19:33:45]

Yes, Thank you. Actually marked PolicyWatcher as NonThreadSafe and removed
policy_service_task_runner.
Also removed StopWatchign() - we don't need it anymore because shutdown can be
synchronous now, yay!

[Sergey Ulanov, 2015/01/30 19:33:45]

Done.

+  // all callbacks on this thread.
+  //
+  // When |policy_service| is null, then |io_task_runner| is used for reading
+  // the policy from files / registry / preferences. |io_task_runner| should be
+  // of TYPE_IO type.
   //
   // When |policy_service| is specified then |task_runner| argument is ignored

[Łukasz Anforowicz, 2015/01/30 05:35:55]

Need to update the name of the parameter in the comment below:
When |policy_service| is specified then |*io*_task_runner| argument is ignored.

Also - we probably want to document in the comments that when specifying
|policy_service|, it has to be safe to use |policy_service| from
|current_task_runner|.

[Sergey Ulanov, 2015/01/30 19:33:45]

Done.

   // and 1) BrowserThread::UI is used for PolicyUpdatedCallback and
   // PolicyErrorCallback and 2) BrowserThread::FILE is used for reading the
   // policy from files / registry / preferences (although (2) is just an
   // implementation detail and should likely be ignored outside of
   // PolicyWatcher).
   static scoped_ptr<PolicyWatcher> Create(
       policy::PolicyService* policy_service,
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner);
+      const scoped_refptr<base::SingleThreadTaskRunner>& current_task_runner,
+      const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
 
  private:
   friend class PolicyWatcherTest;
 
   // Used to check if the class is on the right thread.
   bool OnPolicyServiceThread() const;
 
   // Takes the policy dictionary from the OS specific store and extracts the
   // relevant policies.
   void UpdatePolicies(const base::DictionaryValue* new_policy);
@@ skipping 58 matching lines @@
   scoped_ptr<policy::ConfigurationPolicyProvider> owned_policy_provider_;
   scoped_ptr<policy::PolicyService> owned_policy_service_;
 
   DISALLOW_COPY_AND_ASSIGN(PolicyWatcher);
 };
 
 }  // namespace policy_hack
 }  // namespace remoting
 
 #endif  // REMOTING_HOST_POLICY_HACK_POLICY_WATCHER_H_