Standardize usage of virtual/override/final in chrome/browser/extensions/

chrome/browser/extensions/api/storage/settings_sync_unittest.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 77 matching lines @@
   return ValuesEq(_1, _2, &expected, &actual->settings());
 }
 
 // SyncChangeProcessor which just records the changes made, accessed after
 // being converted to the more useful SettingSyncData via changes().
 class MockSyncChangeProcessor : public syncer::SyncChangeProcessor {
  public:
   MockSyncChangeProcessor() : fail_all_requests_(false) {}
 
   // syncer::SyncChangeProcessor implementation.
-  virtual syncer::SyncError ProcessSyncChanges(
+  syncer::SyncError ProcessSyncChanges(
       const tracked_objects::Location& from_here,
       const syncer::SyncChangeList& change_list) override {
     if (fail_all_requests_) {
       return syncer::SyncError(
           FROM_HERE,
           syncer::SyncError::DATATYPE_ERROR,
           "MockSyncChangeProcessor: configured to fail",
           change_list[0].sync_data().GetDataType());
     }
     for (syncer::SyncChangeList::const_iterator it = change_list.begin();
         it != change_list.end(); ++it) {
       changes_.push_back(SettingSyncData(*it));
     }
     return syncer::SyncError();
   }
 
-  virtual syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const
-      override {
+  syncer::SyncDataList GetAllSyncData(syncer::ModelType type) const override {
     return syncer::SyncDataList();
   }
 
   // Mock methods.
 
   const SettingSyncDataList& changes() { return changes_; }
 
   void ClearChanges() {
     changes_.clear();
   }
@@ skipping 37 matching lines @@
 // SettingsStorageFactory which always returns TestingValueStore objects,
 // and allows individually created objects to be returned.
 class TestingValueStoreFactory : public SettingsStorageFactory {
  public:
   TestingValueStore* GetExisting(const std::string& extension_id) {
     DCHECK(created_.count(extension_id));
     return created_[extension_id];
   }
 
   // SettingsStorageFactory implementation.
-  virtual ValueStore* Create(const base::FilePath& base_path,
-                             const std::string& extension_id) override {
+  ValueStore* Create(const base::FilePath& base_path,
+                     const std::string& extension_id) override {
     TestingValueStore* new_storage = new TestingValueStore();
     DCHECK(!created_.count(extension_id));
     created_[extension_id] = new_storage;
     return new_storage;
   }
 
   // Testing value stores don't actually create a real database. Don't delete
   // any files.
-  virtual void DeleteDatabaseIfExists(
-      const base::FilePath& base_path,
-      const std::string& extension_id) override {}
+  void DeleteDatabaseIfExists(const base::FilePath& base_path,
+                              const std::string& extension_id) override {}
 
  private:
   // SettingsStorageFactory is refcounted.
-  virtual ~TestingValueStoreFactory() {}
+  ~TestingValueStoreFactory() override {}
 
   // None of these storage areas are owned by this factory, so care must be
   // taken when calling GetExisting.
   std::map<std::string, TestingValueStore*> created_;
 };
 
 }  // namespace
 
 class ExtensionSettingsSyncTest : public testing::Test {
  public:
@@ skipping 1302 matching lines @@
                             settings_namespace::SYNC,
                             base::Bind(&UnlimitedSyncStorageTestCallback));
   frontend_->RunWithStorage(extension,
                             settings_namespace::LOCAL,
                             base::Bind(&UnlimitedLocalStorageTestCallback));
 
   base::MessageLoop::current()->RunUntilIdle();
 }
 
 }  // namespace extensions