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

chrome/browser/sync/test/integration/bookmarks_helper.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/sync/test/integration/bookmarks_helper.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_util.h"
 #include "base/path_service.h"
@@ skipping 31 matching lines @@
 #include "ui/gfx/image/image_skia.h"
 
 namespace {
 
 // History task which runs all pending tasks on the history thread and
 // signals when the tasks have completed.
 class HistoryEmptyTask : public history::HistoryDBTask {
  public:
   explicit HistoryEmptyTask(base::WaitableEvent* done) : done_(done) {}
 
-  virtual bool RunOnDBThread(history::HistoryBackend* backend,
-                             history::HistoryDatabase* db) override {
+  bool RunOnDBThread(history::HistoryBackend* backend,
+                     history::HistoryDatabase* db) override {
     content::RunAllPendingInMessageLoop();
     done_->Signal();
     return true;
   }
 
-  virtual void DoneRunOnMainThread() override {}
+  void DoneRunOnMainThread() override {}
 
  private:
-  virtual ~HistoryEmptyTask() {}
+  ~HistoryEmptyTask() override {}
 
   base::WaitableEvent* done_;
 };
 
 // Helper class used to wait for changes to take effect on the favicon of a
 // particular bookmark node in a particular bookmark model.
 class FaviconChangeObserver : public BookmarkModelObserver {
  public:
   FaviconChangeObserver(BookmarkModel* model, const BookmarkNode* node)
       : model_(model),
         node_(node),
         wait_for_load_(false) {
     model->AddObserver(this);
   }
-  virtual ~FaviconChangeObserver() {
-    model_->RemoveObserver(this);
-  }
+  ~FaviconChangeObserver() override { model_->RemoveObserver(this); }
   void WaitForGetFavicon() {
     wait_for_load_ = true;
     content::RunMessageLoop();
     ASSERT_TRUE(node_->is_favicon_loaded());
     ASSERT_FALSE(model_->GetFavicon(node_).IsEmpty());
   }
   void WaitForSetFavicon() {
     wait_for_load_ = false;
     content::RunMessageLoop();
   }
-  virtual void BookmarkModelLoaded(BookmarkModel* model,
-                                   bool ids_reassigned) override {}
-  virtual void BookmarkNodeMoved(BookmarkModel* model,
-                                 const BookmarkNode* old_parent,
-                                 int old_index,
-                                 const BookmarkNode* new_parent,
-                                 int new_index) override {}
-  virtual void BookmarkNodeAdded(BookmarkModel* model,
-                                 const BookmarkNode* parent,
-                                 int index) override {}
-  virtual void BookmarkNodeRemoved(
-      BookmarkModel* model,
-      const BookmarkNode* parent,
-      int old_index,
-      const BookmarkNode* node,
-      const std::set<GURL>& removed_urls) override {}
-  virtual void BookmarkAllUserNodesRemoved(
+  void BookmarkModelLoaded(BookmarkModel* model, bool ids_reassigned) override {
+  }
+  void BookmarkNodeMoved(BookmarkModel* model,
+                         const BookmarkNode* old_parent,
+                         int old_index,
+                         const BookmarkNode* new_parent,
+                         int new_index) override {}
+  void BookmarkNodeAdded(BookmarkModel* model,
+                         const BookmarkNode* parent,
+                         int index) override {}
+  void BookmarkNodeRemoved(BookmarkModel* model,
+                           const BookmarkNode* parent,
+                           int old_index,
+                           const BookmarkNode* node,
+                           const std::set<GURL>& removed_urls) override {}
+  void BookmarkAllUserNodesRemoved(
       BookmarkModel* model,
       const std::set<GURL>& removed_urls) override {}
 
-  virtual void BookmarkNodeChanged(BookmarkModel* model,
-                                   const BookmarkNode* node) override {
+  void BookmarkNodeChanged(BookmarkModel* model,
+                           const BookmarkNode* node) override {
     if (model == model_ && node == node_)
       model->GetFavicon(node);
   }
-  virtual void BookmarkNodeChildrenReordered(
-      BookmarkModel* model,
-      const BookmarkNode* node) override {}
-  virtual void BookmarkNodeFaviconChanged(
-      BookmarkModel* model,
-      const BookmarkNode* node) override {
+  void BookmarkNodeChildrenReordered(BookmarkModel* model,
+                                     const BookmarkNode* node) override {}
+  void BookmarkNodeFaviconChanged(BookmarkModel* model,
+                                  const BookmarkNode* node) override {
     if (model == model_ && node == node_) {
       if (!wait_for_load_ || (wait_for_load_ && node->is_favicon_loaded()))
         base::MessageLoopForUI::current()->Quit();
     }
   }
 
  private:
   BookmarkModel* model_;
   const BookmarkNode* node_;
   bool wait_for_load_;
@@ skipping 571 matching lines @@
   }
   return true;
 }
 
 namespace {
 
 // Helper class used in the implementation of AwaitAllModelsMatch.
 class AllModelsMatchChecker : public MultiClientStatusChangeChecker {
  public:
   AllModelsMatchChecker();
-  virtual ~AllModelsMatchChecker();
+  ~AllModelsMatchChecker() override;
 
-  virtual bool IsExitConditionSatisfied() override;
-  virtual std::string GetDebugMessage() const override;
+  bool IsExitConditionSatisfied() override;
+  std::string GetDebugMessage() const override;
 };
 
 AllModelsMatchChecker::AllModelsMatchChecker()
     : MultiClientStatusChangeChecker(
         sync_datatype_helper::test()->GetSyncServices()) {}
 
 AllModelsMatchChecker::~AllModelsMatchChecker() {}
 
 bool AllModelsMatchChecker::IsExitConditionSatisfied() {
   return AllModelsMatch();
@@ skipping 108 matching lines @@
 
 std::string IndexedSubfolderName(int i) {
   return base::StringPrintf("Subfolder Name %d", i);
 }
 
 std::string IndexedSubsubfolderName(int i) {
   return base::StringPrintf("Subsubfolder Name %d", i);
 }
 
 }  // namespace bookmarks_helper