Rename ChromeThread to BrowserThread Part13:

chrome/browser/policy/config_dir_policy_provider.cc

 // Copyright (c) 2010 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 "chrome/browser/policy/config_dir_policy_provider.h"
 
 #include <set>
 
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 27 matching lines @@
       config_dir_(config_dir),
       reload_task_(NULL),
       settle_interval_seconds_(settle_interval_seconds),
       reload_interval_minutes_(reload_interval_minutes) {
   // Force an initial load, so GetPolicy() works.
   policy_.reset(Load());
   DCHECK(policy_.get());
 }
 
 void PolicyDirLoader::Stop() {
-  if (!ChromeThread::CurrentlyOn(ChromeThread::FILE)) {
-    ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
-                           NewRunnableMethod(this, &PolicyDirLoader::Stop));
+  if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
+    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
+                            NewRunnableMethod(this, &PolicyDirLoader::Stop));
     return;
   }
 
   if (reload_task_) {
     reload_task_->Cancel();
     reload_task_ = NULL;
   }
 }
 
 void PolicyDirLoader::Reload() {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Check the directory time in order to see whether a reload is required.
   base::TimeDelta delay;
   base::Time now = base::Time::Now();
   if (!IsSafeToReloadPolicy(now, &delay)) {
     ScheduleReloadTask(delay);
     return;
   }
 
   // Load the policy definitions.
@@ skipping 24 matching lines @@
   // that'll make us recheck after a reasonable interval.
   ScheduleReloadTask(base::TimeDelta::FromMinutes(reload_interval_minutes_));
 }
 
 DictionaryValue* PolicyDirLoader::GetPolicy() {
   AutoLock lock(lock_);
   return static_cast<DictionaryValue*>(policy_->DeepCopy());
 }
 
 void PolicyDirLoader::OnFilePathChanged(const FilePath& path) {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   Reload();
 }
 
 void PolicyDirLoader::OnError() {
   LOG(ERROR) << "FileWatcher on " << config_dir_.value() << " failed.";
 }
 
 DictionaryValue* PolicyDirLoader::Load() {
   // Enumerate the files and sort them lexicographically.
   std::set<FilePath> files;
@@ skipping 53 matching lines @@
   base::TimeDelta age = now - last_modification_clock_;
   if (age < settleInterval) {
     *delay = settleInterval - age;
     return false;
   }
 
   return true;
 }
 
 void PolicyDirLoader::ScheduleReloadTask(const base::TimeDelta& delay) {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   if (reload_task_)
     reload_task_->Cancel();
 
   reload_task_ = NewRunnableMethod(this, &PolicyDirLoader::ReloadFromTask);
-  ChromeThread::PostDelayedTask(ChromeThread::FILE, FROM_HERE, reload_task_,
+  BrowserThread::PostDelayedTask(BrowserThread::FILE, FROM_HERE, reload_task_,
                                 delay.InMilliseconds());
 }
 
 void PolicyDirLoader::NotifyPolicyChanged() {
   DCHECK_EQ(origin_loop_, MessageLoop::current());
   if (provider_)
     provider_->NotifyStoreOfPolicyChange();
 }
 
 void PolicyDirLoader::ReloadFromTask() {
-  DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
   // Drop the reference to the reload task, since the task might be the only
   // referer that keeps us alive, so we should not Cancel() it.
   reload_task_ = NULL;
 
   Reload();
 }
 
 // PolicyDirWatcher implementation:
 
 void PolicyDirWatcher::Init(PolicyDirLoader* loader) {
   // Initialization can happen early when the file thread is not yet available.
   // So post a task to ourselves on the UI thread which will run after threading
   // is up and schedule watch initialization on the file thread.
-  ChromeThread::PostTask(ChromeThread::UI, FROM_HERE,
+  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(this,
                         &PolicyDirWatcher::InitWatcher,
                         scoped_refptr<PolicyDirLoader>(loader)));
 }
 
 void PolicyDirWatcher::InitWatcher(
     const scoped_refptr<PolicyDirLoader>& loader) {
-  if (!ChromeThread::CurrentlyOn(ChromeThread::FILE)) {
-    ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE,
+  if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
+    BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(this, &PolicyDirWatcher::InitWatcher, loader));
     return;
   }
 
   if (!watcher_.Watch(loader->config_dir(), loader.get()))
     loader->OnError();
 
   // There might have been changes to the directory in the time between
   // construction of the loader and initialization of the watcher. Call reload
   // to detect if that is the case.
@@ skipping 33 matching lines @@
     Value* value;
     if (policies->Get(entry.name, &value) && value->IsType(entry.value_type))
       store->Apply(entry.policy_type, value->DeepCopy());
   }
 
   // TODO(mnissler): Handle preference overrides once |ConfigurationPolicyStore|
   // supports it.
 }
 
 }  // namespace policy