Standardize usage of virtual/override/final in net/

net/cookies/cookie_monster_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 "net/cookies/cookie_store_unittest.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 2147 matching lines @@
   ASSERT_TRUE(cookie_list[0].IsExpired(Time::Now()));
 }
 
 namespace {
 
 // Mock PersistentCookieStore that keeps track of the number of Flush() calls.
 class FlushablePersistentStore : public CookieMonster::PersistentCookieStore {
  public:
   FlushablePersistentStore() : flush_count_(0) {}
 
-  virtual void Load(const LoadedCallback& loaded_callback) override {
+  void Load(const LoadedCallback& loaded_callback) override {
     std::vector<CanonicalCookie*> out_cookies;
     base::MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(&net::LoadedCallbackTask::Run,
                    new net::LoadedCallbackTask(loaded_callback, out_cookies)));
   }
 
-  virtual void LoadCookiesForKey(
-      const std::string& key,
-      const LoadedCallback& loaded_callback) override {
+  void LoadCookiesForKey(const std::string& key,
+                         const LoadedCallback& loaded_callback) override {
     Load(loaded_callback);
   }
 
-  virtual void AddCookie(const CanonicalCookie&) override {}
-  virtual void UpdateCookieAccessTime(const CanonicalCookie&) override {}
-  virtual void DeleteCookie(const CanonicalCookie&) override {}
-  virtual void SetForceKeepSessionState() override {}
+  void AddCookie(const CanonicalCookie&) override {}
+  void UpdateCookieAccessTime(const CanonicalCookie&) override {}
+  void DeleteCookie(const CanonicalCookie&) override {}
+  void SetForceKeepSessionState() override {}
 
-  virtual void Flush(const base::Closure& callback) override {
+  void Flush(const base::Closure& callback) override {
     ++flush_count_;
     if (!callback.is_null())
       callback.Run();
   }
 
   int flush_count() {
     return flush_count_;
   }
 
  private:
-  virtual ~FlushablePersistentStore() {}
+  ~FlushablePersistentStore() override {}
 
   volatile int flush_count_;
 };
 
 // Counts the number of times Callback() has been run.
 class CallbackCounter : public base::RefCountedThreadSafe<CallbackCounter> {
  public:
   CallbackCounter() : callback_count_(0) {}
 
   void Callback() {
@@ skipping 523 matching lines @@
 
   // Inject our initial cookies into the mock PersistentCookieStore.
   store->SetLoadExpectation(true, initial_cookies);
 
   scoped_refptr<CookieMonster> cm(new CookieMonster(store.get(), NULL));
 
   EXPECT_EQ("foo=bar; hello=world", GetCookies(cm.get(), url));
 }
 
 }  // namespace net