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

chrome/browser/ui/webui/devtools_ui.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/ui/webui/devtools_ui.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted_memory.h"
@@ skipping 51 matching lines @@
 
 // FetchRequest ---------------------------------------------------------------
 
 class FetchRequest : public net::URLFetcherDelegate {
  public:
   FetchRequest(net::URLRequestContextGetter* request_context,
                const GURL& url,
                const content::URLDataSource::GotDataCallback& callback);
 
  private:
-  virtual ~FetchRequest() {}
-  virtual void OnURLFetchComplete(const net::URLFetcher* source) override;
+  ~FetchRequest() override {}
+  void OnURLFetchComplete(const net::URLFetcher* source) override;
   scoped_ptr<net::URLFetcher> fetcher_;
   content::URLDataSource::GotDataCallback callback_;
 };
 
 FetchRequest::FetchRequest(
     net::URLRequestContextGetter* request_context,
     const GURL& url,
     const content::URLDataSource::GotDataCallback& callback)
     : callback_(callback) {
   if (!url.is_valid()) {
@@ skipping 40 matching lines @@
 // An URLDataSource implementation that handles chrome-devtools://devtools/
 // requests. Three types of requests could be handled based on the URL path:
 // 1. /bundled/: bundled DevTools frontend is served.
 // 2. /remote/: remote DevTools frontend is served from App Engine.
 // 3. /remote/open/: query is URL which is opened on remote device.
 class DevToolsDataSource : public content::URLDataSource {
  public:
   explicit DevToolsDataSource(net::URLRequestContextGetter* request_context);
 
   // content::URLDataSource implementation.
-  virtual std::string GetSource() const override;
+  std::string GetSource() const override;
 
-  virtual void StartDataRequest(
+  void StartDataRequest(
       const std::string& path,
       int render_process_id,
       int render_frame_id,
       const content::URLDataSource::GotDataCallback& callback) override;
 
  private:
   // content::URLDataSource overrides.
-  virtual std::string GetMimeType(const std::string& path) const override;
-  virtual bool ShouldAddContentSecurityPolicy() const override;
-  virtual bool ShouldServeMimeTypeAsContentTypeHeader() const override;
+  std::string GetMimeType(const std::string& path) const override;
+  bool ShouldAddContentSecurityPolicy() const override;
+  bool ShouldServeMimeTypeAsContentTypeHeader() const override;
 
   // Serves bundled DevTools frontend from ResourceBundle.
   void StartBundledDataRequest(
       const std::string& path,
       int render_process_id,
       int render_frame_id,
       const content::URLDataSource::GotDataCallback& callback);
 
   // Serves remote DevTools frontend from hard-coded App Engine domain.
   void StartRemoteDataRequest(
       const std::string& path,
       int render_process_id,
       int render_frame_id,
       const content::URLDataSource::GotDataCallback& callback);
 
-  virtual ~DevToolsDataSource() {}
+  ~DevToolsDataSource() override {}
   scoped_refptr<net::URLRequestContextGetter> request_context_;
 
   DISALLOW_COPY_AND_ASSIGN(DevToolsDataSource);
 };
 
 DevToolsDataSource::DevToolsDataSource(
     net::URLRequestContextGetter* request_context)
     : request_context_(request_context) {
 }
 
@@ skipping 82 matching lines @@
 }
 
 // OpenRemotePageRequest ------------------------------------------------------
 
 class OpenRemotePageRequest : public DevToolsAndroidBridge::DeviceListListener {
  public:
   OpenRemotePageRequest(
       Profile* profile,
       const std::string url,
       const DevToolsAndroidBridge::RemotePageCallback& callback);
-  virtual ~OpenRemotePageRequest() {}
+  ~OpenRemotePageRequest() override {}
 
  private:
   // DevToolsAndroidBridge::Listener overrides.
-  virtual void DeviceListChanged(
+  void DeviceListChanged(
       const DevToolsAndroidBridge::RemoteDevices& devices) override;
 
   bool OpenInBrowser(
       scoped_refptr<DevToolsAndroidBridge::RemoteBrowser> browser);
   void RemotePageOpened(scoped_refptr<DevToolsAndroidBridge::RemotePage> page);
 
   std::string url_;
   DevToolsAndroidBridge::RemotePageCallback callback_;
   bool opening_;
   scoped_refptr<DevToolsAndroidBridge> android_bridge_;
@@ skipping 134 matching lines @@
   params.should_replace_current_entry = true;
   remote_frontend_loading_url_ = virtual_url;
   navigation_controller.LoadURLWithParams(params);
   navigation_controller.GetPendingEntry()->SetVirtualURL(virtual_url);
 
   DevToolsAndroidBridge* bridge =
       DevToolsAndroidBridge::Factory::GetForProfile(profile);
   scoped_ptr<DevToolsTargetImpl> target(bridge->CreatePageTarget(page));
   bindings_.AttachTo(target->GetAgentHost());
 }