Replacing the OVERRIDE with override and FINAL with final in content/browser/indexed_db

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 17 matching lines @@
 
 using base::ASCIIToUTF16;
 
 namespace content {
 
 namespace {
 
 class Comparator : public LevelDBComparator {
  public:
   virtual int Compare(const base::StringPiece& a,
-                      const base::StringPiece& b) const OVERRIDE {
+                      const base::StringPiece& b) const override {
     return content::Compare(a, b, false /*index_keys*/);
   }
-  virtual const char* Name() const OVERRIDE { return "idb_cmp1"; }
+  virtual 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 {
+                                      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 {
+      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 47 matching lines @@
   void ClearWrites() { writes_.clear(); }
   const std::vector<int64>& removals() const { return removals_; }
   void ClearRemovals() { removals_.clear(); }
 
  protected:
   virtual ~TestableIndexedDBBackingStore() {}
 
   virtual bool WriteBlobFile(
       int64 database_id,
       const Transaction::WriteDescriptor& descriptor,
-      Transaction::ChainedBlobWriter* chained_blob_writer) OVERRIDE {
+      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 {
+  virtual 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 {
+  virtual 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 43 matching lines @@
   virtual ~TestIDBFactory() {}
 
   virtual 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 {
+      leveldb::Status* status) override {
     DefaultLevelDBFactory leveldb_factory;
     return TestableIndexedDBBackingStore::Open(this,
                                                origin_url,
                                                data_directory,
                                                request_context,
                                                &leveldb_factory,
                                                context()->TaskRunner(),
                                                status);
   }
 
@@ skipping 127 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 {
+  virtual void Run(bool succeeded_in) override {
     called = true;
     succeeded = succeeded_in;
   }
   bool called;
   bool succeeded;
 
  protected:
   virtual ~TestCallback() {}
 
  private:
@@ skipping 625 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