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

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 303 matching lines @@
  protected:
   BaseInternalsJob(net::URLRequest* request,
                    net::NetworkDelegate* network_delegate,
                    AppCacheServiceImpl* service)
       : URLRequestSimpleJob(request, network_delegate),
         appcache_service_(service),
         appcache_storage_(service->storage()) {
     appcache_service_->AddObserver(this);
   }
 
-  virtual ~BaseInternalsJob() {
-    appcache_service_->RemoveObserver(this);
-  }
+  ~BaseInternalsJob() override { appcache_service_->RemoveObserver(this); }
 
-  virtual void OnServiceReinitialized(
+  void OnServiceReinitialized(
       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 {
+  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 {
+  int GetData(std::string* mime_type,
+              std::string* charset,
+              std::string* out,
+              const net::CompletionCallback& callback) const override {
     // TODO(vadimt): Remove ScopedProfile below once crbug.com/422489 is fixed.
     tracked_objects::ScopedProfile tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION("422489 MainPageJob::GetData"));
 
     mime_type->assign("text/html");
     charset->assign("UTF-8");
 
     out->clear();
     EmitPageStart(out);
     if (!info_collection_.get()) {
@@ skipping 12 matching lines @@
       std::sort(appcaches.begin(), appcaches.end(), SortByManifestUrl);
 
       GURL base_url = ClearQuery(request_->url());
       EmitAppCacheInfoVector(base_url, appcache_service_, appcaches, out);
     }
     EmitPageEnd(out);
     return net::OK;
   }
 
  private:
-  virtual ~MainPageJob() {}
+  ~MainPageJob() override {}
 
   void OnGotInfoComplete(int rv) {
     if (rv != net::OK)
       info_collection_ = NULL;
     StartAsync();
   }
 
   scoped_refptr<AppCacheInfoCollection> info_collection_;
   base::WeakPtrFactory<MainPageJob> weak_factory_;
   DISALLOW_COPY_AND_ASSIGN(MainPageJob);
 };
 
 // Job that redirects back to the main appcache internals page.
 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 {
+  int GetData(std::string* mime_type,
+              std::string* charset,
+              std::string* data,
+              const net::CompletionCallback& callback) const override {
     return net::OK;  // IsRedirectResponse induces a redirect.
   }
 
-  virtual bool IsRedirectResponse(GURL* location,
-                                  int* http_status_code) override {
+  bool IsRedirectResponse(GURL* location, int* http_status_code) override {
     *location = ClearQuery(request_->url());
     *http_status_code = 307;
     return true;
   }
 
  protected:
-  virtual ~RedirectToMainPageJob() {}
+  ~RedirectToMainPageJob() override {}
 };
 
 // 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 {
+  void Start() override {
     DCHECK(request_);
 
     appcache_service_->DeleteAppCacheGroup(
         manifest_url_,base::Bind(&RemoveAppCacheJob::OnDeleteAppCacheComplete,
                                  weak_factory_.GetWeakPtr()));
   }
 
  private:
-  virtual ~RemoveAppCacheJob() {}
+  ~RemoveAppCacheJob() override {}
 
   void OnDeleteAppCacheComplete(int rv) {
     StartAsync();  // Causes the base class to redirect.
   }
 
   GURL manifest_url_;
   base::WeakPtrFactory<RemoveAppCacheJob> weak_factory_;
 };
 
 
 // Job shows the details of a particular manifest url.
 class ViewAppCacheJob : public BaseInternalsJob,
                         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 {
+  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 {
+  int GetData(std::string* mime_type,
+              std::string* charset,
+              std::string* out,
+              const net::CompletionCallback& callback) const override {
     // TODO(vadimt): Remove ScopedProfile below once crbug.com/422489 is fixed.
     tracked_objects::ScopedProfile tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION("422489 ViewAppCacheJob::GetData"));
 
     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() {
+  ~ViewAppCacheJob() override {
     appcache_storage_->CancelDelegateCallbacks(this);
   }
 
   // AppCacheStorage::Delegate override
-  virtual void OnGroupLoaded(
-      AppCacheGroup* group, const GURL& manifest_url) override {
+  void OnGroupLoaded(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 {
+  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 {
+  int GetData(std::string* mime_type,
+              std::string* charset,
+              std::string* out,
+              const net::CompletionCallback& callback) const override {
     // TODO(vadimt): Remove ScopedProfile below once crbug.com/422489 is fixed.
     tracked_objects::ScopedProfile tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION("422489 ViewEntryJob::GetData"));
 
     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");
@@ skipping 13 matching lines @@
         out->append("Failed to read response data.<br>");
       }
     } else {
       out->append("Failed to read response headers and data.<br>");
     }
     EmitPageEnd(out);
     return net::OK;
   }
 
  private:
-  virtual ~ViewEntryJob() {
-    appcache_storage_->CancelDelegateCallbacks(this);
-  }
+  ~ViewEntryJob() override { appcache_storage_->CancelDelegateCallbacks(this); }
 
-  virtual void OnResponseInfoLoaded(
-      AppCacheResponseInfo* response_info, int64 response_id) override {
+  void OnResponseInfoLoaded(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