Using PolicyServiceWatcher instead of PolicyWatcherLinux/Win/Mac.

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"
@@ skipping 70 matching lines @@
       initialization_complete_[domain] &=
           provider->IsInitializationComplete(static_cast<PolicyDomain>(domain));
     }
   }
   // There are no observers yet, but calls to GetPolicies() should already get
   // the processed policy values.
   MergeAndTriggerUpdates();
 }
 
 PolicyServiceImpl::~PolicyServiceImpl() {
+  DCHECK(thread_checker_.CalledOnValidThread());
   for (Iterator it = providers_.begin(); it != providers_.end(); ++it)
     (*it)->RemoveObserver(this);
   STLDeleteValues(&observers_);
 }
 
 void PolicyServiceImpl::AddObserver(PolicyDomain domain,
                                     PolicyService::Observer* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   Observers*& list = observers_[domain];
   if (!list)
     list = new Observers();
   list->AddObserver(observer);
 }
 
 void PolicyServiceImpl::RemoveObserver(PolicyDomain domain,
                                        PolicyService::Observer* observer) {
+  DCHECK(thread_checker_.CalledOnValidThread());
   ObserverMap::iterator it = observers_.find(domain);
   if (it == observers_.end()) {
     NOTREACHED();
     return;
   }
   it->second->RemoveObserver(observer);
   if (!it->second->might_have_observers()) {
     delete it->second;
     observers_.erase(it);
   }
 }
 
 const PolicyMap& PolicyServiceImpl::GetPolicies(
     const PolicyNamespace& ns) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
   return policy_bundle_.Get(ns);
 }
 
 bool PolicyServiceImpl::IsInitializationComplete(PolicyDomain domain) const {
+  DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(domain >= 0 && domain < POLICY_DOMAIN_SIZE);
   return initialization_complete_[domain];
 }
 
 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,
@@ skipping 24 matching lines @@
   base::MessageLoop::current()->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,
                       *iterator->second,
                       OnPolicyUpdated(ns, previous, current));
   }
 }
 
 void PolicyServiceImpl::MergeAndTriggerUpdates() {
   // Merge from each provider in their order of priority.
@@ skipping 41 matching lines @@
 
   // Sends updates for the remaining removed namespaces, if any.
   for (; it_old != end_old; ++it_old)
     NotifyNamespaceUpdated(it_old->first, *it_old->second, kEmpty);
 
   CheckInitializationComplete();
   CheckRefreshComplete();
 }
 
 void PolicyServiceImpl::CheckInitializationComplete() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+
   // Check if all the providers just became initialized for each domain; if so,
   // notify that domain's observers.
   for (int domain = 0; domain < POLICY_DOMAIN_SIZE; ++domain) {
     if (initialization_complete_[domain])
       continue;
 
     PolicyDomain policy_domain = static_cast<PolicyDomain>(domain);
 
     bool all_complete = true;
     for (Iterator it = providers_.begin(); it != providers_.end(); ++it) {
@@ skipping 19 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