Replacing the OVERRIDE with override and FINAL with final in content/browser/[download|…

content/browser/quota/storage_monitor_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 <vector>
 
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
@@ skipping 33 matching lines @@
   const StorageObserver::Event& LastEvent() const {
     CHECK(!events_.empty());
     return events_.back();
   }
 
   int EventCount() const {
     return events_.size();
   }
 
   // StorageObserver implementation:
-  virtual void OnStorageEvent(const StorageObserver::Event& event) OVERRIDE {
+  virtual void OnStorageEvent(const StorageObserver::Event& event) override {
     events_.push_back(event);
   }
 
  private:
   std::vector<StorageObserver::Event> events_;
 };
 
 // A mock quota manager for overriding GetUsageAndQuotaForWebApps().
 class UsageMockQuotaManager : public QuotaManager {
  public:
@@ skipping 17 matching lines @@
     callback_status_ = status;
   }
 
   void InvokeCallback() {
     delayed_callback_.Run(callback_status_, callback_usage_, callback_quota_);
   }
 
   virtual void GetUsageAndQuotaForWebApps(
       const GURL& origin,
       StorageType type,
-      const GetUsageAndQuotaCallback& callback) OVERRIDE {
+      const GetUsageAndQuotaCallback& callback) override {
     if (initialized_)
       callback.Run(callback_status_, callback_usage_, callback_quota_);
     else
       delayed_callback_ = callback;
   }
 
  protected:
   virtual ~UsageMockQuotaManager() {}
 
  private:
@@ skipping 54 matching lines @@
     SetLastNotificationTime(host_observers.observers_, observer);
   }
 
   int GetObserverCount(const HostStorageObservers& host_observers) {
     return host_observers.observers_.ObserverCount();
   }
 };
 
 class StorageTestWithManagerBase : public StorageMonitorTestBase {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     storage_policy_ = new MockSpecialStoragePolicy();
     quota_manager_ = new UsageMockQuotaManager(storage_policy_.get());
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // This ensures the quota manager is destroyed correctly.
     quota_manager_ = NULL;
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   base::MessageLoop message_loop_;
   scoped_refptr<MockSpecialStoragePolicy> storage_policy_;
   scoped_refptr<UsageMockQuotaManager> quota_manager_;
 };
@@ skipping 373 matching lines @@
                  GURL(kDefaultOrigin),
                  base::TimeDelta::FromHours(1),
                  false),
         params2_(kStorageTypePersistent,
                  GURL(kDefaultOrigin),
                  base::TimeDelta::FromHours(1),
                  false) {
   }
 
  protected:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     StorageTestWithManagerBase::SetUp();
 
     storage_monitor_ = quota_manager_->storage_monitor_.get();
     host_ = net::GetHostOrSpecFromURL(params1_.filter.origin);
 
     storage_monitor_->AddObserver(&mock_observer1_, params1_);
     storage_monitor_->AddObserver(&mock_observer2_, params1_);
 
     storage_monitor_->AddObserver(&mock_observer1_, params2_);
     storage_monitor_->AddObserver(&mock_observer2_, params2_);
@@ skipping 61 matching lines @@
 // Test removing an observer for a specific filter.
 TEST_F(StorageMonitorTest, RemoveObserverForFilter) {
   storage_monitor_->RemoveObserverForFilter(&mock_observer1_, params2_.filter);
   CheckObserverCount(2, 2);
 }
 
 // Integration test for QuotaManager and StorageMonitor:
 
 class StorageMonitorIntegrationTest : public testing::Test {
  public:
-  virtual void SetUp() OVERRIDE {
+  virtual void SetUp() override {
     ASSERT_TRUE(data_dir_.CreateUniqueTempDir());
     storage_policy_ = new MockSpecialStoragePolicy();
     quota_manager_ = new QuotaManager(
         false,
         data_dir_.path(),
         base::MessageLoopProxy::current().get(),
         base::MessageLoopProxy::current().get(),
         storage_policy_.get());
 
     client_ = new MockStorageClient(quota_manager_->proxy(),
                                     NULL,
                                     QuotaClient::kFileSystem,
                                     0);
 
     quota_manager_->proxy()->RegisterClient(client_);
   }
 
-  virtual void TearDown() OVERRIDE {
+  virtual void TearDown() override {
     // This ensures the quota manager is destroyed correctly.
     quota_manager_ = NULL;
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   base::MessageLoop message_loop_;
   base::ScopedTempDir data_dir_;
   scoped_refptr<MockSpecialStoragePolicy> storage_policy_;
   scoped_refptr<QuotaManager> quota_manager_;
@@ skipping 21 matching lines @@
   base::RunLoop().RunUntilIdle();
 
   // Verify that the observer receives it.
   ASSERT_EQ(1, mock_observer.EventCount());
   const StorageObserver::Event& event = mock_observer.LastEvent();
   EXPECT_EQ(params.filter, event.filter);
   EXPECT_EQ(kTestUsage, event.usage);
 }
 
 }  // namespace content