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

content/browser/appcache/view_appcache_internals_job.cc

 // Copyright 2014 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/view_appcache_internals_job.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/base64.h"
@@ skipping 307 matching lines @@
         appcache_service_(service),
         appcache_storage_(service->storage()) {
     appcache_service_->AddObserver(this);
   }
 
   virtual ~BaseInternalsJob() {
     appcache_service_->RemoveObserver(this);
   }
 
   virtual void OnServiceReinitialized(
-      AppCacheStorageReference* old_storage_ref) OVERRIDE {
+      AppCacheStorageReference* old_storage_ref) override {
     if (old_storage_ref->storage() == appcache_storage_)
       disabled_storage_reference_ = old_storage_ref;
   }
 
   AppCacheServiceImpl* appcache_service_;
   AppCacheStorage* appcache_storage_;
   scoped_refptr<AppCacheStorageReference> disabled_storage_reference_;
 };
 
 // Job that lists all appcaches in the system.
 class MainPageJob : public BaseInternalsJob {
  public:
   MainPageJob(net::URLRequest* request,
               net::NetworkDelegate* network_delegate,
               AppCacheServiceImpl* service)
       : BaseInternalsJob(request, network_delegate, service),
         weak_factory_(this) {
   }
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     DCHECK(request_);
     info_collection_ = new AppCacheInfoCollection;
     appcache_service_->GetAllAppCacheInfo(
         info_collection_.get(),
         base::Bind(&MainPageJob::OnGotInfoComplete,
                    weak_factory_.GetWeakPtr()));
   }
 
   // Produces a page containing the listing
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* out,
-                      const net::CompletionCallback& callback) const OVERRIDE {
+                      const net::CompletionCallback& callback) const override {
     mime_type->assign("text/html");
     charset->assign("UTF-8");
 
     out->clear();
     EmitPageStart(out);
     if (!info_collection_.get()) {
       out->append(kErrorMessage);
     } else if (info_collection_->infos_by_origin.empty()) {
       out->append(kEmptyAppCachesMessage);
     } else {
@@ skipping 32 matching lines @@
 class RedirectToMainPageJob : public BaseInternalsJob {
  public:
   RedirectToMainPageJob(net::URLRequest* request,
                         net::NetworkDelegate* network_delegate,
                         AppCacheServiceImpl* service)
       : BaseInternalsJob(request, network_delegate, service) {}
 
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* data,
-                      const net::CompletionCallback& callback) const OVERRIDE {
+                      const net::CompletionCallback& callback) const override {
     return net::OK;  // IsRedirectResponse induces a redirect.
   }
 
   virtual bool IsRedirectResponse(GURL* location,
-                                  int* http_status_code) OVERRIDE {
+                                  int* http_status_code) override {
     *location = ClearQuery(request_->url());
     *http_status_code = 307;
     return true;
   }
 
  protected:
   virtual ~RedirectToMainPageJob() {}
 };
 
 // Job that removes an appcache and then redirects back to the main page.
 class RemoveAppCacheJob : public RedirectToMainPageJob {
  public:
   RemoveAppCacheJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate,
       AppCacheServiceImpl* service,
       const GURL& manifest_url)
       : RedirectToMainPageJob(request, network_delegate, service),
         manifest_url_(manifest_url),
         weak_factory_(this) {
   }
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     DCHECK(request_);
 
     appcache_service_->DeleteAppCacheGroup(
         manifest_url_,base::Bind(&RemoveAppCacheJob::OnDeleteAppCacheComplete,
                                  weak_factory_.GetWeakPtr()));
   }
 
  private:
   virtual ~RemoveAppCacheJob() {}
 
