Use SingleThreadTaskRunner instead of MessageLoopProxy in remoting/host.

remoting/host/policy_hack/nat_policy_linux.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.
 
 // Most of this code is copied from various classes in
 // src/chrome/browser/policy. In particular, look at
 //
 //   file_based_policy_loader.{h,cc}
 //   config_dir_policy_provider.{h,cc}
 //
 // This is a reduction of the functionality in those classes.
 
 #include <set>
 
 #include "remoting/host/policy_hack/nat_policy.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/files/file_path_watcher.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
-#include "base/message_loop_proxy.h"
+#include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time.h"
 #include "base/values.h"
 
 namespace remoting {
 namespace policy_hack {
 
 namespace {
 
 const FilePath::CharType kPolicyDir[] =
     FILE_PATH_LITERAL("/etc/opt/chrome/policies/managed");
 
 // Amount of time we wait for the files on disk to settle before trying to load
 // them. This alleviates the problem of reading partially written files and
 // makes it possible to batch quasi-simultaneous changes.
 const int kSettleIntervalSeconds = 5;
 
 }  // namespace
 
 class NatPolicyLinux : public NatPolicy {
  public:
-  NatPolicyLinux(base::MessageLoopProxy* message_loop_proxy,
+  NatPolicyLinux(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
                  const FilePath& config_dir)
-      : NatPolicy(message_loop_proxy),
+      : NatPolicy(task_runner),
         config_dir_(config_dir),
         ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
     // Detach the factory because we ensure that only the policy thread ever
     // calls methods on this. Also, the API contract of having to call
     // StopWatching() (which signals completion) after StartWatching()
     // before this object can be destructed ensures there are no users of
     // this object before it is destructed.
     weak_factory_.DetachFromThread();
   }
 
@@ skipping 201 matching lines @@
   // wall clock times come from the same source, just in case there is some
   // non-local filesystem involved.
   base::Time last_modification_clock_;
 
   const FilePath config_dir_;
 
   // Allows us to cancel any inflight FileWatcher events or scheduled reloads.
   base::WeakPtrFactory<NatPolicyLinux> weak_factory_;
 };
 
-NatPolicy* NatPolicy::Create(base::MessageLoopProxy* message_loop_proxy) {
+NatPolicy* NatPolicy::Create(
+    scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   FilePath policy_dir(kPolicyDir);
-  return new NatPolicyLinux(message_loop_proxy, policy_dir);
+  return new NatPolicyLinux(task_runner, policy_dir);
 }
 
 }  // namespace policy_hack
 }  // namespace remoting