Replace FINAL and OVERRIDE with their C++11 counterparts in content

content/browser/database_tracker_unittest.cc

 // Copyright 2014 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 "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 28 matching lines @@
   }
   TestObserver(bool observe_size_changes, bool observe_scheduled_deletions)
       : new_notification_received_(false),
         observe_size_changes_(observe_size_changes),
         observe_scheduled_deletions_(observe_scheduled_deletions) {
   }
 
   virtual ~TestObserver() {}
   virtual void OnDatabaseSizeChanged(const std::string& origin_identifier,
                                      const base::string16& database_name,
-                                     int64 database_size) OVERRIDE {
+                                     int64 database_size) override {
     if (!observe_size_changes_)
       return;
     new_notification_received_ = true;
     origin_identifier_ = origin_identifier;
     database_name_ = database_name;
     database_size_ = database_size;
   }
   virtual void OnDatabaseScheduledForDeletion(
       const std::string& origin_identifier,
-      const base::string16& database_name) OVERRIDE {
+      const base::string16& database_name) override {
     if (!observe_scheduled_deletions_)
       return;
     new_notification_received_ = true;
     origin_identifier_ = origin_identifier;
     database_name_ = database_name;
   }
   bool DidReceiveNewNotification() {
     bool temp_new_notification_received = new_notification_received_;
     new_notification_received_ = false;
     return temp_new_notification_received;
@@ skipping 26 matching lines @@
             observer->GetNotificationDatabaseSize());
 }
 
 class TestQuotaManagerProxy : public storage::QuotaManagerProxy {
  public:
   TestQuotaManagerProxy()
       : QuotaManagerProxy(NULL, NULL),
         registered_client_(NULL) {
   }
 
-  virtual void RegisterClient(storage::QuotaClient* client) OVERRIDE {
+  virtual void RegisterClient(storage::QuotaClient* client) override {
     EXPECT_FALSE(registered_client_);
     registered_client_ = client;
   }
 
   virtual void NotifyStorageAccessed(storage::QuotaClient::ID client_id,
                                      const GURL& origin,
-                                     storage::StorageType type) OVERRIDE {
+                                     storage::StorageType type) override {
     EXPECT_EQ(storage::QuotaClient::kDatabase, client_id);
     EXPECT_EQ(storage::kStorageTypeTemporary, type);
     accesses_[origin] += 1;
   }
 
   virtual void NotifyStorageModified(storage::QuotaClient::ID client_id,
                                      const GURL& origin,
                                      storage::StorageType type,
-                                     int64 delta) OVERRIDE {
+                                     int64 delta) override {
     EXPECT_EQ(storage::QuotaClient::kDatabase, client_id);
     EXPECT_EQ(storage::kStorageTypeTemporary, type);
     modifications_[origin].first += 1;
     modifications_[origin].second += delta;
   }
 
   // Not needed for our tests.
-  virtual void NotifyOriginInUse(const GURL& origin) OVERRIDE {}
-  virtual void NotifyOriginNoLongerInUse(const GURL& origin) OVERRIDE {}
+  virtual void NotifyOriginInUse(const GURL& origin) override {}
+  virtual void NotifyOriginNoLongerInUse(const GURL& origin) override {}
   virtual void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
                                     const GURL& origin,
                                     storage::StorageType type,
-                                    bool enabled) OVERRIDE {}
+                                    bool enabled) override {}
   virtual void GetUsageAndQuota(
       base::SequencedTaskRunner* original_task_runner,
       const GURL& origin,
       storage::StorageType type,
-      const GetUsageAndQuotaCallback& callback) OVERRIDE {}
+      const GetUsageAndQuotaCallback& callback) override {}
 
   void SimulateQuotaManagerDestroyed() {
     if (registered_client_) {
       registered_client_->OnQuotaManagerDestroyed();
       registered_client_ = NULL;
     }
   }
 
   bool WasAccessNotified(const GURL& origin) {
     return accesses_[origin] != 0;
@@ skipping 712 matching lines @@
 
 TEST(DatabaseTrackerTest, EmptyDatabaseNameIsValid) {
   DatabaseTracker_TestHelper_Test::EmptyDatabaseNameIsValid();
 }
 
 TEST(DatabaseTrackerTest, HandleSqliteError) {
   DatabaseTracker_TestHelper_Test::HandleSqliteError();
 }
 
 }  // namespace content