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

content/browser/appcache/appcache_host_unittest.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_backend_impl.h"
@@ skipping 24 matching lines @@
   class MockFrontend : public AppCacheFrontend {
    public:
     MockFrontend()
         : last_host_id_(-222), last_cache_id_(-222),
           last_status_(APPCACHE_STATUS_OBSOLETE),
           last_status_changed_(APPCACHE_STATUS_OBSOLETE),
           last_event_id_(APPCACHE_OBSOLETE_EVENT),
           content_blocked_(false) {
     }
 
-    virtual void OnCacheSelected(
-        int host_id, const AppCacheInfo& info) override {
+    void OnCacheSelected(int host_id, const AppCacheInfo& info) override {
       last_host_id_ = host_id;
       last_cache_id_ = info.cache_id;
       last_status_ = info.status;
     }
 
-    virtual void OnStatusChanged(const std::vector<int>& host_ids,
-                                 AppCacheStatus status) override {
+    void OnStatusChanged(const std::vector<int>& host_ids,
+                         AppCacheStatus status) override {
       last_status_changed_ = status;
     }
 
-    virtual void OnEventRaised(const std::vector<int>& host_ids,
-                               AppCacheEventID event_id) override {
+    void OnEventRaised(const std::vector<int>& host_ids,
+                       AppCacheEventID event_id) override {
       last_event_id_ = event_id;
     }
 
-    virtual void OnErrorEventRaised(
-        const std::vector<int>& host_ids,
-        const AppCacheErrorDetails& details) override {
+    void OnErrorEventRaised(const std::vector<int>& host_ids,
+                            const AppCacheErrorDetails& details) override {
       last_event_id_ = APPCACHE_ERROR_EVENT;
     }
 
-    virtual void OnProgressEventRaised(const std::vector<int>& host_ids,
-                                       const GURL& url,
-                                       int num_total,
-                                       int num_complete) override {
+    void OnProgressEventRaised(const std::vector<int>& host_ids,
+                               const GURL& url,
+                               int num_total,
+                               int num_complete) override {
       last_event_id_ = APPCACHE_PROGRESS_EVENT;
     }
 
-    virtual void OnLogMessage(int host_id,
-                              AppCacheLogLevel log_level,
-                              const std::string& message) override {
-    }
+    void OnLogMessage(int host_id,
+                      AppCacheLogLevel log_level,
+                      const std::string& message) override {}
 
-    virtual void OnContentBlocked(int host_id,
-                                  const GURL& manifest_url) override {
+    void OnContentBlocked(int host_id, const GURL& manifest_url) override {
       content_blocked_ = true;
     }
 
     int last_host_id_;
     int64 last_cache_id_;
     AppCacheStatus last_status_;
     AppCacheStatus last_status_changed_;
     AppCacheEventID last_event_id_;
     bool content_blocked_;
   };
 
   class MockQuotaManagerProxy : public storage::QuotaManagerProxy {
    public:
     MockQuotaManagerProxy() : QuotaManagerProxy(NULL, NULL) {}
 
     // Not needed for our tests.
-    virtual void RegisterClient(storage::QuotaClient* client) override {}
-    virtual void NotifyStorageAccessed(storage::QuotaClient::ID client_id,
-                                       const GURL& origin,
-                                       storage::StorageType type) override {}
-    virtual void NotifyStorageModified(storage::QuotaClient::ID client_id,
-                                       const GURL& origin,
-                                       storage::StorageType type,
-                                       int64 delta) override {}
-    virtual void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
-                                      const GURL& origin,
-                                      storage::StorageType type,
-                                      bool enabled) override {}
-    virtual void GetUsageAndQuota(
-        base::SequencedTaskRunner* original_task_runner,
-        const GURL& origin,
-        storage::StorageType type,
-        const GetUsageAndQuotaCallback& callback) override {}
+    void RegisterClient(storage::QuotaClient* client) override {}
+    void NotifyStorageAccessed(storage::QuotaClient::ID client_id,
+                               const GURL& origin,
+                               storage::StorageType type) override {}
+    void NotifyStorageModified(storage::QuotaClient::ID client_id,
+                               const GURL& origin,
+                               storage::StorageType type,
+                               int64 delta) override {}
+    void SetUsageCacheEnabled(storage::QuotaClient::ID client_id,
+                              const GURL& origin,
+                              storage::StorageType type,
+                              bool enabled) override {}
+    void GetUsageAndQuota(base::SequencedTaskRunner* original_task_runner,
+                          const GURL& origin,
+                          storage::StorageType type,
+                          const GetUsageAndQuotaCallback& callback) override {}
 
-    virtual void NotifyOriginInUse(const GURL& origin) override {
-      inuse_[origin] += 1;
-    }
+    void NotifyOriginInUse(const GURL& origin) override { inuse_[origin] += 1; }
 
-    virtual void NotifyOriginNoLongerInUse(const GURL& origin) override {
+    void NotifyOriginNoLongerInUse(const GURL& origin) override {
       inuse_[origin] -= 1;
     }
 
     int GetInUseCount(const GURL& origin) {
       return inuse_[origin];
     }
 
     void reset() {
       inuse_.clear();
     }
 
     // Map from origin to count of inuse notifications.
     std::map<GURL, int> inuse_;
 
    protected:
-    virtual ~MockQuotaManagerProxy() {}
+    ~MockQuotaManagerProxy() override {}
   };
 
   void GetStatusCallback(AppCacheStatus status, void* param) {
     last_status_result_ = status;
     last_callback_param_ = param;
   }
 
   void StartUpdateCallback(bool result, void* param) {
     last_start_result_ = result;
     last_callback_param_ = param;
@@ skipping 384 matching lines @@
     EXPECT_EQ(&mock_frontend_, host.frontend());
     EXPECT_EQ(NULL, host.associated_cache());
     EXPECT_FALSE(host.is_selection_pending());
     EXPECT_TRUE(host.preferred_manifest_url().is_empty());
   }
   EXPECT_EQ(0, mock_quota_proxy->GetInUseCount(kDocAndOriginUrl));
   service_.set_quota_manager_proxy(NULL);
 }
 
 }  // namespace content