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

content/browser/quota/usage_tracker_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/run_loop.h"
 #include "content/public/test/mock_special_storage_policy.h"
 #include "net/base/net_util.h"
 #include "storage/browser/quota/usage_tracker.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 27 matching lines @@
   EXPECT_FALSE(*done);
   *done = true;
   *usage_out = usage;
 }
 
 }  // namespace
 
 class MockQuotaClient : public QuotaClient {
  public:
   MockQuotaClient() {}
-  virtual ~MockQuotaClient() {}
+  ~MockQuotaClient() override {}
 
-  virtual ID id() const override {
-    return kFileSystem;
-  }
+  ID id() const override { return kFileSystem; }
 
-  virtual void OnQuotaManagerDestroyed() override {}
+  void OnQuotaManagerDestroyed() override {}
 
-  virtual void GetOriginUsage(const GURL& origin,
-                              StorageType type,
-                              const GetUsageCallback& callback) override {
+  void GetOriginUsage(const GURL& origin,
+                      StorageType type,
+                      const GetUsageCallback& callback) override {
     EXPECT_EQ(kStorageTypeTemporary, type);
     int64 usage = GetUsage(origin);
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::Bind(callback, usage));
   }
 
-  virtual void GetOriginsForType(StorageType type,
-                                 const GetOriginsCallback& callback) override {
+  void GetOriginsForType(StorageType type,
+                         const GetOriginsCallback& callback) override {
     EXPECT_EQ(kStorageTypeTemporary, type);
     std::set<GURL> origins;
     for (UsageMap::const_iterator itr = usage_map_.begin();
          itr != usage_map_.end(); ++itr) {
       origins.insert(itr->first);
     }
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::Bind(callback, origins));
   }
 
-  virtual void GetOriginsForHost(StorageType type,
-                                 const std::string& host,
-                                 const GetOriginsCallback& callback) override {
+  void GetOriginsForHost(StorageType type,
+                         const std::string& host,
+                         const GetOriginsCallback& callback) override {
     EXPECT_EQ(kStorageTypeTemporary, type);
     std::set<GURL> origins;
     for (UsageMap::const_iterator itr = usage_map_.begin();
          itr != usage_map_.end(); ++itr) {
       if (net::GetHostOrSpecFromURL(itr->first) == host)
         origins.insert(itr->first);
     }
     base::MessageLoop::current()->PostTask(FROM_HERE,
                                            base::Bind(callback, origins));
   }
 
-  virtual void DeleteOriginData(const GURL& origin,
-                                StorageType type,
-                                const DeletionCallback& callback) override {
+  void DeleteOriginData(const GURL& origin,
+                        StorageType type,
+                        const DeletionCallback& callback) override {
     EXPECT_EQ(kStorageTypeTemporary, type);
     usage_map_.erase(origin);
     base::MessageLoop::current()->PostTask(
         FROM_HERE, base::Bind(callback, kQuotaStatusOk));
   }
 
-  virtual bool DoesSupport(storage::StorageType type) const override {
+  bool DoesSupport(storage::StorageType type) const override {
     return type == storage::kStorageTypeTemporary;
   }
 
   int64 GetUsage(const GURL& origin) {
     UsageMap::const_iterator found = usage_map_.find(origin);
     if (found == usage_map_.end())
       return 0;
     return found->second;
   }
 
@@ skipping 216 matching lines @@
 
   GetGlobalLimitedUsage(&limited_usage);
   GetGlobalUsage(&total_usage, &unlimited_usage);
   EXPECT_EQ(1 + 16, limited_usage);
   EXPECT_EQ(1 + 2 + 16 + 32, total_usage);
   EXPECT_EQ(2 + 32, unlimited_usage);
 }
 
 
 }  // namespace content