Standardize usage of virtual/override/final specifiers.

remoting/host/policy_hack/policy_watcher_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}
 //
@@ skipping 36 matching lines @@
 
 class PolicyWatcherLinux : public PolicyWatcher {
  public:
   PolicyWatcherLinux(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
                      const base::FilePath& config_dir)
       : PolicyWatcher(task_runner),
         config_dir_(config_dir),
         weak_factory_(this) {
   }
 
-  virtual ~PolicyWatcherLinux() {}
+  ~PolicyWatcherLinux() override {}
 
  protected:
-  virtual void StartWatchingInternal() override {
+  void StartWatchingInternal() override {
     DCHECK(OnPolicyWatcherThread());
     watcher_.reset(new base::FilePathWatcher());
 
     if (!config_dir_.empty() &&
         !watcher_->Watch(
             config_dir_, false,
             base::Bind(&PolicyWatcherLinux::OnFilePathChanged,
                        weak_factory_.GetWeakPtr()))) {
       OnFilePathChanged(config_dir_, true);
     }
 
     // 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.
     Reload();
 
     ScheduleFallbackReloadTask();
   }
 
-  virtual void StopWatchingInternal() override {
+  void StopWatchingInternal() override {
     DCHECK(OnPolicyWatcherThread());
 
     // Stop watching for changes to files in the policies directory.
     watcher_.reset();
 
     // Orphan any pending OnFilePathChanged tasks.
     weak_factory_.InvalidateWeakPtrs();
   }
 
  private:
@@ skipping 64 matching lines @@
         LOG(WARNING) << "Expected JSON dictionary in configuration file "
                      << config_file_iter->value();
         return nullptr;
       }
       policy->MergeDictionary(static_cast<base::DictionaryValue*>(value.get()));
     }
 
     return policy.Pass();
   }
 
-  virtual void Reload() override {
+  void Reload() override {
     DCHECK(OnPolicyWatcherThread());
     // 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;
     }
 
     // Check again in case the directory has changed while reading it.
@@ skipping 69 matching lines @@
 };
 
 PolicyWatcher* PolicyWatcher::Create(
     scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
   base::FilePath policy_dir(kPolicyDir);
   return new PolicyWatcherLinux(task_runner, policy_dir);
 }
 
 }  // namespace policy_hack
 }  // namespace remoting