Update {virtual,override,final} to follow C++11 style.

chrome/browser/android/provider/chrome_browser_provider.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/android/provider/chrome_browser_provider.h"
 
 #include <cmath>
 #include <list>
 #include <utility>
 
@@ skipping 230 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(AddBookmarkTask);
 };
 
 // Utility method to remove a bookmark.
 class RemoveBookmarkTask : public BookmarkModelObserverTask {
  public:
   explicit RemoveBookmarkTask(BookmarkModel* model)
       : BookmarkModelObserverTask(model),
         deleted_(0),
         id_to_delete_(kInvalidBookmarkId) {}
-  virtual ~RemoveBookmarkTask() {}
+  ~RemoveBookmarkTask() override {}
 
   int Run(const int64 id) {
     id_to_delete_ = id;
     RunOnUIThreadBlocking::Run(
         base::Bind(&RemoveBookmarkTask::RunOnUIThread, model(), id));
     return deleted_;
   }
 
   static void RunOnUIThread(BookmarkModel* model, const int64 id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     const BookmarkNode* node = bookmarks::GetBookmarkNodeByID(model, id);
     if (node && node->parent()) {
       const BookmarkNode* parent_node = node->parent();
       model->Remove(parent_node, parent_node->GetIndexOf(node));
     }
   }
 
   // Verify that the bookmark was actually removed. Called synchronously.
-  virtual void BookmarkNodeRemoved(
-      BookmarkModel* bookmark_model,
-      const BookmarkNode* parent,
-      int old_index,
-      const BookmarkNode* node,
-      const std::set<GURL>& removed_urls) override {
+  void BookmarkNodeRemoved(BookmarkModel* bookmark_model,
+                           const BookmarkNode* parent,
+                           int old_index,
+                           const BookmarkNode* node,
+                           const std::set<GURL>& removed_urls) override {
     if (bookmark_model == model() && node->id() == id_to_delete_)
         ++deleted_;
   }
 
  private:
   int deleted_;
   int64 id_to_delete_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoveBookmarkTask);
 };
 
 // Utility method to remove all bookmarks that the user can edit.
 class RemoveAllUserBookmarksTask : public BookmarkModelObserverTask {
  public:
   explicit RemoveAllUserBookmarksTask(BookmarkModel* model)
       : BookmarkModelObserverTask(model) {}
 
-  virtual ~RemoveAllUserBookmarksTask() {}
+  ~RemoveAllUserBookmarksTask() override {}
 
   void Run() {
     RunOnUIThreadBlocking::Run(
         base::Bind(&RemoveAllUserBookmarksTask::RunOnUIThread, model()));
   }
 
   static void RunOnUIThread(BookmarkModel* model) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     model->RemoveAllUserBookmarks();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(RemoveAllUserBookmarksTask);
 };
 
 // Utility method to update a bookmark.
 class UpdateBookmarkTask : public BookmarkModelObserverTask {
  public:
   explicit UpdateBookmarkTask(BookmarkModel* model)
       : BookmarkModelObserverTask(model),
         updated_(0),
         id_to_update_(kInvalidBookmarkId){}
-  virtual ~UpdateBookmarkTask() {}
+  ~UpdateBookmarkTask() override {}
 
   int Run(const int64 id,
           const base::string16& title,
           const base::string16& url,
           const int64 parent_id) {
     id_to_update_ = id;
     RunOnUIThreadBlocking::Run(
         base::Bind(&UpdateBookmarkTask::RunOnUIThread,
                    model(), id, title, url, parent_id));
     return updated_;
@@ skipping 21 matching lines @@
         const BookmarkNode* new_parent =
             bookmarks::GetBookmarkNodeByID(model, parent_id);
 
         if (new_parent)
           model->Move(node, new_parent, 0);
       }
     }
   }
 
   // Verify that the bookmark was actually updated. Called synchronously.
-  virtual void BookmarkNodeChanged(BookmarkModel* bookmark_model,
-                                   const BookmarkNode* node) override {
+  void BookmarkNodeChanged(BookmarkModel* bookmark_model,
+                           const BookmarkNode* node) override {
     if (bookmark_model == model() && node->id() == id_to_update_)
       ++updated_;
   }
 
  private:
   int updated_;
   int64 id_to_update_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateBookmarkTask);
 };
@@ skipping 1270 matching lines @@
   ScopedJavaLocalRef<jobject> obj = weak_java_provider_.get(env);
   if (obj.is_null())
     return;
   Java_ChromeBrowserProvider_onSearchTermChanged(env, obj.obj());
 }
 
 void ChromeBrowserProvider::OnKeywordSearchTermDeleted(
     HistoryService* history_service,
     history::URLID url_id) {
 }