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

content/browser/appcache/appcache_storage_impl.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 "content/browser/appcache/appcache_storage_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <set>
 #include <vector>
@@ skipping 250 matching lines @@
         last_deletable_response_rowid_(0) {
     if (!storage->is_incognito_) {
       db_file_path_ =
           storage->cache_directory_.Append(kAppCacheDatabaseName);
       disk_cache_directory_ =
           storage->cache_directory_.Append(kDiskCacheDirectoryName);
     }
   }
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE;
-  virtual void RunCompleted() OVERRIDE;
+  virtual void Run() override;
+  virtual void RunCompleted() override;
 
  protected:
   virtual ~InitTask() {}
 
  private:
   base::FilePath db_file_path_;
   base::FilePath disk_cache_directory_;
   int64 last_group_id_;
   int64 last_cache_id_;
   int64 last_response_id_;
@@ skipping 40 matching lines @@
 }
 
 // DisableDatabaseTask -------
 
 class AppCacheStorageImpl::DisableDatabaseTask : public DatabaseTask {
  public:
   explicit DisableDatabaseTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE { database_->Disable(); }
+  virtual void Run() override { database_->Disable(); }
 
  protected:
   virtual ~DisableDatabaseTask() {}
 };
 
 // GetAllInfoTask -------
 
 class AppCacheStorageImpl::GetAllInfoTask : public DatabaseTask {
  public:
   explicit GetAllInfoTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage),
         info_collection_(new AppCacheInfoCollection()) {
   }
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE;
-  virtual void RunCompleted() OVERRIDE;
+  virtual void Run() override;
+  virtual void RunCompleted() override;
 
  protected:
   virtual ~GetAllInfoTask() {}
 
  private:
   scoped_refptr<AppCacheInfoCollection> info_collection_;
 };
 
 void AppCacheStorageImpl::GetAllInfoTask::Run() {
   std::set<GURL> origins;
@@ skipping 132 matching lines @@
 
 // CacheLoadTask -------
 
 class AppCacheStorageImpl::CacheLoadTask : public StoreOrLoadTask {
  public:
   CacheLoadTask(int64 cache_id, AppCacheStorageImpl* storage)
       : StoreOrLoadTask(storage), cache_id_(cache_id),
         success_(false) {}
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE;
-  virtual void RunCompleted() OVERRIDE;
+  virtual void Run() override;
+  virtual void RunCompleted() override;
 
  protected:
   virtual ~CacheLoadTask() {}
 
  private:
   int64 cache_id_;
   bool success_;
 };
 
 void AppCacheStorageImpl::CacheLoadTask::Run() {
@@ skipping 20 matching lines @@
 
 // GroupLoadTask -------
 
 class AppCacheStorageImpl::GroupLoadTask : public StoreOrLoadTask {
  public:
   GroupLoadTask(GURL manifest_url, AppCacheStorageImpl* storage)
       : StoreOrLoadTask(storage), manifest_url_(manifest_url),
         success_(false) {}
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE;
-  virtual void RunCompleted() OVERRIDE;
+  virtual void Run() override;
+  virtual void RunCompleted() override;
 
  protected:
   virtual ~GroupLoadTask() {}
 
  private:
   GURL manifest_url_;
   bool success_;
 };
 
 void AppCacheStorageImpl::GroupLoadTask::Run() {
@@ skipping 32 matching lines @@
  public:
   StoreGroupAndCacheTask(AppCacheStorageImpl* storage, AppCacheGroup* group,
                          AppCache* newest_cache);
 
   void GetQuotaThenSchedule();
   void OnQuotaCallback(storage::QuotaStatusCode status,
                        int64 usage,
                        int64 quota);
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE;
-  virtual void RunCompleted() OVERRIDE;
-  virtual void CancelCompletion() OVERRIDE;
+  virtual void Run() override;
+  virtual void RunCompleted() override;
+  virtual void CancelCompletion() override;
 
  protected:
   virtual ~StoreGroupAndCacheTask() {}
 
  private:
   scoped_refptr<AppCacheGroup> group_;
   scoped_refptr<AppCache> cache_;
   bool success_;
   bool would_exceed_quota_;
   int64 space_available_;
@@ skipping 282 matching lines @@
         AppCacheGroup* group = it->second;
         AppCache* cache = group->newest_complete_cache();
         if (group->is_obsolete() || !cache)
           continue;
         cache_ids_in_use_.insert(cache->cache_id());
       }
     }
   }
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE;
-  virtual void RunCompleted() OVERRIDE;
+  virtual void Run() override;
+  virtual void RunCompleted() override;
 
  protected:
   virtual ~FindMainResponseTask() {}
 
  private:
   typedef std::vector<AppCacheDatabase::NamespaceRecord*>
       NamespaceRecordPtrVector;
 
   bool FindExactMatch(int64 preferred_id);
   bool FindNamespaceMatch(int64 preferred_id);
