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

content/browser/indexed_db/indexed_db_backing_store.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/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
@@ skipping 468 matching lines @@
   if (!found)
     *max_object_store_id = 0;
 
   DCHECK_GE(*max_object_store_id, 0);
   return s;
 }
 
 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);
 };
 
 static bool GetBlobKeyGeneratorCurrentNumber(
     LevelDBTransaction* leveldb_transaction,
     int64 database_id,
@@ skipping 1693 matching lines @@
         database_id_(database_id),
         backing_store_(backing_store),
         callback_(callback),
         aborted_(false) {
     blobs_.swap(*blobs);
     iter_ = blobs_.begin();
     backing_store->task_runner()->PostTask(
         FROM_HERE, base::Bind(&ChainedBlobWriterImpl::WriteNextFile, this));
   }
 
-  virtual void set_delegate(scoped_ptr<FileWriterDelegate> delegate) override {
+  void set_delegate(scoped_ptr<FileWriterDelegate> delegate) override {
     delegate_.reset(delegate.release());
   }
 
-  virtual void ReportWriteCompletion(bool succeeded,
-                                     int64 bytes_written) override {
+  void ReportWriteCompletion(bool succeeded, int64 bytes_written) override {
     DCHECK(waiting_for_callback_);
     DCHECK(!succeeded || bytes_written >= 0);
     waiting_for_callback_ = false;
     if (delegate_.get())  // Only present for Blob, not File.
       content::BrowserThread::DeleteSoon(
           content::BrowserThread::IO, FROM_HERE, delegate_.release());
     if (aborted_) {
       self_ref_ = NULL;
       return;
     }
     if (iter_->size() != -1 && iter_->size() != bytes_written)
       succeeded = false;
     if (succeeded) {
       ++iter_;
       WriteNextFile();
     } else {
       callback_->Run(false);
     }
   }
 
-  virtual void Abort() override {
+  void Abort() override {
     if (!waiting_for_callback_)
       return;
     self_ref_ = this;
     aborted_ = true;
   }
 
  private:
-  virtual ~ChainedBlobWriterImpl() {}
+  ~ChainedBlobWriterImpl() override {}
 
   void WriteNextFile() {
     DCHECK(!waiting_for_callback_);
     DCHECK(!aborted_);
     if (iter_ == blobs_.end()) {
       DCHECK(!self_ref_.get());
       callback_->Run(true);
       return;
     } else {
       if (!backing_store_->WriteBlobFile(database_id_, *iter_, this)) {
@@ skipping 990 matching lines @@
   ObjectStoreKeyCursorImpl(
       scoped_refptr<IndexedDBBackingStore> backing_store,
       IndexedDBBackingStore::Transaction* transaction,
       int64 database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(backing_store,
                                       transaction,
                                       database_id,
                                       cursor_options) {}
 
-  virtual Cursor* Clone() override {
-    return new ObjectStoreKeyCursorImpl(this);
-  }
+  Cursor* Clone() override { return new ObjectStoreKeyCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
-  virtual IndexedDBValue* value() override {
+  IndexedDBValue* value() override {
     NOTREACHED();
     return NULL;
   }
-  virtual bool LoadCurrentRow() override;
+  bool LoadCurrentRow() override;
 
  protected:
-  virtual std::string EncodeKey(const IndexedDBKey& key) override {
+  std::string EncodeKey(const IndexedDBKey& key) override {
     return ObjectStoreDataKey::Encode(
         cursor_options_.database_id, cursor_options_.object_store_id, key);
   }
-  virtual std::string EncodeKey(const IndexedDBKey& key,
-                                const IndexedDBKey& primary_key) override {
+  std::string EncodeKey(const IndexedDBKey& key,
+                        const IndexedDBKey& primary_key) override {
     NOTREACHED();
     return std::string();
   }
 
  private:
   explicit ObjectStoreKeyCursorImpl(const ObjectStoreKeyCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other) {}
 
   DISALLOW_COPY_AND_ASSIGN(ObjectStoreKeyCursorImpl);
 };
@@ skipping 28 matching lines @@
   ObjectStoreCursorImpl(
       scoped_refptr<IndexedDBBackingStore> backing_store,
       IndexedDBBackingStore::Transaction* transaction,
       int64 database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(backing_store,
                                       transaction,
                                       database_id,
                                       cursor_options) {}
 
-  virtual Cursor* Clone() override { return new ObjectStoreCursorImpl(this); }
+  Cursor* Clone() override { return new ObjectStoreCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
-  virtual IndexedDBValue* value() override { return &current_value_; }
-  virtual bool LoadCurrentRow() override;
+  IndexedDBValue* value() override { return &current_value_; }
+  bool LoadCurrentRow() override;
 
  protected:
-  virtual std::string EncodeKey(const IndexedDBKey& key) override {
+  std::string EncodeKey(const IndexedDBKey& key) override {
     return ObjectStoreDataKey::Encode(
         cursor_options_.database_id, cursor_options_.object_store_id, key);
   }
-  virtual std::string EncodeKey(const IndexedDBKey& key,
-                                const IndexedDBKey& primary_key) override {
+  std::string EncodeKey(const IndexedDBKey& key,
+                        const IndexedDBKey& primary_key) override {
     NOTREACHED();
     return std::string();
   }
 
  private:
   explicit ObjectStoreCursorImpl(const ObjectStoreCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other),
         current_value_(other->current_value_) {}
 
   IndexedDBValue current_value_;
@@ skipping 37 matching lines @@
   IndexKeyCursorImpl(
       scoped_refptr<IndexedDBBackingStore> backing_store,
       IndexedDBBackingStore::Transaction* transaction,
       int64 database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(backing_store,
                                       transaction,
                                       database_id,
                                       cursor_options) {}
 
-  virtual Cursor* Clone() override { return new IndexKeyCursorImpl(this); }
+  Cursor* Clone() override { return new IndexKeyCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
-  virtual IndexedDBValue* value() override {
+  IndexedDBValue* value() override {
     NOTREACHED();
     return NULL;
   }
-  virtual const IndexedDBKey& primary_key() const override {
-    return *primary_key_;
-  }
-  virtual const IndexedDBBackingStore::RecordIdentifier& record_identifier()
+  const IndexedDBKey& primary_key() const override { return *primary_key_; }
+  const IndexedDBBackingStore::RecordIdentifier& record_identifier()
       const override {
     NOTREACHED();
     return record_identifier_;
   }
-  virtual bool LoadCurrentRow() override;
+  bool LoadCurrentRow() override;
 
  protected:
-  virtual std::string EncodeKey(const IndexedDBKey& key) override {
+  std::string EncodeKey(const IndexedDBKey& key) override {
     return IndexDataKey::Encode(cursor_options_.database_id,
                                 cursor_options_.object_store_id,
                                 cursor_options_.index_id,
                                 key);
   }
-  virtual std::string EncodeKey(const IndexedDBKey& key,
-                                const IndexedDBKey& primary_key) override {
+  std::string EncodeKey(const IndexedDBKey& key,
+                        const IndexedDBKey& primary_key) override {
     return IndexDataKey::Encode(cursor_options_.database_id,
                                 cursor_options_.object_store_id,
                                 cursor_options_.index_id,
                                 key,
                                 primary_key);
   }
 
  private:
   explicit IndexKeyCursorImpl(const IndexKeyCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other),
@@ skipping 69 matching lines @@
   IndexCursorImpl(
       scoped_refptr<IndexedDBBackingStore> backing_store,
       IndexedDBBackingStore::Transaction* transaction,
       int64 database_id,
       const IndexedDBBackingStore::Cursor::CursorOptions& cursor_options)
       : IndexedDBBackingStore::Cursor(backing_store,
                                       transaction,
                                       database_id,
                                       cursor_options) {}
 
-  virtual Cursor* Clone() override { return new IndexCursorImpl(this); }
+  Cursor* Clone() override { return new IndexCursorImpl(this); }
 
   // IndexedDBBackingStore::Cursor
-  virtual IndexedDBValue* value() override { return &current_value_; }
-  virtual const IndexedDBKey& primary_key() const override {
-    return *primary_key_;
-  }
-  virtual const IndexedDBBackingStore::RecordIdentifier& record_identifier()
+  IndexedDBValue* value() override { return &current_value_; }
+  const IndexedDBKey& primary_key() const override { return *primary_key_; }
+  const IndexedDBBackingStore::RecordIdentifier& record_identifier()
       const override {
     NOTREACHED();
     return record_identifier_;
   }
-  virtual bool LoadCurrentRow() override;
+  bool LoadCurrentRow() override;
 
  protected:
-  virtual std::string EncodeKey(const IndexedDBKey& key) override {
+  std::string EncodeKey(const IndexedDBKey& key) override {
     return IndexDataKey::Encode(cursor_options_.database_id,
                                 cursor_options_.object_store_id,
                                 cursor_options_.index_id,
                                 key);
   }
-  virtual std::string EncodeKey(const IndexedDBKey& key,
-                                const IndexedDBKey& primary_key) override {
+  std::string EncodeKey(const IndexedDBKey& key,
+                        const IndexedDBKey& primary_key) override {
     return IndexDataKey::Encode(cursor_options_.database_id,
                                 cursor_options_.object_store_id,
                                 cursor_options_.index_id,
                                 key,
                                 primary_key);
   }
 
  private:
   explicit IndexCursorImpl(const IndexCursorImpl* other)
       : IndexedDBBackingStore::Cursor(other),
@@ skipping 561 matching lines @@
   return s;
 }
 
 
 class IndexedDBBackingStore::Transaction::BlobWriteCallbackWrapper
     : public IndexedDBBackingStore::BlobWriteCallback {
  public:
   BlobWriteCallbackWrapper(IndexedDBBackingStore::Transaction* transaction,
                            scoped_refptr<BlobWriteCallback> callback)
       : transaction_(transaction), callback_(callback) {}
-  virtual void Run(bool succeeded) override {
+  void Run(bool succeeded) override {
     callback_->Run(succeeded);
     if (succeeded)  // Else it's already been deleted during rollback.
       transaction_->chained_blob_writer_ = NULL;
   }
 
  private:
-  virtual ~BlobWriteCallbackWrapper() {}
+  ~BlobWriteCallbackWrapper() override {}
   friend class base::RefCounted<IndexedDBBackingStore::BlobWriteCallback>;
 
   IndexedDBBackingStore::Transaction* transaction_;
   scoped_refptr<BlobWriteCallback> callback_;
 
   DISALLOW_COPY_AND_ASSIGN(BlobWriteCallbackWrapper);
 };
 
 void IndexedDBBackingStore::Transaction::WriteNewBlobs(
     BlobEntryKeyValuePairVec* new_blob_entries,
@@ skipping 137 matching lines @@
     int64_t size,
     base::Time last_modified)
     : is_file_(true),
       file_path_(file_path),
       key_(key),
       size_(size),
       last_modified_(last_modified) {
 }
 
 }  // namespace content