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

chrome/browser/browsing_data/cookies_tree_model.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.
 
 #ifndef CHROME_BROWSER_BROWSING_DATA_COOKIES_TREE_MODEL_H_
 #define CHROME_BROWSER_BROWSING_DATA_COOKIES_TREE_MODEL_H_
 
 // TODO(viettrungluu): This header file #includes far too much and has too much
 // inline code (which shouldn't be inline).
 
@@ skipping 130 matching lines @@
     const BrowsingDataFileSystemHelper::FileSystemInfo* file_system_info;
     const BrowsingDataQuotaHelper::QuotaInfo* quota_info;
     const net::ChannelIDStore::ChannelID* channel_id;
     const content::ServiceWorkerUsageInfo* service_worker_info;
     std::string flash_lso_domain;
   };
 
   CookieTreeNode() {}
   explicit CookieTreeNode(const base::string16& title)
       : ui::TreeNode<CookieTreeNode>(title) {}
-  virtual ~CookieTreeNode() {}
+  ~CookieTreeNode() override {}
 
   // Delete backend storage for this node, and any children nodes. (E.g. delete
   // the cookie from CookieMonster, clear the database, and so forth.)
   virtual void DeleteStoredObjects();
 
   // Gets a pointer back to the associated model for the tree we are in.
   virtual CookiesTreeModel* GetModel() const;
 
   // Returns a struct with detailed information used to populate the details
   // part of the view.
   virtual DetailedInfo GetDetailedInfo() const = 0;
 
  protected:
   void AddChildSortedByTitle(CookieTreeNode* new_child);
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeNode);
 };
 
 // CookieTreeRootNode ---------------------------------------------------------
 // The node at the root of the CookieTree that gets inserted into the view.
 class CookieTreeRootNode : public CookieTreeNode {
  public:
   explicit CookieTreeRootNode(CookiesTreeModel* model);
-  virtual ~CookieTreeRootNode();
+  ~CookieTreeRootNode() override;
 
   CookieTreeHostNode* GetOrCreateHostNode(const GURL& url);
 
   // CookieTreeNode methods:
-  virtual CookiesTreeModel* GetModel() const override;
-  virtual DetailedInfo GetDetailedInfo() const override;
+  CookiesTreeModel* GetModel() const override;
+  DetailedInfo GetDetailedInfo() const override;
 
  private:
   CookiesTreeModel* model_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeRootNode);
 };
 
 // CookieTreeHostNode -------------------------------------------------------
 class CookieTreeHostNode : public CookieTreeNode {
  public:
   // Returns the host node's title to use for a given URL.
   static base::string16 TitleForUrl(const GURL& url);
 
   explicit CookieTreeHostNode(const GURL& url);
-  virtual ~CookieTreeHostNode();
+  ~CookieTreeHostNode() override;
 
   // CookieTreeNode methods:
-  virtual DetailedInfo GetDetailedInfo() const override;
+  DetailedInfo GetDetailedInfo() const override;
 
   // CookieTreeHostNode methods:
   CookieTreeCookiesNode* GetOrCreateCookiesNode();
   CookieTreeDatabasesNode* GetOrCreateDatabasesNode();
   CookieTreeLocalStoragesNode* GetOrCreateLocalStoragesNode();
   CookieTreeSessionStoragesNode* GetOrCreateSessionStoragesNode();
   CookieTreeAppCachesNode* GetOrCreateAppCachesNode();
   CookieTreeIndexedDBsNode* GetOrCreateIndexedDBsNode();
   CookieTreeFileSystemsNode* GetOrCreateFileSystemsNode();
   CookieTreeChannelIDsNode* GetOrCreateChannelIDsNode();
@@ skipping 42 matching lines @@
 
 // CookieTreeCookieNode ------------------------------------------------------
 class CookieTreeCookieNode : public CookieTreeNode {
  public:
   friend class CookieTreeCookiesNode;
 
   // The cookie should remain valid at least as long as the
   // CookieTreeCookieNode is valid.
   explicit CookieTreeCookieNode(
       std::list<net::CanonicalCookie>::iterator cookie);
-  virtual ~CookieTreeCookieNode();
+  ~CookieTreeCookieNode() override;
 
   // CookieTreeNode methods:
-  virtual void DeleteStoredObjects() override;
-  virtual DetailedInfo GetDetailedInfo() const override;
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
 
  private:
   // cookie_ is expected to remain valid as long as the CookieTreeCookieNode is
   // valid.
   std::list<net::CanonicalCookie>::iterator cookie_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeCookieNode);
 };
 
 class CookieTreeCookiesNode : public CookieTreeNode {
  public:
   CookieTreeCookiesNode();
-  virtual ~CookieTreeCookiesNode();
+  ~CookieTreeCookiesNode() override;
 
-  virtual DetailedInfo GetDetailedInfo() const override;
+  DetailedInfo GetDetailedInfo() const override;
 
   void AddCookieNode(CookieTreeCookieNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeCookiesNode);
 };
 
 // CookieTreeAppCacheNode -----------------------------------------------------
 class CookieTreeAppCacheNode : public CookieTreeNode {
  public:
   friend class CookieTreeAppCachesNode;
 
   // appcache_info should remain valid at least as long as the
   // CookieTreeAppCacheNode is valid.
   explicit CookieTreeAppCacheNode(
       const GURL& origin_url,
       std::list<content::AppCacheInfo>::iterator appcache_info);
-  virtual ~CookieTreeAppCacheNode();
+  ~CookieTreeAppCacheNode() override;
 
-  virtual void DeleteStoredObjects() override;
-  virtual DetailedInfo GetDetailedInfo() const override;
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
 
  private:
   GURL origin_url_;
   std::list<content::AppCacheInfo>::iterator appcache_info_;
   DISALLOW_COPY_AND_ASSIGN(CookieTreeAppCacheNode);
 };
 
 class CookieTreeAppCachesNode : public CookieTreeNode {
  public:
   CookieTreeAppCachesNode();
-  virtual ~CookieTreeAppCachesNode();
+  ~CookieTreeAppCachesNode() override;
 
-  virtual DetailedInfo GetDetailedInfo() const override;
+  DetailedInfo GetDetailedInfo() const override;
 
   void AddAppCacheNode(CookieTreeAppCacheNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeAppCachesNode);
 };
 
 // CookieTreeDatabaseNode -----------------------------------------------------
 class CookieTreeDatabaseNode : public CookieTreeNode {
  public:
   friend class CookieTreeDatabasesNode;
 
   // database_info should remain valid at least as long as the
   // CookieTreeDatabaseNode is valid.
   explicit CookieTreeDatabaseNode(
       std::list<BrowsingDataDatabaseHelper::DatabaseInfo>::iterator
           database_info);
-  virtual ~CookieTreeDatabaseNode();
+  ~CookieTreeDatabaseNode() override;
 
-  virtual void DeleteStoredObjects() override;
-  virtual DetailedInfo GetDetailedInfo() const override;
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
 
  private:
   // database_info_ is expected to remain valid as long as the
   // CookieTreeDatabaseNode is valid.
   std::list<BrowsingDataDatabaseHelper::DatabaseInfo>::iterator
       database_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeDatabaseNode);
 };
 
 class CookieTreeDatabasesNode : public CookieTreeNode {
  public:
   CookieTreeDatabasesNode();
-  virtual ~CookieTreeDatabasesNode();
+  ~CookieTreeDatabasesNode() override;
 
-  virtual DetailedInfo GetDetailedInfo() const override;
+  DetailedInfo GetDetailedInfo() const override;
 
   void AddDatabaseNode(CookieTreeDatabaseNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeDatabasesNode);
 };
 
 // CookieTreeFileSystemNode --------------------------------------------------
 class CookieTreeFileSystemNode : public CookieTreeNode {
  public:
   friend class CookieTreeFileSystemsNode;
 
   // file_system_info should remain valid at least as long as the
   // CookieTreeFileSystemNode is valid.
   explicit CookieTreeFileSystemNode(
       std::list<BrowsingDataFileSystemHelper::FileSystemInfo>::iterator
           file_system_info);
-  virtual ~CookieTreeFileSystemNode();
+  ~CookieTreeFileSystemNode() override;
 
-  virtual void DeleteStoredObjects() override;
-  virtual DetailedInfo GetDetailedInfo() const override;
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
 
  private:
   // file_system_info_ expected to remain valid as long as the
   // CookieTreeFileSystemNode is valid.
   std::list<BrowsingDataFileSystemHelper::FileSystemInfo>::iterator
       file_system_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeFileSystemNode);
 };
 
 class CookieTreeFileSystemsNode : public CookieTreeNode {
  public:
   CookieTreeFileSystemsNode();
-  virtual ~CookieTreeFileSystemsNode();
+  ~CookieTreeFileSystemsNode() override;
 
-  virtual DetailedInfo GetDetailedInfo() const override;
+  DetailedInfo GetDetailedInfo() const override;
 
   void AddFileSystemNode(CookieTreeFileSystemNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeFileSystemsNode);
 };
 
 // CookieTreeLocalStorageNode -------------------------------------------------
 class CookieTreeLocalStorageNode : public CookieTreeNode {
  public:
   // local_storage_info should remain valid at least as long as the
   // CookieTreeLocalStorageNode is valid.
   explicit CookieTreeLocalStorageNode(
       std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator
           local_storage_info);
-  virtual ~CookieTreeLocalStorageNode();
+  ~CookieTreeLocalStorageNode() override;
 
   // CookieTreeNode methods:
-  virtual void DeleteStoredObjects() override;
-  virtual DetailedInfo GetDetailedInfo() const override;
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
 
  private:
   // local_storage_info_ is expected to remain valid as long as the
   // CookieTreeLocalStorageNode is valid.
   std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator
       local_storage_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeLocalStorageNode);
 };
 
 class CookieTreeLocalStoragesNode : public CookieTreeNode {
  public:
   CookieTreeLocalStoragesNode();
-  virtual ~CookieTreeLocalStoragesNode();
+  ~CookieTreeLocalStoragesNode() override;
 
-  virtual DetailedInfo GetDetailedInfo() const override;
+  DetailedInfo GetDetailedInfo() const override;
 
   void AddLocalStorageNode(CookieTreeLocalStorageNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeLocalStoragesNode);
 };
 
 
 // CookieTreeSessionStorageNode -----------------------------------------------
 class CookieTreeSessionStorageNode : public CookieTreeNode {
  public:
   // session_storage_info should remain valid at least as long as the
   // CookieTreeSessionStorageNode is valid.
   explicit CookieTreeSessionStorageNode(
       std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator
           session_storage_info);
-  virtual ~CookieTreeSessionStorageNode();
+  ~CookieTreeSessionStorageNode() override;
 
   // CookieTreeNode methods:
-  virtual void DeleteStoredObjects() override;
-  virtual DetailedInfo GetDetailedInfo() const override;
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
 
  private:
   // session_storage_info_ is expected to remain valid as long as the
   // CookieTreeSessionStorageNode is valid.
   std::list<BrowsingDataLocalStorageHelper::LocalStorageInfo>::iterator
       session_storage_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeSessionStorageNode);
 };
 
 class CookieTreeSessionStoragesNode : public CookieTreeNode {
  public:
   CookieTreeSessionStoragesNode();
-  virtual ~CookieTreeSessionStoragesNode();
+  ~CookieTreeSessionStoragesNode() override;
 
-  virtual DetailedInfo GetDetailedInfo() const override;
+  DetailedInfo GetDetailedInfo() const override;
 
   void AddSessionStorageNode(CookieTreeSessionStorageNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeSessionStoragesNode);
 };
 
 // CookieTreeIndexedDBNode -----------------------------------------------
 class CookieTreeIndexedDBNode : public CookieTreeNode {
  public:
   // indexed_db_info should remain valid at least as long as the
   // CookieTreeIndexedDBNode is valid.
   explicit CookieTreeIndexedDBNode(
       std::list<content::IndexedDBInfo>::iterator
           indexed_db_info);
-  virtual ~CookieTreeIndexedDBNode();
+  ~CookieTreeIndexedDBNode() override;
 
   // CookieTreeNode methods:
-  virtual void DeleteStoredObjects() override;
-  virtual DetailedInfo GetDetailedInfo() const override;
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
 
  private:
   // indexed_db_info_ is expected to remain valid as long as the
   // CookieTreeIndexedDBNode is valid.
   std::list<content::IndexedDBInfo>::iterator
       indexed_db_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeIndexedDBNode);
 };
 
 class CookieTreeIndexedDBsNode : public CookieTreeNode {
  public:
   CookieTreeIndexedDBsNode();
-  virtual ~CookieTreeIndexedDBsNode();
+  ~CookieTreeIndexedDBsNode() override;
 
-  virtual DetailedInfo GetDetailedInfo() const override;
+  DetailedInfo GetDetailedInfo() const override;
 
   void AddIndexedDBNode(CookieTreeIndexedDBNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeIndexedDBsNode);
 };
 
 // CookieTreeQuotaNode --------------------------------------------------
 class CookieTreeQuotaNode : public CookieTreeNode {
  public:
   // quota_info should remain valid at least as long as the CookieTreeQuotaNode
   // is valid.
   explicit CookieTreeQuotaNode(
       std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info);
-  virtual ~CookieTreeQuotaNode();
+  ~CookieTreeQuotaNode() override;
 
-  virtual void DeleteStoredObjects() override;
-  virtual DetailedInfo GetDetailedInfo() const override;
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
 
  private:
   // quota_info_ is expected to remain valid as long as the CookieTreeQuotaNode
   // is valid.
   std::list<BrowsingDataQuotaHelper::QuotaInfo>::iterator quota_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeQuotaNode);
 };
 
 // CookieTreeChannelIDNode ---------------------------------------------
 class CookieTreeChannelIDNode : public CookieTreeNode {
  public:
   friend class CookieTreeChannelIDsNode;
 
   // The iterator should remain valid at least as long as the
   // CookieTreeChannelIDNode is valid.
   explicit CookieTreeChannelIDNode(
       net::ChannelIDStore::ChannelIDList::iterator cert);
-  virtual ~CookieTreeChannelIDNode();
+  ~CookieTreeChannelIDNode() override;
 
   // CookieTreeNode methods:
-  virtual void DeleteStoredObjects() override;
-  virtual DetailedInfo GetDetailedInfo() const override;
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
 
  private:
   // channel_id_ is expected to remain valid as long as the
   // CookieTreeChannelIDNode is valid.
   net::ChannelIDStore::ChannelIDList::iterator channel_id_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeChannelIDNode);
 };
 
 class CookieTreeChannelIDsNode : public CookieTreeNode {
  public:
   CookieTreeChannelIDsNode();
-  virtual ~CookieTreeChannelIDsNode();
+  ~CookieTreeChannelIDsNode() override;
 
-  virtual DetailedInfo GetDetailedInfo() const override;
+  DetailedInfo GetDetailedInfo() const override;
 
   void AddChannelIDNode(CookieTreeChannelIDNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeChannelIDsNode);
 };
 
 // CookieTreeServiceWorkerNode -----------------------------------------------
 class CookieTreeServiceWorkerNode : public CookieTreeNode {
  public:
   // service_worker_info should remain valid at least as long as the
   // CookieTreeServiceWorkerNode is valid.
   explicit CookieTreeServiceWorkerNode(
       std::list<content::ServiceWorkerUsageInfo>::iterator service_worker_info);
-  virtual ~CookieTreeServiceWorkerNode();
+  ~CookieTreeServiceWorkerNode() override;
 
   // CookieTreeNode methods:
-  virtual void DeleteStoredObjects() override;
-  virtual DetailedInfo GetDetailedInfo() const override;
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
 
  private:
   // service_worker_info_ is expected to remain valid as long as the
   // CookieTreeServiceWorkerNode is valid.
   std::list<content::ServiceWorkerUsageInfo>::iterator service_worker_info_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeServiceWorkerNode);
 };
 
 class CookieTreeServiceWorkersNode : public CookieTreeNode {
  public:
   CookieTreeServiceWorkersNode();
-  virtual ~CookieTreeServiceWorkersNode();
+  ~CookieTreeServiceWorkersNode() override;
 
-  virtual DetailedInfo GetDetailedInfo() const override;
+  DetailedInfo GetDetailedInfo() const override;
 
   void AddServiceWorkerNode(CookieTreeServiceWorkerNode* child) {
     AddChildSortedByTitle(child);
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CookieTreeServiceWorkersNode);
 };
 
 // CookieTreeFlashLSONode ----------------------------------------------------
 class CookieTreeFlashLSONode : public CookieTreeNode {
  public:
   explicit CookieTreeFlashLSONode(const std::string& domain);
-  virtual ~CookieTreeFlashLSONode();
+  ~CookieTreeFlashLSONode() override;
 
   // CookieTreeNode methods:
-  virtual void DeleteStoredObjects() override;
-  virtual DetailedInfo GetDetailedInfo() const override;
+  void DeleteStoredObjects() override;
+  DetailedInfo GetDetailedInfo() const override;
 
  private:
   std::string domain_;
 
   DISALLOW_COPY_AND_ASSIGN(CookieTreeFlashLSONode);
 };
 
 // CookiesTreeModel -----------------------------------------------------------
 class CookiesTreeModel : public ui::TreeNodeModel<CookieTreeNode> {
  public:
   CookiesTreeModel(LocalDataContainer* data_container,
                    ExtensionSpecialStoragePolicy* special_storage_policy,
                    bool group_by_cookie_source);
-  virtual ~CookiesTreeModel();
+  ~CookiesTreeModel() override;
 
   // Because non-cookie nodes are fetched in a background thread, they are not
   // present at the time the Model is created. The Model then notifies its
   // observers for every item added from databases, local storage, and
   // appcache. We extend the Observer interface to add notifications before and
   // after these batch inserts.
   class Observer : public ui::TreeModelObserver {
    public:
     virtual void TreeModelBeginBatch(CookiesTreeModel* model) {}
     virtual void TreeModelEndBatch(CookiesTreeModel* model) {}
@@ skipping 12 matching lines @@
 
    private:
     CookiesTreeModel* model_;
     CookieTreeNode* node_;
     bool batch_in_progress_;
   };
 
   // ui::TreeModel methods:
   // Returns the set of icons for the nodes in the tree. You only need override
   // this if you don't want to use the default folder icons.
-  virtual void GetIcons(std::vector<gfx::ImageSkia>* icons) override;
+  void GetIcons(std::vector<gfx::ImageSkia>* icons) override;
 
   // Returns the index of the icon to use for |node|. Return -1 to use the
   // default icon. The index is relative to the list of icons returned from
   // GetIcons.
-  virtual int GetIconIndex(ui::TreeModelNode* node) override;
+  int GetIconIndex(ui::TreeModelNode* node) override;
 
   // CookiesTreeModel methods:
   void DeleteAllStoredObjects();
 
   // Deletes a specific node in the tree, identified by |cookie_node|, and its
   // subtree.
   void DeleteCookieNode(CookieTreeNode* cookie_node);
 
   // Filter the origins to only display matched results.
   void UpdateSearchResults(const base::string16& filter);
@@ skipping 96 matching lines @@
   // Otherwise, use the CanonicalCookie::Domain attribute.
   bool group_by_cookie_source_;
 
   // If this is non-zero, then this model is batching updates (there's a lot of
   // notifications coming down the pipe). This is an integer is used to balance
   // calls to Begin/EndBatch() if they're called in a nested manner.
   int batch_update_;
 };
 
 #endif  // CHROME_BROWSER_BROWSING_DATA_COOKIES_TREE_MODEL_H_