@@ skipping 179 matching lines @@
 
 // MarkEntryAsForeignTask -------
 
 class AppCacheStorageImpl::MarkEntryAsForeignTask : public DatabaseTask {
  public:
   MarkEntryAsForeignTask(
       AppCacheStorageImpl* storage, const GURL& url, int64 cache_id)
       : DatabaseTask(storage), cache_id_(cache_id), entry_url_(url) {}
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE;
-  virtual void RunCompleted() OVERRIDE;
+  virtual void Run() override;
+  virtual void RunCompleted() override;
 
  protected:
   virtual ~MarkEntryAsForeignTask() {}
 
  private:
   int64 cache_id_;
   GURL entry_url_;
 };
 
 void AppCacheStorageImpl::MarkEntryAsForeignTask::Run() {
   database_->AddEntryFlags(entry_url_, cache_id_, AppCacheEntry::FOREIGN);
 }
 
 void AppCacheStorageImpl::MarkEntryAsForeignTask::RunCompleted() {
   DCHECK(storage_->pending_foreign_markings_.front().first == entry_url_ &&
          storage_->pending_foreign_markings_.front().second == cache_id_);
   storage_->pending_foreign_markings_.pop_front();
 }
 
 // MakeGroupObsoleteTask -------
 
 class AppCacheStorageImpl::MakeGroupObsoleteTask : public DatabaseTask {
  public:
   MakeGroupObsoleteTask(AppCacheStorageImpl* storage,
                         AppCacheGroup* group,
                         int response_code);
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE;
-  virtual void RunCompleted() OVERRIDE;
-  virtual void CancelCompletion() OVERRIDE;
+  virtual void Run() override;
+  virtual void RunCompleted() override;
+  virtual void CancelCompletion() override;
 
  protected:
   virtual ~MakeGroupObsoleteTask() {}
 
  private:
   scoped_refptr<AppCacheGroup> group_;
   int64 group_id_;
   GURL origin_;
   bool success_;
   int response_code_;
@@ skipping 66 matching lines @@
 }
 
 // GetDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::GetDeletableResponseIdsTask : public DatabaseTask {
  public:
   GetDeletableResponseIdsTask(AppCacheStorageImpl* storage, int64 max_rowid)
       : DatabaseTask(storage), max_rowid_(max_rowid) {}
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE;
-  virtual void RunCompleted() OVERRIDE;
+  virtual void Run() override;
+  virtual void RunCompleted() override;
 
  protected:
   virtual ~GetDeletableResponseIdsTask() {}
 
  private:
   int64 max_rowid_;
   std::vector<int64> response_ids_;
 };
 
 void AppCacheStorageImpl::GetDeletableResponseIdsTask::Run() {
   const int kSqlLimit = 1000;
   database_->GetDeletableResponseIds(&response_ids_, max_rowid_, kSqlLimit);
   // TODO(michaeln): retrieve group_ids too
 }
 
 void AppCacheStorageImpl::GetDeletableResponseIdsTask::RunCompleted() {
   if (!response_ids_.empty())
     storage_->StartDeletingResponses(response_ids_);
 }
 
 // InsertDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::InsertDeletableResponseIdsTask
     : public DatabaseTask {
  public:
   explicit InsertDeletableResponseIdsTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
   std::vector<int64> response_ids_;
 
  protected:
   virtual ~InsertDeletableResponseIdsTask() {}
 };
 
 void AppCacheStorageImpl::InsertDeletableResponseIdsTask::Run() {
   database_->InsertDeletableResponseIds(response_ids_);
   // TODO(michaeln): store group_ids too
 }
 
 // DeleteDeletableResponseIdsTask -------
 
 class AppCacheStorageImpl::DeleteDeletableResponseIdsTask
     : public DatabaseTask {
  public:
   explicit DeleteDeletableResponseIdsTask(AppCacheStorageImpl* storage)
       : DatabaseTask(storage) {}
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
   std::vector<int64> response_ids_;
 
  protected:
   virtual ~DeleteDeletableResponseIdsTask() {}
 };
 
 void AppCacheStorageImpl::DeleteDeletableResponseIdsTask::Run() {
   database_->DeleteDeletableResponseIds(response_ids_);
 }
 
 // UpdateGroupLastAccessTimeTask -------
 
 class AppCacheStorageImpl::UpdateGroupLastAccessTimeTask
     : public DatabaseTask {
  public:
   UpdateGroupLastAccessTimeTask(
       AppCacheStorageImpl* storage, AppCacheGroup* group, base::Time time)
       : DatabaseTask(storage), group_id_(group->group_id()),
         last_access_time_(time) {
     storage->NotifyStorageAccessed(group->manifest_url().GetOrigin());
   }
 
   // DatabaseTask:
-  virtual void Run() OVERRIDE;
+  virtual void Run() override;
 
  protected:
   virtual ~UpdateGroupLastAccessTimeTask() {}
 
  private:
   int64 group_id_;
   base::Time last_access_time_;
 };
 
 void AppCacheStorageImpl::UpdateGroupLastAccessTimeTask::Run() {
@@ skipping 544 matching lines @@
       base::Bind(&AppCacheStorageImpl::CallScheduleReinitialize,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AppCacheStorageImpl::CallScheduleReinitialize() {
   service_->ScheduleReinitialize();
   // note: 'this' may be deleted at this point.
 }
 
 }  // namespace content