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

chrome/browser/android/dev_tools_manager_delegate_android.cc

 // Copyright 2014 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/dev_tools_manager_delegate_android.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 37 matching lines @@
 base::TimeTicks GetLastActiveTimeForAgentHost(
     scoped_refptr<DevToolsAgentHost> agent_host) {
   if (WebContents* web_contents = agent_host->GetWebContents())
     return web_contents->GetLastActiveTime();
   return base::TimeTicks();
 }
 
 class TargetBase : public content::DevToolsTarget {
  public:
   // content::DevToolsTarget implementation:
-  virtual std::string GetParentId() const override { return std::string(); }
+  std::string GetParentId() const override { return std::string(); }
 
-  virtual std::string GetTitle() const override { return title_; }
+  std::string GetTitle() const override { return title_; }
 
-  virtual std::string GetDescription() const override { return std::string(); }
+  std::string GetDescription() const override { return std::string(); }
 
-  virtual GURL GetURL() const override { return url_; }
+  GURL GetURL() const override { return url_; }
 
-  virtual GURL GetFaviconURL() const override { return favicon_url_; }
+  GURL GetFaviconURL() const override { return favicon_url_; }
 
-  virtual base::TimeTicks GetLastActivityTime() const override {
+  base::TimeTicks GetLastActivityTime() const override {
     return last_activity_time_;
   }
 
  protected:
   explicit TargetBase(WebContents* web_contents)
       : title_(base::UTF16ToUTF8(web_contents->GetTitle())),
         url_(web_contents->GetURL()),
         favicon_url_(GetFaviconURLForContents(web_contents)),
         last_activity_time_(web_contents->GetLastActiveTime()) {
   }
@@ skipping 24 matching lines @@
     return new TabTarget(tab_id, web_contents);
   }
 
   static TabTarget* CreateForUnloadedTab(int tab_id,
                                          const base::string16& title,
                                          const GURL& url) {
     return new TabTarget(tab_id, title, url);
   }
 
   // content::DevToolsTarget implementation:
-  virtual std::string GetId() const override {
-    return base::IntToString(tab_id_);
-  }
+  std::string GetId() const override { return base::IntToString(tab_id_); }
 
-  virtual std::string GetType() const override {
-    return kTargetTypePage;
-  }
+  std::string GetType() const override { return kTargetTypePage; }
 
-  virtual bool IsAttached() const override {
+  bool IsAttached() const override {
     TabModel* model;
     int index;
     if (!FindTab(&model, &index))
       return false;
     WebContents* web_contents = model->GetWebContentsAt(index);
     if (!web_contents)
       return false;
     return DevToolsAgentHost::IsDebuggerAttached(web_contents);
   }
 
-  virtual scoped_refptr<DevToolsAgentHost> GetAgentHost() const override {
+  scoped_refptr<DevToolsAgentHost> GetAgentHost() const override {
     TabModel* model;
     int index;
     if (!FindTab(&model, &index))
       return NULL;
     WebContents* web_contents = model->GetWebContentsAt(index);
     if (!web_contents) {
       // The tab has been pushed out of memory, pull it back.
       TabAndroid* tab = model->GetTabAt(index);
       if (!tab)
         return NULL;
 
       if (!tab->LoadIfNeeded())
         return NULL;
 
       web_contents = model->GetWebContentsAt(index);
       if (!web_contents)
         return NULL;
     }
     return DevToolsAgentHost::GetOrCreateFor(web_contents);
   }
 
-  virtual bool Activate() const override {
+  bool Activate() const override {
     TabModel* model;
     int index;
     if (!FindTab(&model, &index))
       return false;
     model->SetActiveIndex(index);
     return true;
   }
 
-  virtual bool Close() const override {
+  bool Close() const override {
     TabModel* model;
     int index;
     if (!FindTab(&model, &index))
       return false;
     model->CloseTabAt(index);
     return true;
   }
 
  private:
   TabTarget(int tab_id, WebContents* web_contents)
@@ skipping 26 matching lines @@
 };
 
 class NonTabTarget : public TargetBase {
  public:
   explicit NonTabTarget(scoped_refptr<DevToolsAgentHost> agent_host)
       : TargetBase(agent_host),
         agent_host_(agent_host) {
   }
 
   // content::DevToolsTarget implementation:
-  virtual std::string GetId() const override {
-    return agent_host_->GetId();
-  }
+  std::string GetId() const override { return agent_host_->GetId(); }
 
-  virtual std::string GetType() const override {
+  std::string GetType() const override {
     switch (agent_host_->GetType()) {
       case DevToolsAgentHost::TYPE_WEB_CONTENTS:
         if (TabModelList::begin() == TabModelList::end()) {
           // If there are no tab models we must be running in ChromeShell.
           // Return the 'page' target type for backwards compatibility.
           return kTargetTypePage;
         }
         break;
       case DevToolsAgentHost::TYPE_SERVICE_WORKER:
         return kTargetTypeServiceWorker;
       default:
         break;
     }
     return kTargetTypeOther;
   }
 
-  virtual bool IsAttached() const override {
-    return agent_host_->IsAttached();
-  }
+  bool IsAttached() const override { return agent_host_->IsAttached(); }
 
-  virtual scoped_refptr<DevToolsAgentHost> GetAgentHost() const override {
+  scoped_refptr<DevToolsAgentHost> GetAgentHost() const override {
     return agent_host_;
   }
 
-  virtual bool Activate() const override {
-    return agent_host_->Activate();
-  }
+  bool Activate() const override { return agent_host_->Activate(); }
 
-  virtual bool Close() const override {
-    return agent_host_->Close();
-  }
+  bool Close() const override { return agent_host_->Close(); }
 
  private:
   scoped_refptr<DevToolsAgentHost> agent_host_;
 };
 
 }  // namespace
 
 DevToolsManagerDelegateAndroid::DevToolsManagerDelegateAndroid()
     : network_protocol_handler_(new DevToolsNetworkProtocolHandler()) {
 }
@@ skipping 84 matching lines @@
   Profile* profile = ProfileManager::GetLastUsedProfile()->GetOriginalProfile();
   scoped_refptr<history::TopSites> top_sites =
       TopSitesFactory::GetForProfile(profile);
   if (top_sites) {
     scoped_refptr<base::RefCountedMemory> data;
     if (top_sites->GetPageThumbnail(url, false, &data))
       return std::string(data->front_as<char>(), data->size());
   }
   return std::string();
 }