Standardize usage of virtual/override/final in chrome/browser/browsing_data/

chrome/browser/browsing_data/browsing_data_remover_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/browsing_data/browsing_data_remover.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 115 matching lines @@
   base::Time remove_end;
   StoragePartition::OriginMatcherFunction origin_matcher;
 
   StoragePartitionRemovalData() : remove_mask(0),
                                   quota_storage_remove_mask(0) {}
 };
 
 class TestStoragePartition : public StoragePartition {
  public:
   TestStoragePartition() {}
-  virtual ~TestStoragePartition() {}
+  ~TestStoragePartition() override {}
 
   // content::StoragePartition implementation.
-  virtual base::FilePath GetPath() override { return base::FilePath(); }
-  virtual net::URLRequestContextGetter* GetURLRequestContext() override {
+  base::FilePath GetPath() override { return base::FilePath(); }
+  net::URLRequestContextGetter* GetURLRequestContext() override { return NULL; }
+  net::URLRequestContextGetter* GetMediaURLRequestContext() override {
     return NULL;
   }
-  virtual net::URLRequestContextGetter* GetMediaURLRequestContext() override {
-    return NULL;
-  }
-  virtual storage::QuotaManager* GetQuotaManager() override { return NULL; }
-  virtual content::AppCacheService* GetAppCacheService() override {
-    return NULL;
-  }
-  virtual storage::FileSystemContext* GetFileSystemContext() override {
-    return NULL;
-  }
-  virtual storage::DatabaseTracker* GetDatabaseTracker() override {
-    return NULL;
-  }
-  virtual content::DOMStorageContext* GetDOMStorageContext() override {
-    return NULL;
-  }
-  virtual content::IndexedDBContext* GetIndexedDBContext() override {
-    return NULL;
-  }
-  virtual content::ServiceWorkerContext* GetServiceWorkerContext() override {
+  storage::QuotaManager* GetQuotaManager() override { return NULL; }
+  content::AppCacheService* GetAppCacheService() override { return NULL; }
+  storage::FileSystemContext* GetFileSystemContext() override { return NULL; }
+  storage::DatabaseTracker* GetDatabaseTracker() override { return NULL; }
+  content::DOMStorageContext* GetDOMStorageContext() override { return NULL; }
+  content::IndexedDBContext* GetIndexedDBContext() override { return NULL; }
+  content::ServiceWorkerContext* GetServiceWorkerContext() override {
     return NULL;
   }
 
-  virtual void ClearDataForOrigin(uint32 remove_mask,
-                                  uint32 quota_storage_remove_mask,
-                                  const GURL& storage_origin,
-                                  net::URLRequestContextGetter* rq_context,
-                                  const base::Closure& callback) override {
+  void ClearDataForOrigin(uint32 remove_mask,
+                          uint32 quota_storage_remove_mask,
+                          const GURL& storage_origin,
+                          net::URLRequestContextGetter* rq_context,
+                          const base::Closure& callback) override {
     BrowserThread::PostTask(BrowserThread::UI,
                             FROM_HERE,
                             base::Bind(&TestStoragePartition::AsyncRunCallback,
                                        base::Unretained(this),
                                        callback));
   }
 
-  virtual void ClearData(uint32 remove_mask,
-                         uint32 quota_storage_remove_mask,
-                         const GURL& storage_origin,
-                         const OriginMatcherFunction& origin_matcher,
-                         const base::Time begin,
-                         const base::Time end,
-                         const base::Closure& callback) override {
+  void ClearData(uint32 remove_mask,
+                 uint32 quota_storage_remove_mask,
+                 const GURL& storage_origin,
+                 const OriginMatcherFunction& origin_matcher,
+                 const base::Time begin,
+                 const base::Time end,
+                 const base::Closure& callback) override {
     // Store stuff to verify parameters' correctness later.
     storage_partition_removal_data_.remove_mask = remove_mask;
     storage_partition_removal_data_.quota_storage_remove_mask =
         quota_storage_remove_mask;
     storage_partition_removal_data_.remove_origin = storage_origin;
     storage_partition_removal_data_.remove_begin = begin;
     storage_partition_removal_data_.remove_end = end;
     storage_partition_removal_data_.origin_matcher = origin_matcher;
 
     BrowserThread::PostTask(
@@ skipping 115 matching lines @@
 class RemoveChannelIDTester : public net::SSLConfigService::Observer {
  public:
   explicit RemoveChannelIDTester(TestingProfile* profile)
       : ssl_config_changed_count_(0) {
     channel_id_service_ = profile->GetRequestContext()->
         GetURLRequestContext()->channel_id_service();
     ssl_config_service_ = profile->GetSSLConfigService();
     ssl_config_service_->AddObserver(this);
   }
 
-  virtual ~RemoveChannelIDTester() {
+  ~RemoveChannelIDTester() override {
     ssl_config_service_->RemoveObserver(this);
   }
 
   int ChannelIDCount() {
     return channel_id_service_->cert_count();
   }
 
   // Add a server bound cert for |server| with specific creation and expiry
   // times.  The cert and key data will be filled with dummy values.
   void AddChannelIDWithTimes(const std::string& server_identifier,
@@ skipping 23 matching lines @@
 
   net::ChannelIDStore* GetChannelIDStore() {
     return channel_id_service_->GetChannelIDStore();
   }
 
   int ssl_config_changed_count() const {
     return ssl_config_changed_count_;
   }
 
   // net::SSLConfigService::Observer implementation:
-  virtual void OnSSLConfigChanged() override {
-    ssl_config_changed_count_++;
-  }
+  void OnSSLConfigChanged() override { ssl_config_changed_count_++; }
 
  private:
   static void GetAllChannelIDsCallback(
       net::ChannelIDStore::ChannelIDList* dest,
       const net::ChannelIDStore::ChannelIDList& result) {
     *dest = result;
   }
 
   net::ChannelIDService* channel_id_service_;
   scoped_refptr<net::SSLConfigService> ssl_config_service_;
@@ skipping 57 matching lines @@
 
 class RemoveAutofillTester : public autofill::PersonalDataManagerObserver {
  public:
   explicit RemoveAutofillTester(TestingProfile* profile)
       : personal_data_manager_(
             autofill::PersonalDataManagerFactory::GetForProfile(profile)) {
     autofill::test::DisableSystemServices(profile->GetPrefs());
     personal_data_manager_->AddObserver(this);
   }
 
-  virtual ~RemoveAutofillTester() {
+  ~RemoveAutofillTester() override {
     personal_data_manager_->RemoveObserver(this);
   }
 
   // Returns true if there are autofill profiles.
   bool HasProfile() {
     return !personal_data_manager_->GetProfiles().empty() &&
            !personal_data_manager_->GetCreditCards().empty();
   }
 
   bool HasOrigin(const std::string& origin) {
@@ skipping 50 matching lines @@
 
     card.set_guid(base::GenerateGUID());
     card.set_origin(kChromeOrigin);
     cards.push_back(card);
 
     personal_data_manager_->SetCreditCards(&cards);
     base::MessageLoop::current()->Run();
   }
 
  private:
-  virtual void OnPersonalDataChanged() override {
+  void OnPersonalDataChanged() override {
     base::MessageLoop::current()->Quit();
   }
 
   autofill::PersonalDataManager* personal_data_manager_;
   DISALLOW_COPY_AND_ASSIGN(RemoveAutofillTester);
 };
 
 class RemoveLocalStorageTester {
  public:
   explicit RemoveLocalStorageTester(TestingProfile* profile)
@@ skipping 64 matching lines @@
   std::vector<content::LocalStorageUsageInfo> infos_;
   base::Closure quit_closure_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveLocalStorageTester);
 };
 
 class MockDomainReliabilityService : public DomainReliabilityService {
  public:
   MockDomainReliabilityService() : clear_count_(0) {}
 
-  virtual ~MockDomainReliabilityService() {}
+  ~MockDomainReliabilityService() override {}
 
-  virtual scoped_ptr<DomainReliabilityMonitor> CreateMonitor(
+  scoped_ptr<DomainReliabilityMonitor> CreateMonitor(
       scoped_refptr<base::SingleThreadTaskRunner> network_task_runner)
       override {
     NOTREACHED();
     return scoped_ptr<DomainReliabilityMonitor>();
   }
 
-  virtual void ClearBrowsingData(DomainReliabilityClearMode clear_mode,
-                                 const base::Closure& callback) override {
+  void ClearBrowsingData(DomainReliabilityClearMode clear_mode,
+                         const base::Closure& callback) override {
     clear_count_++;
     last_clear_mode_ = clear_mode;
     callback.Run();
   }
 
-  virtual void GetWebUIData(
-      const base::Callback<void(scoped_ptr<base::Value>)>& callback)
-      const override {
+  void GetWebUIData(const base::Callback<void(scoped_ptr<base::Value>)>&
+                        callback) const override {
     NOTREACHED();
   }
 
   int clear_count() const { return clear_count_; }
 
   DomainReliabilityClearMode last_clear_mode() const {
     return last_clear_mode_;
   }
 
  private:
   unsigned clear_count_;
   DomainReliabilityClearMode last_clear_mode_;
 };
 
 struct TestingDomainReliabilityServiceFactoryUserData
     : public base::SupportsUserData::Data {
   TestingDomainReliabilityServiceFactoryUserData(
       content::BrowserContext* context,
       MockDomainReliabilityService* service)
       : context(context),
         service(service),
         attached(false) {}
-  virtual ~TestingDomainReliabilityServiceFactoryUserData() {}
+  ~TestingDomainReliabilityServiceFactoryUserData() override {}
 
   content::BrowserContext* const context;
   MockDomainReliabilityService* const service;
   bool attached;
 
   static const void* kKey;
 };
 
 // static
 const void* TestingDomainReliabilityServiceFactoryUserData::kKey =
@@ skipping 142 matching lines @@
 
   int GetOriginSetMask() {
     return called_with_details_->origin_set_mask;
   }
 
   StoragePartitionRemovalData GetStoragePartitionRemovalData() {
     return storage_partition_removal_data_;
   }
 
   // content::NotificationObserver implementation.
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) override {
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override {
     DCHECK_EQ(type, chrome::NOTIFICATION_BROWSING_DATA_REMOVED);
 
     // We're not taking ownership of the details object, but storing a copy of
     // it locally.
     called_with_details_.reset(new BrowsingDataRemover::NotificationDetails(
         *content::Details<BrowsingDataRemover::NotificationDetails>(
             details).ptr()));
 
     registrar_.RemoveAll();
   }
@@ skipping 1012 matching lines @@
   EXPECT_EQ(1u, tester.clear_count());
   EXPECT_EQ(CLEAR_CONTEXTS, tester.last_clear_mode());
 }
 
 TEST_F(BrowsingDataRemoverTest, DomainReliability_NoMonitor) {
   BlockUntilBrowsingDataRemoved(
       BrowsingDataRemover::EVERYTHING,
       BrowsingDataRemover::REMOVE_HISTORY |
       BrowsingDataRemover::REMOVE_COOKIES, false);
 }