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

content/browser/indexed_db/indexed_db_backing_store_unittest.cc

 // Copyright (c) 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/browser/indexed_db/indexed_db_backing_store.h"
 
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
@@ skipping 16 matching lines @@
 #include "third_party/WebKit/public/platform/WebIDBTypes.h"
 
 using base::ASCIIToUTF16;
 
 namespace content {
 
 namespace {
 
 class Comparator : public LevelDBComparator {
  public:
-  virtual int Compare(const base::StringPiece& a,
-                      const base::StringPiece& b) const override {
+  int Compare(const base::StringPiece& a,
+              const base::StringPiece& b) const override {
     return content::Compare(a, b, false /*index_keys*/);
   }
-  virtual const char* Name() const override { return "idb_cmp1"; }
+  const char* Name() const override { return "idb_cmp1"; }
 };
 
 class DefaultLevelDBFactory : public LevelDBFactory {
  public:
   DefaultLevelDBFactory() {}
-  virtual leveldb::Status OpenLevelDB(const base::FilePath& file_name,
-                                      const LevelDBComparator* comparator,
-                                      scoped_ptr<LevelDBDatabase>* db,
-                                      bool* is_disk_full) override {
+  leveldb::Status OpenLevelDB(const base::FilePath& file_name,
+                              const LevelDBComparator* comparator,
+                              scoped_ptr<LevelDBDatabase>* db,
+                              bool* is_disk_full) override {
     return LevelDBDatabase::Open(file_name, comparator, db, is_disk_full);
   }
-  virtual leveldb::Status DestroyLevelDB(
-      const base::FilePath& file_name) override {
+  leveldb::Status DestroyLevelDB(const base::FilePath& file_name) override {
     return LevelDBDatabase::Destroy(file_name);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(DefaultLevelDBFactory);
 };
 
 class TestableIndexedDBBackingStore : public IndexedDBBackingStore {
  public:
   static scoped_refptr<TestableIndexedDBBackingStore> Open(
@@ skipping 42 matching lines @@
 
   const std::vector<IndexedDBBackingStore::Transaction::WriteDescriptor>&
   writes() const {
     return writes_;
   }
   void ClearWrites() { writes_.clear(); }
   const std::vector<int64>& removals() const { return removals_; }
   void ClearRemovals() { removals_.clear(); }
 
  protected:
-  virtual ~TestableIndexedDBBackingStore() {}
+  ~TestableIndexedDBBackingStore() override {}
 
-  virtual bool WriteBlobFile(
+  bool WriteBlobFile(
       int64 database_id,
       const Transaction::WriteDescriptor& descriptor,
       Transaction::ChainedBlobWriter* chained_blob_writer) override {
     if (KeyPrefix::IsValidDatabaseId(database_id_)) {
       if (database_id_ != database_id) {
         return false;
       }
     } else {
       database_id_ = database_id;
     }
     writes_.push_back(descriptor);
     task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&Transaction::ChainedBlobWriter::ReportWriteCompletion,
                    chained_blob_writer,
                    true,
                    1));
     return true;
   }
 
-  virtual bool RemoveBlobFile(int64 database_id, int64 key) override {
+  bool RemoveBlobFile(int64 database_id, int64 key) override {
     if (database_id_ != database_id ||
         !KeyPrefix::IsValidDatabaseId(database_id)) {
       return false;
     }
     removals_.push_back(key);
     return true;
   }
 
   // Timers don't play nicely with unit tests.
-  virtual void StartJournalCleaningTimer() override {
+  void StartJournalCleaningTimer() override {
     CleanPrimaryJournalIgnoreReturn();
   }
 
  private:
   TestableIndexedDBBackingStore(IndexedDBFactory* indexed_db_factory,
                                 const GURL& origin_url,
                                 const base::FilePath& blob_path,
                                 net::URLRequestContext* request_context,
                                 scoped_ptr<LevelDBDatabase> db,
                                 scoped_ptr<LevelDBComparator> comparator,
@@ skipping 33 matching lines @@
                          &data_loss,
                          &data_loss_reason,
                          &disk_full,
                          &status);
     scoped_refptr<TestableIndexedDBBackingStore> testable_store =
         static_cast<TestableIndexedDBBackingStore*>(backing_store.get());
     return testable_store;
   }
 
  protected:
-  virtual ~TestIDBFactory() {}
+  ~TestIDBFactory() override {}
 
-  virtual scoped_refptr<IndexedDBBackingStore> OpenBackingStoreHelper(
+  scoped_refptr<IndexedDBBackingStore> OpenBackingStoreHelper(
       const GURL& origin_url,
       const base::FilePath& data_directory,
       net::URLRequestContext* request_context,
       blink::WebIDBDataLoss* data_loss,
       std::string* data_loss_message,
       bool* disk_full,
       bool first_time,
       leveldb::Status* status) override {
     DefaultLevelDBFactory leveldb_factory;
     return TestableIndexedDBBackingStore::Open(this,
@@ skipping 135 matching lines @@
   IndexedDBValue m_value3;
   std::vector<IndexedDBBlobInfo> m_blob_info;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(IndexedDBBackingStoreTest);
 };
 
 class TestCallback : public IndexedDBBackingStore::BlobWriteCallback {
  public:
   TestCallback() : called(false), succeeded(false) {}
-  virtual void Run(bool succeeded_in) override {
+  void Run(bool succeeded_in) override {
     called = true;
     succeeded = succeeded_in;
   }
   bool called;
   bool succeeded;
 
  protected:
-  virtual ~TestCallback() {}
+  ~TestCallback() override {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TestCallback);
 };
 
 TEST_F(IndexedDBBackingStoreTest, PutGetConsistency) {
   {
     IndexedDBBackingStore::Transaction transaction1(backing_store_.get());
     transaction1.Begin();
     ScopedVector<storage::BlobDataHandle> handles;
@@ skipping 617 matching lines @@
 
   std::vector<base::string16> names = backing_store_->GetDatabaseNames(&s);
   EXPECT_TRUE(s.ok());
   EXPECT_EQ(names.size(), 1ULL);
   EXPECT_EQ(names[0], db1_name);
 }
 
 }  // namespace
 
 }  // namespace content