components: Remove use of MessageLoopProxy and deprecated MessageLoop APIs

components/policy/core/common/policy_service_impl.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 "components/policy/core/common/policy_service_impl.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
-#include "base/message_loop/message_loop.h"
+#include "base/location.h"
+#include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "components/policy/core/common/policy_bundle.h"
 #include "components/policy/core/common/policy_map.h"
 #include "policy/policy_constants.h"
 
 namespace policy {
 
 typedef PolicyServiceImpl::Providers::const_iterator Iterator;
 
 namespace {
@@ skipping 111 matching lines @@
 void PolicyServiceImpl::RefreshPolicies(const base::Closure& callback) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!callback.is_null())
     refresh_callbacks_.push_back(callback);
 
   if (providers_.empty()) {
     // Refresh is immediately complete if there are no providers. See the note
     // on OnUpdatePolicy() about why this is a posted task.
     update_task_ptr_factory_.InvalidateWeakPtrs();
-    base::MessageLoop::current()->PostTask(
-        FROM_HERE,
-        base::Bind(&PolicyServiceImpl::MergeAndTriggerUpdates,
-                   update_task_ptr_factory_.GetWeakPtr()));
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
+        FROM_HERE, base::Bind(&PolicyServiceImpl::MergeAndTriggerUpdates,
+                              update_task_ptr_factory_.GetWeakPtr()));
   } else {
     // Some providers might invoke OnUpdatePolicy synchronously while handling
     // RefreshPolicies. Mark all as pending before refreshing.
     for (Iterator it = providers_.begin(); it != providers_.end(); ++it)
       refresh_pending_.insert(*it);
     for (Iterator it = providers_.begin(); it != providers_.end(); ++it)
       (*it)->RefreshPolicies();
   }
 }
 
 void PolicyServiceImpl::OnUpdatePolicy(ConfigurationPolicyProvider* provider) {
   DCHECK_EQ(1, std::count(providers_.begin(), providers_.end(), provider));
   refresh_pending_.erase(provider);
 
   // Note: a policy change may trigger further policy changes in some providers.
   // For example, disabling SigninAllowed would cause the CloudPolicyManager to
   // drop all its policies, which makes this method enter again for that
   // provider.
   //
   // Therefore this update is posted asynchronously, to prevent reentrancy in
   // MergeAndTriggerUpdates. Also, cancel a pending update if there is any,
   // since both will produce the same PolicyBundle.
   update_task_ptr_factory_.InvalidateWeakPtrs();
-  base::MessageLoop::current()->PostTask(
-      FROM_HERE,
-      base::Bind(&PolicyServiceImpl::MergeAndTriggerUpdates,
-                 update_task_ptr_factory_.GetWeakPtr()));
+  base::ThreadTaskRunnerHandle::Get()->PostTask(
+      FROM_HERE, base::Bind(&PolicyServiceImpl::MergeAndTriggerUpdates,
+                            update_task_ptr_factory_.GetWeakPtr()));
 }
 
 void PolicyServiceImpl::NotifyNamespaceUpdated(
     const PolicyNamespace& ns,
     const PolicyMap& previous,
     const PolicyMap& current) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ObserverMap::iterator iterator = observers_.find(ns.domain);
   if (iterator != observers_.end()) {
     FOR_EACH_OBSERVER(PolicyService::Observer,
@@ skipping 89 matching lines @@
   if (refresh_pending_.empty() && !refresh_callbacks_.empty()) {
     std::vector<base::Closure> callbacks;
     callbacks.swap(refresh_callbacks_);
     std::vector<base::Closure>::iterator it;
     for (it = callbacks.begin(); it != callbacks.end(); ++it)
       it->Run();
   }
 }
 
 }  // namespace policy