Standardize usage of virtual/override/final in content/browser/

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 25 matching lines @@
       : new_notification_received_(false),
         observe_size_changes_(true),
         observe_scheduled_deletions_(true) {
   }
   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 {
+  ~TestObserver() override {}
+  void OnDatabaseSizeChanged(const std::string& origin_identifier,
+                             const base::string16& database_name,
+                             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(
+  void OnDatabaseScheduledForDeletion(
       const std::string& origin_identifier,
       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_;
@@ skipping 28 matching lines @@
             observer->GetNotificationDatabaseSize());
 }
 
 class TestQuotaManagerProxy : public storage::QuotaManagerProxy {
  public:
   TestQuotaManagerProxy()
       : QuotaManagerProxy(NULL, NULL),
         registered_client_(NULL) {
   }
 
-  virtual void RegisterClient(storage::QuotaClient* client) override {
+  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 {
+  void NotifyStorageAccessed(storage::QuotaClient::ID client_id,
+                             const GURL& origin,
+                             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 {
+  void NotifyStorageModified(storage::QuotaClient::ID client_id,
+                             const GURL& origin,
+                             storage::StorageType type,
+                             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 SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
-                                    const GURL& origin,
-                                    storage::StorageType type,
-                                    bool enabled) override {}
-  virtual void GetUsageAndQuota(
-      base::SequencedTaskRunner* original_task_runner,
-      const GURL& origin,
-      storage::StorageType type,
-      const GetUsageAndQuotaCallback& callback) override {}
+  void NotifyOriginInUse(const GURL& origin) override {}
+  void NotifyOriginNoLongerInUse(const GURL& origin) override {}
+  void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
+                            const GURL& origin,
+                            storage::StorageType type,
+                            bool enabled) override {}
+  void GetUsageAndQuota(base::SequencedTaskRunner* original_task_runner,
+                        const GURL& origin,
+                        storage::StorageType type,
+                        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 11 matching lines @@
 
   storage::QuotaClient* registered_client_;
 
   // Map from origin to count of access notifications.
   std::map<GURL, int> accesses_;
 
   // Map from origin to <count, sum of deltas>
   std::map<GURL, std::pair<int, int64> > modifications_;
 
  protected:
-  virtual ~TestQuotaManagerProxy() {
-    EXPECT_FALSE(registered_client_);
-  }
+  ~TestQuotaManagerProxy() override { EXPECT_FALSE(registered_client_); }
 };
 
 
 bool EnsureFileOfSize(const base::FilePath& file_path, int64 length) {
   base::File file(file_path,
                   base::File::FLAG_OPEN_ALWAYS | base::File::FLAG_WRITE);
   if (!file.IsValid())
     return false;
   return file.SetLength(length);
 }
@@ skipping 678 matching lines @@
 
 TEST(DatabaseTrackerTest, EmptyDatabaseNameIsValid) {
   DatabaseTracker_TestHelper_Test::EmptyDatabaseNameIsValid();
 }
 
 TEST(DatabaseTrackerTest, HandleSqliteError) {
   DatabaseTracker_TestHelper_Test::HandleSqliteError();
 }
 
 }  // namespace content