@@ skipping 11 matching lines @@
                         public AppCacheStorage::Delegate {
  public:
   ViewAppCacheJob(
       net::URLRequest* request,
       net::NetworkDelegate* network_delegate,
       AppCacheServiceImpl* service,
       const GURL& manifest_url)
       : BaseInternalsJob(request, network_delegate, service),
         manifest_url_(manifest_url) {}
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     DCHECK(request_);
     appcache_storage_->LoadOrCreateGroup(manifest_url_, this);
   }
 
   // Produces a page containing the entries listing.
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* out,
-                      const net::CompletionCallback& callback) const OVERRIDE {
+                      const net::CompletionCallback& callback) const override {
     mime_type->assign("text/html");
     charset->assign("UTF-8");
     out->clear();
     EmitPageStart(out);
     if (appcache_info_.manifest_url.is_empty()) {
       out->append(kManifestNotFoundMessage);
     } else {
       GURL base_url = ClearQuery(request_->url());
       EmitAppCacheInfo(base_url, appcache_service_, &appcache_info_, out);
       EmitAppCacheResourceInfoVector(base_url,
                                      manifest_url_,
                                      resource_infos_,
                                      appcache_info_.group_id,
                                      out);
     }
     EmitPageEnd(out);
     return net::OK;
   }
 
  private:
   virtual ~ViewAppCacheJob() {
     appcache_storage_->CancelDelegateCallbacks(this);
   }
 
   // AppCacheStorage::Delegate override
   virtual void OnGroupLoaded(
-      AppCacheGroup* group, const GURL& manifest_url) OVERRIDE {
+      AppCacheGroup* group, const GURL& manifest_url) override {
     DCHECK_EQ(manifest_url_, manifest_url);
     if (group && group->newest_complete_cache()) {
       appcache_info_.manifest_url = manifest_url;
       appcache_info_.group_id = group->group_id();
       appcache_info_.size = group->newest_complete_cache()->cache_size();
       appcache_info_.creation_time = group->creation_time();
       appcache_info_.last_update_time =
           group->newest_complete_cache()->update_time();
       appcache_info_.last_access_time = base::Time::Now();
       group->newest_complete_cache()->ToResourceInfoVector(&resource_infos_);
@@ skipping 18 matching lines @@
       net::NetworkDelegate* network_delegate,
       AppCacheServiceImpl* service,
       const GURL& manifest_url,
       const GURL& entry_url,
       int64 response_id, int64 group_id)
       : BaseInternalsJob(request, network_delegate, service),
         manifest_url_(manifest_url), entry_url_(entry_url),
         response_id_(response_id), group_id_(group_id), amount_read_(0) {
   }
 
-  virtual void Start() OVERRIDE {
+  virtual void Start() override {
     DCHECK(request_);
     appcache_storage_->LoadResponseInfo(
         manifest_url_, group_id_, response_id_, this);
   }
 
   // Produces a page containing the response headers and data.
   virtual int GetData(std::string* mime_type,
                       std::string* charset,
                       std::string* out,
-                      const net::CompletionCallback& callback) const OVERRIDE {
+                      const net::CompletionCallback& callback) const override {
     mime_type->assign("text/html");
     charset->assign("UTF-8");
     out->clear();
     EmitPageStart(out);
     EmitAnchor(entry_url_.spec(), entry_url_.spec(), out);
     out->append("<br/>\n");
     if (response_info_.get()) {
       if (response_info_->http_response_info())
         EmitResponseHeaders(response_info_->http_response_info()->headers.get(),
                             out);
@@ skipping 14 matching lines @@
     EmitPageEnd(out);
     return net::OK;
   }
 
  private:
   virtual ~ViewEntryJob() {
     appcache_storage_->CancelDelegateCallbacks(this);
   }
 
   virtual void OnResponseInfoLoaded(
-      AppCacheResponseInfo* response_info, int64 response_id) OVERRIDE {
+      AppCacheResponseInfo* response_info, int64 response_id) override {
     if (!response_info) {
       StartAsync();
       return;
     }
     response_info_ = response_info;
 
     // Read the response data, truncating if its too large.
     const int64 kLimit = 100 * 1000;
     int64 amount_to_read =
         std::min(kLimit, response_info->response_data_size());
@@ skipping 55 matching lines @@
     return new ViewEntryJob(request, network_delegate, service,
                             DecodeBase64URL(tokens[0]),  // manifest url
                             DecodeBase64URL(tokens[1]),  // entry url
                             response_id, group_id);
   }
 
   return new RedirectToMainPageJob(request, network_delegate, service);
 }
 
 }  // namespace content