Replacing the OVERRIDE with override and FINAL with final in storage

storage/browser/quota/quota_manager.cc

 // Copyright 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 "storage/browser/quota/quota_manager.h"
 
 #include <algorithm>
 #include <deque>
 #include <functional>
 #include <set>
@@ skipping 402 matching lines @@
   }
 
   void DidGetAvailableSpace(QuotaStatusCode status, int64 space) {
     DCHECK_GE(space, 0);
     if (status_ == kQuotaStatusUnknown || status_ == kQuotaStatusOk)
       status_ = status;
     usage_and_quota_.available_disk_space = space;
     CheckCompleted();
   }
 
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     // We initialize waiting_callbacks to 1 so that we won't run
     // the completion callback until here even some of the callbacks
     // are dispatched synchronously.
     CheckCompleted();
   }
 
-  virtual void Aborted() OVERRIDE {
+  virtual void Aborted() override {
     callback_.Run(kQuotaErrorAbort, UsageAndQuota());
     DeleteSoon();
   }
 
-  virtual void Completed() OVERRIDE {
+  virtual void Completed() override {
     DCHECK(!has_usage_ || usage_and_quota_.usage >= 0);
     DCHECK(!has_global_limited_usage_ ||
            usage_and_quota_.global_limited_usage >= 0);
     DCHECK(!has_quota_ || usage_and_quota_.quota >= 0);
     DCHECK(!has_available_disk_space_ ||
            usage_and_quota_.available_disk_space >= 0);
 
     callback_.Run(status_, usage_and_quota_);
     DeleteSoon();
   }
@@ skipping 21 matching lines @@
  public:
   GetUsageInfoTask(
       QuotaManager* manager,
       const GetUsageInfoCallback& callback)
       : QuotaTask(manager),
         callback_(callback),
         weak_factory_(this) {
   }
 
  protected:
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     remaining_trackers_ = 3;
     // This will populate cached hosts and usage info.
     manager()->GetUsageTracker(kStorageTypeTemporary)->GetGlobalUsage(
         base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
                    weak_factory_.GetWeakPtr(),
                    kStorageTypeTemporary));
     manager()->GetUsageTracker(kStorageTypePersistent)->GetGlobalUsage(
         base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
                    weak_factory_.GetWeakPtr(),
                    kStorageTypePersistent));
     manager()->GetUsageTracker(kStorageTypeSyncable)->GetGlobalUsage(
         base::Bind(&GetUsageInfoTask::DidGetGlobalUsage,
                    weak_factory_.GetWeakPtr(),
                    kStorageTypeSyncable));
   }
 
-  virtual void Completed() OVERRIDE {
+  virtual void Completed() override {
     callback_.Run(entries_);
     DeleteSoon();
   }
 
-  virtual void Aborted() OVERRIDE {
+  virtual void Aborted() override {
     callback_.Run(UsageInfoEntries());
     DeleteSoon();
   }
 
  private:
   void AddEntries(StorageType type, UsageTracker* tracker) {
     std::map<std::string, int64> host_usage;
     tracker->GetCachedHostsUsage(&host_usage);
     for (std::map<std::string, int64>::const_iterator iter = host_usage.begin();
          iter != host_usage.end();
@@ skipping 32 matching lines @@
         origin_(origin),
         type_(type),
         quota_client_mask_(quota_client_mask),
         error_count_(0),
         remaining_clients_(-1),
         skipped_clients_(0),
         callback_(callback),
         weak_factory_(this) {}
 
  protected:
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     error_count_ = 0;
     remaining_clients_ = manager()->clients_.size();
     for (QuotaClientList::iterator iter = manager()->clients_.begin();
          iter != manager()->clients_.end(); ++iter) {
       if (quota_client_mask_ & (*iter)->id()) {
         (*iter)->DeleteOriginData(
             origin_, type_,
             base::Bind(&OriginDataDeleter::DidDeleteOriginData,
                        weak_factory_.GetWeakPtr()));
       } else {
         ++skipped_clients_;
         if (--remaining_clients_ == 0)
           CallCompleted();
       }
     }
   }
 
-  virtual void Completed() OVERRIDE {
+  virtual void Completed() override {
     if (error_count_ == 0) {
       // Only remove the entire origin if we didn't skip any client types.
       if (skipped_clients_ == 0)
         manager()->DeleteOriginFromDatabase(origin_, type_);
       callback_.Run(kQuotaStatusOk);
     } else {
       callback_.Run(kQuotaErrorInvalidModification);
     }
     DeleteSoon();
   }
 
-  virtual void Aborted() OVERRIDE {
+  virtual void Aborted() override {
     callback_.Run(kQuotaErrorAbort);
     DeleteSoon();
   }
 
  private:
   void DidDeleteOriginData(QuotaStatusCode status) {
     DCHECK_GT(remaining_clients_, 0);
 
     if (status != kQuotaStatusOk)
       ++error_count_;
@@ skipping 29 matching lines @@
         host_(host),
         type_(type),
         quota_client_mask_(quota_client_mask),
         error_count_(0),
         remaining_clients_(-1),
         remaining_deleters_(-1),
         callback_(callback),
         weak_factory_(this) {}
 
  protected:
-  virtual void Run() OVERRIDE {
+  virtual void Run() override {
     error_count_ = 0;
     remaining_clients_ = manager()->clients_.size();
     for (QuotaClientList::iterator iter = manager()->clients_.begin();
          iter != manager()->clients_.end(); ++iter) {
       (*iter)->GetOriginsForHost(
           type_, host_,
           base::Bind(&HostDataDeleter::DidGetOriginsForHost,
                      weak_factory_.GetWeakPtr()));
     }
   }
 
-  virtual void Completed() OVERRIDE {
+  virtual void Completed() override {
     if (error_count_ == 0) {
       callback_.Run(kQuotaStatusOk);
     } else {
       callback_.Run(kQuotaErrorInvalidModification);
     }
     DeleteSoon();
   }
 
-  virtual void Aborted() OVERRIDE {
+  virtual void Aborted() override {
     callback_.Run(kQuotaErrorAbort);
     DeleteSoon();
   }
 
  private:
   void DidGetOriginsForHost(const std::set<GURL>& origins) {
     DCHECK_GT(remaining_clients_, 0);
 
     origins_.insert(origins.begin(), origins.end());
 
@@ skipping 958 matching lines @@
   // |database_|, therefore we can be sure that database_ is alive when this
   // task runs.
   base::PostTaskAndReplyWithResult(
       db_thread_.get(),
       from_here,
       base::Bind(task, base::Unretained(database_.get())),
       reply);
 }
 
 }  // namespace storage