Standardize usage of virtual/override/final in net/

net/cookies/cookie_monster_store_test.h

 // 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.
 
 // This file contains test infrastructure for multiple files
 // (current cookie_monster_unittest.cc and cookie_monster_perftest.cc)
 // that need to test out CookieMonster interactions with the backing store.
 // It should only be included by test code.
 
 #ifndef NET_COOKIES_COOKIE_MONSTER_STORE_TEST_H_
@@ skipping 64 matching lines @@
   MockPersistentCookieStore();
 
   void SetLoadExpectation(
       bool return_value,
       const std::vector<CanonicalCookie*>& result);
 
   const CommandList& commands() const {
     return commands_;
   }
 
-  virtual void Load(const LoadedCallback& loaded_callback) override;
+  void Load(const LoadedCallback& loaded_callback) override;
 
-  virtual void LoadCookiesForKey(const std::string& key,
-    const LoadedCallback& loaded_callback) override;
+  void LoadCookiesForKey(const std::string& key,
+                         const LoadedCallback& loaded_callback) override;
 
-  virtual void AddCookie(const CanonicalCookie& cookie) override;
+  void AddCookie(const CanonicalCookie& cookie) override;
 
-  virtual void UpdateCookieAccessTime(
-      const CanonicalCookie& cookie) override;
+  void UpdateCookieAccessTime(const CanonicalCookie& cookie) override;
 
-  virtual void DeleteCookie(
-      const CanonicalCookie& cookie) override;
+  void DeleteCookie(const CanonicalCookie& cookie) override;
 
-  virtual void Flush(const base::Closure& callback) override;
+  void Flush(const base::Closure& callback) override;
 
-  virtual void SetForceKeepSessionState() override;
+  void SetForceKeepSessionState() override;
 
  protected:
-  virtual ~MockPersistentCookieStore();
+  ~MockPersistentCookieStore() override;
 
  private:
   CommandList commands_;
 
   // Deferred result to use when Load() is called.
   bool load_return_value_;
   std::vector<CanonicalCookie*> load_result_;
   // Indicates if the store has been fully loaded to avoid returning duplicate
   // cookies.
   bool loaded_;
 
   DISALLOW_COPY_AND_ASSIGN(MockPersistentCookieStore);
 };
 
 // Mock for CookieMonsterDelegate
 class MockCookieMonsterDelegate : public CookieMonsterDelegate {
  public:
   typedef std::pair<CanonicalCookie, bool>
       CookieNotification;
 
   MockCookieMonsterDelegate();
 
   const std::vector<CookieNotification>& changes() const { return changes_; }
 
   void reset() { changes_.clear(); }
 
-  virtual void OnCookieChanged(
-      const CanonicalCookie& cookie,
-      bool removed,
-      CookieMonsterDelegate::ChangeCause cause) override;
+  void OnCookieChanged(const CanonicalCookie& cookie,
+                       bool removed,
+                       CookieMonsterDelegate::ChangeCause cause) override;
 
-  virtual void OnLoaded() override;
+  void OnLoaded() override;
 
  private:
-  virtual ~MockCookieMonsterDelegate();
+  ~MockCookieMonsterDelegate() override;
 
   std::vector<CookieNotification> changes_;
 
   DISALLOW_COPY_AND_ASSIGN(MockCookieMonsterDelegate);
 };
 
 // Helper to build a single CanonicalCookie.
 CanonicalCookie BuildCanonicalCookie(const std::string& key,
                                      const std::string& cookie_line,
                                      const base::Time& creation_time);
 
 // Helper to build a list of CanonicalCookie*s.
 void AddCookieToList(
     const std::string& key,
     const std::string& cookie_line,
     const base::Time& creation_time,
     std::vector<CanonicalCookie*>* out_list);
 
 // Just act like a backing database.  Keep cookie information from
 // Add/Update/Delete and regurgitate it when Load is called.
 class MockSimplePersistentCookieStore
     : public CookieMonster::PersistentCookieStore {
  public:
   MockSimplePersistentCookieStore();
 
-  virtual void Load(const LoadedCallback& loaded_callback) override;
+  void Load(const LoadedCallback& loaded_callback) override;
 
-  virtual void LoadCookiesForKey(const std::string& key,
-      const LoadedCallback& loaded_callback) override;
+  void LoadCookiesForKey(const std::string& key,
+                         const LoadedCallback& loaded_callback) override;
 
-  virtual void AddCookie(const CanonicalCookie& cookie) override;
+  void AddCookie(const CanonicalCookie& cookie) override;
 
-  virtual void UpdateCookieAccessTime(const CanonicalCookie& cookie) override;
+  void UpdateCookieAccessTime(const CanonicalCookie& cookie) override;
 
-  virtual void DeleteCookie(const CanonicalCookie& cookie) override;
+  void DeleteCookie(const CanonicalCookie& cookie) override;
 
-  virtual void Flush(const base::Closure& callback) override;
+  void Flush(const base::Closure& callback) override;
 
-  virtual void SetForceKeepSessionState() override;
+  void SetForceKeepSessionState() override;
 
  protected:
-  virtual ~MockSimplePersistentCookieStore();
+  ~MockSimplePersistentCookieStore() override;
 
  private:
   typedef std::map<int64, CanonicalCookie> CanonicalCookieMap;
 
   CanonicalCookieMap cookies_;
 
   // Indicates if the store has been fully loaded to avoid return duplicate
   // cookies in subsequent load requests
   bool loaded_;
 };
 
 // Helper function for creating a CookieMonster backed by a
 // MockSimplePersistentCookieStore for garbage collection testing.
 //
 // Fill the store through import with |num_cookies| cookies, |num_old_cookies|
 // with access time Now()-days_old, the rest with access time Now().
 // Do two SetCookies().  Return whether each of the two SetCookies() took
 // longer than |gc_perf_micros| to complete, and how many cookie were
 // left in the store afterwards.
 CookieMonster* CreateMonsterFromStoreForGC(
     int num_cookies,
     int num_old_cookies,
     int days_old);
 
 }  // namespace net
 
 #endif  // NET_COOKIES_COOKIE_MONSTER_STORE_TEST_H_