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

chrome/browser/ui/webui/memory_internals/memory_internals_proxy.cc

 // Copyright 2013 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/ui/webui/memory_internals/memory_internals_proxy.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 35 matching lines @@
 class Profile;
 
 namespace {
 
 class ProcessDetails : public MemoryDetails {
  public:
   typedef base::Callback<void(const ProcessData&)> DataCallback;
   explicit ProcessDetails(const DataCallback& callback)
       : callback_(callback) {}
   // MemoryDetails:
-  virtual void OnDetailsAvailable() override {
+  void OnDetailsAvailable() override {
     const std::vector<ProcessData>& browser_processes = processes();
     // [0] means Chrome.
     callback_.Run(browser_processes[0]);
   }
 
  private:
-  virtual ~ProcessDetails() {}
+  ~ProcessDetails() override {}
 
   DataCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessDetails);
 };
 
 base::DictionaryValue* FindProcessFromPid(base::ListValue* processes,
                                           base::ProcessId pid) {
   const size_t n = processes->GetSize();
   for (size_t i = 0; i < n; ++i) {
@@ skipping 48 matching lines @@
  public:
   typedef base::Callback<void(const base::ProcessId pid,
                               const size_t v8_allocated,
                               const size_t v8_used)> V8DataCallback;
 
   explicit RendererDetails(const V8DataCallback& callback)
       : callback_(callback) {
     registrar_.Add(this, chrome::NOTIFICATION_RENDERER_V8_HEAP_STATS_COMPUTED,
                    content::NotificationService::AllSources());
   }
-  virtual ~RendererDetails() {}
+  ~RendererDetails() override {}
 
   void Request() {
     for (std::set<content::WebContents*>::iterator iter = web_contents_.begin();
          iter != web_contents_.end(); ++iter)
       (*iter)->GetRenderViewHost()->Send(new ChromeViewMsg_GetV8HeapStats);
   }
 
   void AddWebContents(content::WebContents* content) {
     web_contents_.insert(content);
   }
 
   void Clear() {
     web_contents_.clear();
   }
 
   void RemoveWebContents(base::ProcessId) {
     // We don't have to detect which content is the caller of this method.
     if (!web_contents_.empty())
       web_contents_.erase(web_contents_.begin());
   }
 
   int IsClean() {
     return web_contents_.empty();
   }
 
  private:
   // NotificationObserver:
-  virtual void Observe(int type,
-                       const content::NotificationSource& source,
-                       const content::NotificationDetails& details) override {
+  void Observe(int type,
+               const content::NotificationSource& source,
+               const content::NotificationDetails& details) override {
     const base::ProcessId* pid =
         content::Source<const base::ProcessId>(source).ptr();
     const ChromeRenderMessageFilter::V8HeapStatsDetails* v8_heap =
         content::Details<const ChromeRenderMessageFilter::V8HeapStatsDetails>(
             details).ptr();
     callback_.Run(*pid,
                   v8_heap->v8_memory_allocated(),
                   v8_heap->v8_memory_used());
   }
 
@@ skipping 166 matching lines @@
     const std::string& function, const base::Value& args) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   std::vector<const base::Value*> args_vector(1, &args);
   base::string16 update =
       content::WebUI::GetJavascriptCall(function, args_vector);
   // Don't forward updates to a destructed UI.
   if (handler_)
     handler_->OnUpdate(update);
 }