Standardize usage of virtual/override/final in content/browser/

content/browser/ppapi_plugin_process_host.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 "content/browser/ppapi_plugin_process_host.h"
 
 #include <string>
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
@@ skipping 30 matching lines @@
   PpapiPluginSandboxedProcessLauncherDelegate(bool is_broker,
                                               const PepperPluginInfo& info,
                                               ChildProcessHost* host)
       :
 #if defined(OS_POSIX)
         info_(info),
         ipc_fd_(host->TakeClientFileDescriptor()),
 #endif  // OS_POSIX
         is_broker_(is_broker) {}
 
-  virtual ~PpapiPluginSandboxedProcessLauncherDelegate() {}
+  ~PpapiPluginSandboxedProcessLauncherDelegate() override {}
 
 #if defined(OS_WIN)
   virtual bool ShouldSandbox() override {
     return !is_broker_;
   }
 
   virtual void PreSpawnTarget(sandbox::TargetPolicy* policy,
                               bool* success) {
     if (is_broker_)
       return;
     // The Pepper process as locked-down as a renderer execpt that it can
     // create the server side of chrome pipes.
     sandbox::ResultCode result;
     result = policy->AddRule(sandbox::TargetPolicy::SUBSYS_NAMED_PIPES,
                              sandbox::TargetPolicy::NAMEDPIPES_ALLOW_ANY,
                              L"\\\\.\\pipe\\chrome.*");
     *success = (result == sandbox::SBOX_ALL_OK);
   }
 
 #elif defined(OS_POSIX)
-  virtual bool ShouldUseZygote() override {
+  bool ShouldUseZygote() override {
     const base::CommandLine& browser_command_line =
         *base::CommandLine::ForCurrentProcess();
     base::CommandLine::StringType plugin_launcher = browser_command_line
         .GetSwitchValueNative(switches::kPpapiPluginLauncher);
     return !is_broker_ && plugin_launcher.empty() && info_.is_sandboxed;
   }
-  virtual base::ScopedFD TakeIpcFd() override {
-    return ipc_fd_.Pass();
-  }
+  base::ScopedFD TakeIpcFd() override { return ipc_fd_.Pass(); }
 #endif  // OS_WIN
 
  private:
 #if defined(OS_POSIX)
   const PepperPluginInfo& info_;
   base::ScopedFD ipc_fd_;
 #endif  // OS_POSIX
   bool is_broker_;
 
   DISALLOW_COPY_AND_ASSIGN(PpapiPluginSandboxedProcessLauncherDelegate);
 };
 
 class PpapiPluginProcessHost::PluginNetworkObserver
     : public net::NetworkChangeNotifier::IPAddressObserver,
       public net::NetworkChangeNotifier::ConnectionTypeObserver {
  public:
   explicit PluginNetworkObserver(PpapiPluginProcessHost* process_host)
       : process_host_(process_host) {
     net::NetworkChangeNotifier::AddIPAddressObserver(this);
     net::NetworkChangeNotifier::AddConnectionTypeObserver(this);
   }
 
-  virtual ~PluginNetworkObserver() {
+  ~PluginNetworkObserver() override {
     net::NetworkChangeNotifier::RemoveConnectionTypeObserver(this);
     net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
   }
 
   // IPAddressObserver implementation.
-  virtual void OnIPAddressChanged() override {
+  void OnIPAddressChanged() override {
     // TODO(brettw) bug 90246: This doesn't seem correct. The online/offline
     // notification seems like it should be sufficient, but I don't see that
     // when I unplug and replug my network cable. Sending this notification when
     // "something" changes seems to make Flash reasonably happy, but seems
     // wrong. We should really be able to provide the real online state in
     // OnConnectionTypeChanged().
     process_host_->Send(new PpapiMsg_SetNetworkState(true));
   }
 
   // ConnectionTypeObserver implementation.
-  virtual void OnConnectionTypeChanged(
+  void OnConnectionTypeChanged(
       net::NetworkChangeNotifier::ConnectionType type) override {
     process_host_->Send(new PpapiMsg_SetNetworkState(
         type != net::NetworkChangeNotifier::CONNECTION_NONE));
   }
 
  private:
   PpapiPluginProcessHost* const process_host_;
 };
 
 PpapiPluginProcessHost::~PpapiPluginProcessHost() {
@@ skipping 332 matching lines @@
   // sent_requests_ queue should be the one that the plugin just created.
   Client* client = sent_requests_.front();
   sent_requests_.pop();
 
   const ChildProcessData& data = process_->GetData();
   client->OnPpapiChannelOpened(channel_handle, base::GetProcId(data.handle),
                                data.id);
 }
 
 }  // namespace content