Replace OVERRIDE and FINAL with override and final in content/public/[a-s]*

content/public/test/test_file_system_backend.cc

 // Copyright 2013 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 "content/public/test/test_file_system_backend.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 30 matching lines @@
 class TestFileUtil : public storage::LocalFileUtil {
  public:
   explicit TestFileUtil(const base::FilePath& base_path)
       : base_path_(base_path) {}
   virtual ~TestFileUtil() {}
 
   // LocalFileUtil overrides.
   virtual base::File::Error GetLocalFilePath(
       FileSystemOperationContext* context,
       const FileSystemURL& file_system_url,
-      base::FilePath* local_file_path) OVERRIDE {
+      base::FilePath* local_file_path) override {
     *local_file_path = base_path_.Append(file_system_url.path());
     return base::File::FILE_OK;
   }
 
  private:
   base::FilePath base_path_;
 };
 
 // Stub implementation of storage::WatcherManager. Emits a fake notification
 // after a directory watcher is set successfully.
 class TestWatcherManager : public storage::WatcherManager {
  public:
   TestWatcherManager() : weak_ptr_factory_(this) {}
   virtual ~TestWatcherManager() {}
 
   // storage::WatcherManager overrides.
-  virtual void AddObserver(Observer* observer) OVERRIDE {
+  virtual void AddObserver(Observer* observer) override {
     observers_.AddObserver(observer);
   }
 
-  virtual void RemoveObserver(Observer* observer) OVERRIDE {
+  virtual void RemoveObserver(Observer* observer) override {
     observers_.RemoveObserver(observer);
   }
 
-  virtual bool HasObserver(Observer* observer) const OVERRIDE {
+  virtual bool HasObserver(Observer* observer) const override {
     return observers_.HasObserver(observer);
   }
 
   virtual void WatchDirectory(const storage::FileSystemURL& url,
                               bool recursive,
-                              const StatusCallback& callback) OVERRIDE {
+                              const StatusCallback& callback) override {
     if (recursive) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(callback, base::File::FILE_ERROR_INVALID_OPERATION));
       return;
     }
 
     const GURL gurl = url.ToGURL();
     if (watched_urls_.find(gurl) != watched_urls_.end()) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
@@ skipping 14 matching lines @@
 
     // Send a fake removed notification.
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(&TestWatcherManager::SendFakeRemoveNotification,
                    weak_ptr_factory_.GetWeakPtr(),
                    url));
   }
 
   virtual void UnwatchEntry(const storage::FileSystemURL& url,
-                            const StatusCallback& callback) OVERRIDE {
+                            const StatusCallback& callback) override {
     const GURL gurl = url.ToGURL();
     if (watched_urls_.find(gurl) == watched_urls_.end()) {
       base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE, base::Bind(callback, base::File::FILE_ERROR_NOT_FOUND));
       return;
     }
 
     watched_urls_.erase(gurl);
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, base::File::FILE_OK));
@@ skipping 31 matching lines @@
                                          public storage::FileUpdateObserver {
  public:
   QuotaUtil() : usage_(0) {}
   virtual ~QuotaUtil() {}
 
   // FileSystemQuotaUtil overrides.
   virtual base::File::Error DeleteOriginDataOnFileTaskRunner(
       FileSystemContext* context,
       storage::QuotaManagerProxy* proxy,
       const GURL& origin_url,
-      storage::FileSystemType type) OVERRIDE {
+      storage::FileSystemType type) override {
     NOTREACHED();
     return base::File::FILE_OK;
   }
 
   virtual scoped_refptr<storage::QuotaReservation>
   CreateQuotaReservationOnFileTaskRunner(
       const GURL& origin_url,
-      storage::FileSystemType type) OVERRIDE {
+      storage::FileSystemType type) override {
     NOTREACHED();
     return scoped_refptr<storage::QuotaReservation>();
   }
 
   virtual void GetOriginsForTypeOnFileTaskRunner(
       storage::FileSystemType type,
-      std::set<GURL>* origins) OVERRIDE {
+      std::set<GURL>* origins) override {
     NOTREACHED();
   }
 
   virtual void GetOriginsForHostOnFileTaskRunner(
       storage::FileSystemType type,
       const std::string& host,
-      std::set<GURL>* origins) OVERRIDE {
+      std::set<GURL>* origins) override {
     NOTREACHED();
   }
 
   virtual int64 GetOriginUsageOnFileTaskRunner(
       FileSystemContext* context,
       const GURL& origin_url,
-      storage::FileSystemType type) OVERRIDE {
+      storage::FileSystemType type) override {
     return usage_;
   }
 
   // FileUpdateObserver overrides.
-  virtual void OnStartUpdate(const FileSystemURL& url) OVERRIDE {}
-  virtual void OnUpdate(const FileSystemURL& url, int64 delta) OVERRIDE {
+  virtual void OnStartUpdate(const FileSystemURL& url) override {}
+  virtual void OnUpdate(const FileSystemURL& url, int64 delta) override {
     usage_ += delta;
   }
-  virtual void OnEndUpdate(const FileSystemURL& url) OVERRIDE {}
+  virtual void OnEndUpdate(const FileSystemURL& url) override {}
 
  private:
   int64 usage_;
   DISALLOW_COPY_AND_ASSIGN(QuotaUtil);
 };
 
 TestFileSystemBackend::TestFileSystemBackend(
     base::SequencedTaskRunner* task_runner,
     const base::FilePath& base_path)
     : base_path_(base_path),
@@ skipping 117 matching lines @@
   return NULL;
 }
 
 void TestFileSystemBackend::AddFileChangeObserver(
     storage::FileChangeObserver* observer) {
   change_observers_ =
       change_observers_.AddObserver(observer, task_runner_.get());
 }
 
 }  // namespace content