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

The Google style guide states that only one of {virtual,override,final} should be used for each declaration, since override implies virtual and final implies both virtual and override.

This patch was manually generated using a regex and a text editor.

BUG=417463

Review URL: https://codereview.chromium.org/1101033002

Cr-Commit-Position: refs/heads/master@{#326582}

39 files changed, 170 insertions, 170 deletions

diff --git a/remoting/base/breakpad_win_unittest.cc b/remoting/base/breakpad_win_unittest.cc
index da554b2..78ab02a 100644
--- a/remoting/base/breakpad_win_unittest.cc
+++ b/remoting/base/breakpad_win_unittest.cc
@@ -69,9 +69,9 @@ void InitializeCrashReportingForTest(const wchar_t* pipe_name);
 class BreakpadWinDeathTest : public testing::Test {
  public:
   BreakpadWinDeathTest();
-  virtual ~BreakpadWinDeathTest();
+  ~BreakpadWinDeathTest() override;
 
-  virtual void SetUp() override;
+  void SetUp() override;
 
  protected:
   scoped_ptr<google_breakpad::CrashGenerationServer> crash_server_;
diff --git a/remoting/client/plugin/pepper_module.cc b/remoting/client/plugin/pepper_module.cc
index 557a70d..7082967 100644
--- a/remoting/client/plugin/pepper_module.cc
+++ b/remoting/client/plugin/pepper_module.cc
@@ -12,7 +12,7 @@ namespace remoting {
 
 class ChromotingModule : public pp::Module {
  protected:
-  virtual pp::Instance* CreateInstance(PP_Instance instance) override {
+  pp::Instance* CreateInstance(PP_Instance instance) override {
     pp::Instance* result = new ChromotingInstance(instance);
     return result;
   }
diff --git a/remoting/host/audio_capturer_win.h b/remoting/host/audio_capturer_win.h
index c9f19d3..49477fa 100644
--- a/remoting/host/audio_capturer_win.h
+++ b/remoting/host/audio_capturer_win.h
@@ -23,10 +23,10 @@ namespace remoting {
 class AudioCapturerWin : public AudioCapturer {
  public:
   AudioCapturerWin();
-  virtual ~AudioCapturerWin();
+  ~AudioCapturerWin() override;
 
   // AudioCapturer interface.
-  virtual bool Start(const PacketCapturedCallback& callback) override;
+  bool Start(const PacketCapturedCallback& callback) override;
 
  private:
   // Receives all packets from the audio capture endpoint buffer and pushes them
diff --git a/remoting/host/chromeos/aura_desktop_capturer_unittest.cc b/remoting/host/chromeos/aura_desktop_capturer_unittest.cc
index 9095cba..42dee81 100644
--- a/remoting/host/chromeos/aura_desktop_capturer_unittest.cc
+++ b/remoting/host/chromeos/aura_desktop_capturer_unittest.cc
@@ -39,7 +39,7 @@ class AuraDesktopCapturerTest : public testing::Test,
  public:
   AuraDesktopCapturerTest() {}
 
-  virtual void SetUp() override;
+  void SetUp() override;
 
   MOCK_METHOD1(CreateSharedMemory, webrtc::SharedMemory*(size_t size));
   MOCK_METHOD1(OnCaptureCompleted, void(webrtc::DesktopFrame* frame));
diff --git a/remoting/host/clipboard_win.cc b/remoting/host/clipboard_win.cc
index 7c25ec2..956cb3f 100644
--- a/remoting/host/clipboard_win.cc
+++ b/remoting/host/clipboard_win.cc
@@ -109,9 +109,9 @@ class ClipboardWin : public Clipboard {
   ClipboardWin();
   ~ClipboardWin() override;
 
-  virtual void Start(
+  void Start(
       scoped_ptr<protocol::ClipboardStub> client_clipboard) override;
-  virtual void InjectClipboardEvent(
+  void InjectClipboardEvent(
       const protocol::ClipboardEvent& event) override;
 
  private:
diff --git a/remoting/host/continue_window_win.cc b/remoting/host/continue_window_win.cc
index cb690e5..36aaba9 100644
--- a/remoting/host/continue_window_win.cc
+++ b/remoting/host/continue_window_win.cc
@@ -22,12 +22,12 @@ namespace {
 class ContinueWindowWin : public ContinueWindow {
  public:
   ContinueWindowWin();
-  virtual ~ContinueWindowWin();
+  ~ContinueWindowWin() override;
 
  protected:
   // ContinueWindow overrides.
-  virtual void ShowUi() override;
-  virtual void HideUi() override;
+  void ShowUi() override;
+  void HideUi() override;
 
  private:
   static BOOL CALLBACK DialogProc(HWND hwmd, UINT msg, WPARAM wParam,
diff --git a/remoting/host/curtain_mode_win.cc b/remoting/host/curtain_mode_win.cc
index a9f51c8..0a0f395 100644
--- a/remoting/host/curtain_mode_win.cc
+++ b/remoting/host/curtain_mode_win.cc
@@ -16,7 +16,7 @@ class CurtainModeWin : public CurtainMode {
   CurtainModeWin();
 
   // Overriden from CurtainMode.
-  virtual bool Activate() override;
+  bool Activate() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(CurtainModeWin);
diff --git a/remoting/host/daemon_process_unittest.cc b/remoting/host/daemon_process_unittest.cc
index d1e464b..def799b 100644
--- a/remoting/host/daemon_process_unittest.cc
+++ b/remoting/host/daemon_process_unittest.cc
@@ -54,15 +54,15 @@ class MockDaemonProcess : public DaemonProcess {
       scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
       scoped_refptr<AutoThreadTaskRunner> io_task_runner,
       const base::Closure& stopped_callback);
-  virtual ~MockDaemonProcess();
+  ~MockDaemonProcess() override;
 
-  virtual scoped_ptr<DesktopSession> DoCreateDesktopSession(
+  scoped_ptr<DesktopSession> DoCreateDesktopSession(
       int terminal_id,
       const ScreenResolution& resolution,
       bool virtual_terminal) override;
 
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
-  virtual void SendToNetwork(IPC::Message* message) override;
+  bool OnMessageReceived(const IPC::Message& message) override;
+  void SendToNetwork(IPC::Message* message) override;
 
   MOCK_METHOD1(Received, void(const IPC::Message&));
   MOCK_METHOD1(Sent, void(const IPC::Message&));
diff --git a/remoting/host/daemon_process_win.cc b/remoting/host/daemon_process_win.cc
index 32bf73a..08ffff6 100644
--- a/remoting/host/daemon_process_win.cc
+++ b/remoting/host/daemon_process_win.cc
@@ -68,28 +68,28 @@ class DaemonProcessWin : public DaemonProcess {
       scoped_refptr<AutoThreadTaskRunner> caller_task_runner,
       scoped_refptr<AutoThreadTaskRunner> io_task_runner,
       const base::Closure& stopped_callback);
-  virtual ~DaemonProcessWin();
+  ~DaemonProcessWin() override;
 
   // WorkerProcessIpcDelegate implementation.
-  virtual void OnChannelConnected(int32 peer_pid) override;
-  virtual void OnPermanentError(int exit_code) override;
+  void OnChannelConnected(int32 peer_pid) override;
+  void OnPermanentError(int exit_code) override;
 
   // DaemonProcess overrides.
-  virtual void SendToNetwork(IPC::Message* message) override;
-  virtual bool OnDesktopSessionAgentAttached(
+  void SendToNetwork(IPC::Message* message) override;
+  bool OnDesktopSessionAgentAttached(
       int terminal_id,
       base::ProcessHandle desktop_process,
       IPC::PlatformFileForTransit desktop_pipe) override;
 
  protected:
   // DaemonProcess implementation.
-  virtual scoped_ptr<DesktopSession> DoCreateDesktopSession(
+  scoped_ptr<DesktopSession> DoCreateDesktopSession(
       int terminal_id,
       const ScreenResolution& resolution,
       bool virtual_terminal) override;
-  virtual void DoCrashNetworkProcess(
+  void DoCrashNetworkProcess(
       const tracked_objects::Location& location) override;
-  virtual void LaunchNetworkProcess() override;
+  void LaunchNetworkProcess() override;
 
   // Changes the service start type to 'manual'.
   void DisableAutoStart();
diff --git a/remoting/host/desktop_process_unittest.cc b/remoting/host/desktop_process_unittest.cc
index 609473a..39a4e27 100644
--- a/remoting/host/desktop_process_unittest.cc
+++ b/remoting/host/desktop_process_unittest.cc
@@ -41,9 +41,9 @@ namespace {
 class MockDaemonListener : public IPC::Listener {
  public:
   MockDaemonListener() {}
-  virtual ~MockDaemonListener() {}
+  ~MockDaemonListener() override {}
 
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
+  bool OnMessageReceived(const IPC::Message& message) override;
 
   MOCK_METHOD1(OnDesktopAttached, void(IPC::PlatformFileForTransit));
   MOCK_METHOD1(OnChannelConnected, void(int32));
@@ -56,9 +56,9 @@ class MockDaemonListener : public IPC::Listener {
 class MockNetworkListener : public IPC::Listener {
  public:
   MockNetworkListener() {}
-  virtual ~MockNetworkListener() {}
+  ~MockNetworkListener() override {}
 
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
+  bool OnMessageReceived(const IPC::Message& message) override;
 
   MOCK_METHOD1(OnChannelConnected, void(int32));
   MOCK_METHOD0(OnChannelError, void());
diff --git a/remoting/host/desktop_resizer_win.cc b/remoting/host/desktop_resizer_win.cc
index f35b39f..de2fd376 100644
--- a/remoting/host/desktop_resizer_win.cc
+++ b/remoting/host/desktop_resizer_win.cc
@@ -32,14 +32,14 @@ static inline bool operator <(const ScreenResolution& a,
 class DesktopResizerWin : public DesktopResizer {
  public:
   DesktopResizerWin();
-  virtual ~DesktopResizerWin();
+  ~DesktopResizerWin() override;
 
   // DesktopResizer interface.
-  virtual ScreenResolution GetCurrentResolution() override;
-  virtual std::list<ScreenResolution> GetSupportedResolutions(
+  ScreenResolution GetCurrentResolution() override;
+  std::list<ScreenResolution> GetSupportedResolutions(
       const ScreenResolution& preferred) override;
-  virtual void SetResolution(const ScreenResolution& resolution) override;
-  virtual void RestoreResolution(const ScreenResolution& original) override;
+  void SetResolution(const ScreenResolution& resolution) override;
+  void RestoreResolution(const ScreenResolution& original) override;
 
  private:
   static bool IsResizeSupported();
diff --git a/remoting/host/desktop_session_win.cc b/remoting/host/desktop_session_win.cc
index c98f229..f3c0881 100644
--- a/remoting/host/desktop_session_win.cc
+++ b/remoting/host/desktop_session_win.cc
@@ -91,14 +91,14 @@ class ConsoleSession : public DesktopSessionWin {
     DaemonProcess* daemon_process,
     int id,
     WtsTerminalMonitor* monitor);
-  virtual ~ConsoleSession();
+  ~ConsoleSession() override;
 
  protected:
   // DesktopSession overrides.
-  virtual void SetScreenResolution(const ScreenResolution& resolution) override;
+  void SetScreenResolution(const ScreenResolution& resolution) override;
 
   // DesktopSessionWin overrides.
-  virtual void InjectSas() override;
+  void InjectSas() override;
 
  private:
   scoped_ptr<SasInjector> sas_injector_;
@@ -119,7 +119,7 @@ class RdpSession : public DesktopSessionWin {
     DaemonProcess* daemon_process,
     int id,
     WtsTerminalMonitor* monitor);
-  virtual ~RdpSession();
+  ~RdpSession() override;
 
   // Performs the part of initialization that can fail.
   bool Initialize(const ScreenResolution& resolution);
@@ -130,10 +130,10 @@ class RdpSession : public DesktopSessionWin {
 
  protected:
   // DesktopSession overrides.
-  virtual void SetScreenResolution(const ScreenResolution& resolution) override;
+  void SetScreenResolution(const ScreenResolution& resolution) override;
 
   // DesktopSessionWin overrides.
-  virtual void InjectSas() override;
+  void InjectSas() override;
 
  private:
   // An implementation of IRdpDesktopSessionEventHandler interface that forwards
diff --git a/remoting/host/desktop_session_win.h b/remoting/host/desktop_session_win.h
index 3e21a02..933be24 100644
--- a/remoting/host/desktop_session_win.h
+++ b/remoting/host/desktop_session_win.h
@@ -63,7 +63,7 @@ class DesktopSessionWin
     DaemonProcess* daemon_process,
     int id,
     WtsTerminalMonitor* monitor);
-  virtual ~DesktopSessionWin();
+  ~DesktopSessionWin() override;
 
   const scoped_refptr<AutoThreadTaskRunner>& caller_task_runner() const {
     return caller_task_runner_;
@@ -85,13 +85,13 @@ class DesktopSessionWin
   virtual void InjectSas() = 0;
 
   // WorkerProcessIpcDelegate implementation.
-  virtual void OnChannelConnected(int32 peer_pid) override;
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
-  virtual void OnPermanentError(int exit_code) override;
+  void OnChannelConnected(int32 peer_pid) override;
+  bool OnMessageReceived(const IPC::Message& message) override;
+  void OnPermanentError(int exit_code) override;
 
   // WtsTerminalObserver implementation.
-  virtual void OnSessionAttached(uint32 session_id) override;
-  virtual void OnSessionDetached() override;
+  void OnSessionAttached(uint32 session_id) override;
+  void OnSessionDetached() override;
 
  private:
   // ChromotingDesktopDaemonMsg_DesktopAttached handler.
diff --git a/remoting/host/disconnect_window_win.cc b/remoting/host/disconnect_window_win.cc
index fd789d4..7617b09 100644
--- a/remoting/host/disconnect_window_win.cc
+++ b/remoting/host/disconnect_window_win.cc
@@ -35,10 +35,10 @@ const int kWindowTextMargin = 8;
 class DisconnectWindowWin : public HostWindow {
  public:
   DisconnectWindowWin();
-  virtual ~DisconnectWindowWin();
+  ~DisconnectWindowWin() override;
 
   // HostWindow overrides.
-  virtual void Start(
+  void Start(
       const base::WeakPtr<ClientSessionControl>& client_session_control)
       override;
 
diff --git a/remoting/host/gnubby_auth_handler_win.cc b/remoting/host/gnubby_auth_handler_win.cc
index e24eb6b..6b8bd64 100644
--- a/remoting/host/gnubby_auth_handler_win.cc
+++ b/remoting/host/gnubby_auth_handler_win.cc
@@ -13,9 +13,9 @@ namespace {
 class GnubbyAuthHandlerWin : public GnubbyAuthHandler {
  private:
   // GnubbyAuthHandler interface.
-  virtual void DeliverClientMessage(const std::string& message) override;
-  virtual void DeliverHostDataMessage(int connection_id,
-                                      const std::string& data) const override;
+  void DeliverClientMessage(const std::string& message) override;
+  void DeliverHostDataMessage(int connection_id,
+                              const std::string& data) const override;
 
   DISALLOW_COPY_AND_ASSIGN(GnubbyAuthHandlerWin);
 };
diff --git a/remoting/host/host_event_logger_win.cc b/remoting/host/host_event_logger_win.cc
index fa58b52..d8b039f 100644
--- a/remoting/host/host_event_logger_win.cc
+++ b/remoting/host/host_event_logger_win.cc
@@ -27,19 +27,19 @@ class HostEventLoggerWin : public HostEventLogger, public HostStatusObserver {
   HostEventLoggerWin(base::WeakPtr<HostStatusMonitor> monitor,
                      const std::string& application_name);
 
-  virtual ~HostEventLoggerWin();
+  ~HostEventLoggerWin() override;
 
   // HostStatusObserver implementation.  These methods will be called from the
   // network thread.
-  virtual void OnClientAuthenticated(const std::string& jid) override;
-  virtual void OnClientDisconnected(const std::string& jid) override;
-  virtual void OnAccessDenied(const std::string& jid) override;
-  virtual void OnClientRouteChange(
+  void OnClientAuthenticated(const std::string& jid) override;
+  void OnClientDisconnected(const std::string& jid) override;
+  void OnAccessDenied(const std::string& jid) override;
+  void OnClientRouteChange(
       const std::string& jid,
       const std::string& channel_name,
       const protocol::TransportRoute& route) override;
-  virtual void OnStart(const std::string& xmpp_login) override;
-  virtual void OnShutdown() override;
+  void OnStart(const std::string& xmpp_login) override;
+  void OnShutdown() override;
 
  private:
   void LogString(WORD type, DWORD event_id, const std::string& string);
diff --git a/remoting/host/host_mock_objects.h b/remoting/host/host_mock_objects.h
index 6ea9d7b..52d0170 100644
--- a/remoting/host/host_mock_objects.h
+++ b/remoting/host/host_mock_objects.h
@@ -30,7 +30,7 @@ namespace remoting {
 class MockDesktopEnvironment : public DesktopEnvironment {
  public:
   MockDesktopEnvironment();
-  virtual ~MockDesktopEnvironment();
+  ~MockDesktopEnvironment() override;
 
   MOCK_METHOD0(CreateAudioCapturerPtr, AudioCapturer*());
   MOCK_METHOD0(CreateInputInjectorPtr, InputInjector*());
@@ -43,20 +43,20 @@ class MockDesktopEnvironment : public DesktopEnvironment {
       protocol::ClientStub* client_stub));
 
   // DesktopEnvironment implementation.
-  virtual scoped_ptr<AudioCapturer> CreateAudioCapturer() override;
-  virtual scoped_ptr<InputInjector> CreateInputInjector() override;
-  virtual scoped_ptr<ScreenControls> CreateScreenControls() override;
-  virtual scoped_ptr<webrtc::DesktopCapturer> CreateVideoCapturer() override;
-  virtual scoped_ptr<GnubbyAuthHandler> CreateGnubbyAuthHandler(
+  scoped_ptr<AudioCapturer> CreateAudioCapturer() override;
+  scoped_ptr<InputInjector> CreateInputInjector() override;
+  scoped_ptr<ScreenControls> CreateScreenControls() override;
+  scoped_ptr<webrtc::DesktopCapturer> CreateVideoCapturer() override;
+  scoped_ptr<GnubbyAuthHandler> CreateGnubbyAuthHandler(
       protocol::ClientStub* client_stub) override;
-  virtual scoped_ptr<webrtc::MouseCursorMonitor> CreateMouseCursorMonitor()
+  scoped_ptr<webrtc::MouseCursorMonitor> CreateMouseCursorMonitor()
       override;
 };
 
 class MockClientSessionControl : public ClientSessionControl {
  public:
   MockClientSessionControl();
-  virtual ~MockClientSessionControl();
+  ~MockClientSessionControl() override;
 
   MOCK_CONST_METHOD0(client_jid, const std::string&());
   MOCK_METHOD0(DisconnectSession, void());
@@ -71,7 +71,7 @@ class MockClientSessionControl : public ClientSessionControl {
 class MockClientSessionEventHandler : public ClientSession::EventHandler {
  public:
   MockClientSessionEventHandler();
-  virtual ~MockClientSessionEventHandler();
+  ~MockClientSessionEventHandler() override;
 
   MOCK_METHOD1(OnSessionAuthenticating, void(ClientSession* client));
   MOCK_METHOD1(OnSessionAuthenticated, bool(ClientSession* client));
@@ -90,12 +90,12 @@ class MockClientSessionEventHandler : public ClientSession::EventHandler {
 class MockDesktopEnvironmentFactory : public DesktopEnvironmentFactory {
  public:
   MockDesktopEnvironmentFactory();
-  virtual ~MockDesktopEnvironmentFactory();
+  ~MockDesktopEnvironmentFactory() override;
 
   MOCK_METHOD0(CreatePtr, DesktopEnvironment*());
   MOCK_CONST_METHOD0(SupportsAudioCapture, bool());
 
-  virtual scoped_ptr<DesktopEnvironment> Create(
+  scoped_ptr<DesktopEnvironment> Create(
       base::WeakPtr<ClientSessionControl> client_session_control) override;
 
  private:
@@ -105,7 +105,7 @@ class MockDesktopEnvironmentFactory : public DesktopEnvironmentFactory {
 class MockInputInjector : public InputInjector {
  public:
   MockInputInjector();
-  virtual ~MockInputInjector();
+  ~MockInputInjector() override;
 
   MOCK_METHOD1(InjectClipboardEvent,
                void(const protocol::ClipboardEvent& event));
@@ -125,7 +125,7 @@ class MockInputInjector : public InputInjector {
 class MockHostStatusObserver : public HostStatusObserver {
  public:
   MockHostStatusObserver();
-  virtual ~MockHostStatusObserver();
+  ~MockHostStatusObserver() override;
 
   MOCK_METHOD1(OnAccessDenied, void(const std::string& jid));
   MOCK_METHOD1(OnClientAuthenticated, void(const std::string& jid));
@@ -142,7 +142,7 @@ class MockHostStatusObserver : public HostStatusObserver {
 class MockGnubbyAuthHandler : public GnubbyAuthHandler {
  public:
   MockGnubbyAuthHandler();
-  virtual ~MockGnubbyAuthHandler();
+  ~MockGnubbyAuthHandler() override;
 
   MOCK_METHOD1(DeliverClientMessage, void(const std::string& message));
   MOCK_CONST_METHOD2(DeliverHostDataMessage,
@@ -155,7 +155,7 @@ class MockGnubbyAuthHandler : public GnubbyAuthHandler {
 class MockMouseCursorMonitor : public webrtc::MouseCursorMonitor {
  public:
   MockMouseCursorMonitor();
-  virtual ~MockMouseCursorMonitor();
+  ~MockMouseCursorMonitor() override;
 
   MOCK_METHOD2(Init, void(Callback* callback, Mode mode));
   MOCK_METHOD0(Capture, void());
diff --git a/remoting/host/input_injector_win.cc b/remoting/host/input_injector_win.cc
index 37f628ac..58f694e 100644
--- a/remoting/host/input_injector_win.cc
+++ b/remoting/host/input_injector_win.cc
@@ -59,19 +59,19 @@ class InputInjectorWin : public InputInjector {
  public:
   InputInjectorWin(scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
                    scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner);
-  virtual ~InputInjectorWin();
+  ~InputInjectorWin() override;
 
   // ClipboardStub interface.
-  virtual void InjectClipboardEvent(const ClipboardEvent& event) override;
+  void InjectClipboardEvent(const ClipboardEvent& event) override;
 
   // InputStub interface.
-  virtual void InjectKeyEvent(const KeyEvent& event) override;
-  virtual void InjectTextEvent(const TextEvent& event) override;
-  virtual void InjectMouseEvent(const MouseEvent& event) override;
-  virtual void InjectTouchEvent(const TouchEvent& event) override;
+  void InjectKeyEvent(const KeyEvent& event) override;
+  void InjectTextEvent(const TextEvent& event) override;
+  void InjectMouseEvent(const MouseEvent& event) override;
+  void InjectTouchEvent(const TouchEvent& event) override;
 
   // InputInjector interface.
-  virtual void Start(
+  void Start(
       scoped_ptr<protocol::ClipboardStub> client_clipboard) override;
 
  private:
diff --git a/remoting/host/ipc_desktop_environment_unittest.cc b/remoting/host/ipc_desktop_environment_unittest.cc
index d31d3d4..186574b 100644
--- a/remoting/host/ipc_desktop_environment_unittest.cc
+++ b/remoting/host/ipc_desktop_environment_unittest.cc
@@ -57,10 +57,10 @@ namespace {
 class FakeDaemonSender : public IPC::Sender {
  public:
   FakeDaemonSender() {}
-  virtual ~FakeDaemonSender() {}
+  ~FakeDaemonSender() override {}
 
   // IPC::Sender implementation.
-  virtual bool Send(IPC::Message* message) override;
+  bool Send(IPC::Message* message) override;
 
   MOCK_METHOD3(ConnectTerminal, void(int, const ScreenResolution&, bool));
   MOCK_METHOD1(DisconnectTerminal, void(int));
@@ -76,9 +76,9 @@ class FakeDaemonSender : public IPC::Sender {
 class MockDaemonListener : public IPC::Listener {
  public:
   MockDaemonListener() {}
-  virtual ~MockDaemonListener() {}
+  ~MockDaemonListener() override {}
 
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
+  bool OnMessageReceived(const IPC::Message& message) override;
 
   MOCK_METHOD1(OnDesktopAttached, void(IPC::PlatformFileForTransit));
   MOCK_METHOD1(OnChannelConnected, void(int32));
diff --git a/remoting/host/pairing_registry_delegate_win.h b/remoting/host/pairing_registry_delegate_win.h
index 9f9d4dc..f7cf832 100644
--- a/remoting/host/pairing_registry_delegate_win.h
+++ b/remoting/host/pairing_registry_delegate_win.h
@@ -44,7 +44,7 @@ class PairingRegistryDelegateWin
     : public protocol::PairingRegistry::Delegate {
  public:
   PairingRegistryDelegateWin();
-  virtual ~PairingRegistryDelegateWin();
+  ~PairingRegistryDelegateWin() override;
 
   // Passes the root keys to be used to access the pairing registry store.
   // |privileged| is optional and may be nullptr. The caller retains ownership
@@ -52,12 +52,12 @@ class PairingRegistryDelegateWin
   bool SetRootKeys(HKEY privileged, HKEY unprivileged);
 
   // PairingRegistry::Delegate interface
-  virtual scoped_ptr<base::ListValue> LoadAll() override;
-  virtual bool DeleteAll() override;
-  virtual protocol::PairingRegistry::Pairing Load(
+  scoped_ptr<base::ListValue> LoadAll() override;
+  bool DeleteAll() override;
+  protocol::PairingRegistry::Pairing Load(
       const std::string& client_id) override;
-  virtual bool Save(const protocol::PairingRegistry::Pairing& pairing) override;
-  virtual bool Delete(const std::string& client_id) override;
+  bool Save(const protocol::PairingRegistry::Pairing& pairing) override;
+  bool Delete(const std::string& client_id) override;
 
  private:
   base::win::RegKey privileged_;
diff --git a/remoting/host/pairing_registry_delegate_win_unittest.cc b/remoting/host/pairing_registry_delegate_win_unittest.cc
index 7801926..646bd19 100644
--- a/remoting/host/pairing_registry_delegate_win_unittest.cc
+++ b/remoting/host/pairing_registry_delegate_win_unittest.cc
@@ -18,7 +18,7 @@ using protocol::PairingRegistry;
 
 class PairingRegistryDelegateWinTest : public testing::Test {
  public:
-  virtual void SetUp() override {
+  void SetUp() override {
     key_name_ = base::GenerateGUID();
 
     base::win::RegKey root;
@@ -32,7 +32,7 @@ class PairingRegistryDelegateWinTest : public testing::Test {
                                      KEY_READ | KEY_WRITE) == ERROR_SUCCESS);
   }
 
-  virtual void TearDown() override {
+  void TearDown() override {
     privileged_.Close();
     unprivileged_.Close();
     EXPECT_TRUE(
diff --git a/remoting/host/sas_injector_win.cc b/remoting/host/sas_injector_win.cc
index 53e98b1..ec64a11 100644
--- a/remoting/host/sas_injector_win.cc
+++ b/remoting/host/sas_injector_win.cc
@@ -109,10 +109,10 @@ bool ScopedSoftwareSasPolicy::Apply() {
 class SasInjectorWin : public SasInjector {
  public:
   SasInjectorWin();
-  virtual ~SasInjectorWin();
+  ~SasInjectorWin() override;
 
   // SasInjector implementation.
-  virtual bool InjectSas() override;
+  bool InjectSas() override;
 
  private:
   base::ScopedNativeLibrary sas_dll_;
@@ -125,10 +125,10 @@ class SasInjectorWin : public SasInjector {
 class SasInjectorXp : public SasInjector {
  public:
   SasInjectorXp();
-  virtual ~SasInjectorXp();
+  ~SasInjectorXp() override;
 
   // SasInjector implementation.
-  virtual bool InjectSas() override;
+  bool InjectSas() override;
 };
 
 SasInjectorWin::SasInjectorWin() : send_sas_(nullptr) {
diff --git a/remoting/host/setup/daemon_controller_delegate_win.h b/remoting/host/setup/daemon_controller_delegate_win.h
index 1131045..d7b2582 100644
--- a/remoting/host/setup/daemon_controller_delegate_win.h
+++ b/remoting/host/setup/daemon_controller_delegate_win.h
@@ -14,20 +14,20 @@ class DaemonInstallerWin;
 class DaemonControllerDelegateWin : public DaemonController::Delegate {
  public:
   DaemonControllerDelegateWin();
-  virtual ~DaemonControllerDelegateWin();
+  ~DaemonControllerDelegateWin() override;
 
   // DaemonController::Delegate interface.
-  virtual DaemonController::State GetState() override;
-  virtual scoped_ptr<base::DictionaryValue> GetConfig() override;
-  virtual void SetConfigAndStart(
+  DaemonController::State GetState() override;
+  scoped_ptr<base::DictionaryValue> GetConfig() override;
+  void SetConfigAndStart(
       scoped_ptr<base::DictionaryValue> config,
       bool consent,
       const DaemonController::CompletionCallback& done) override;
-  virtual void UpdateConfig(
+  void UpdateConfig(
       scoped_ptr<base::DictionaryValue> config,
       const DaemonController::CompletionCallback& done) override;
-  virtual void Stop(const DaemonController::CompletionCallback& done) override;
-  virtual DaemonController::UsageStatsConsent GetUsageStatsConsent() override;
+  void Stop(const DaemonController::CompletionCallback& done) override;
+  DaemonController::UsageStatsConsent GetUsageStatsConsent() override;
 
   DISALLOW_COPY_AND_ASSIGN(DaemonControllerDelegateWin);
 };
diff --git a/remoting/host/setup/me2me_native_messaging_host.h b/remoting/host/setup/me2me_native_messaging_host.h
index e1ddaed..6944149 100644
--- a/remoting/host/setup/me2me_native_messaging_host.h
+++ b/remoting/host/setup/me2me_native_messaging_host.h
@@ -135,8 +135,8 @@ class Me2MeNativeMessagingHost
    public:
     ElevatedChannelEventHandler(Me2MeNativeMessagingHost* host);
 
-    virtual void OnMessage(scoped_ptr<base::Value> message) override;
-    virtual void OnDisconnect() override;
+    void OnMessage(scoped_ptr<base::Value> message) override;
+    void OnDisconnect() override;
    private:
     Me2MeNativeMessagingHost* parent_;
   };
diff --git a/remoting/host/win/chromoting_module.h b/remoting/host/win/chromoting_module.h
index b20184a..867deee 100644
--- a/remoting/host/win/chromoting_module.h
+++ b/remoting/host/win/chromoting_module.h
@@ -36,7 +36,7 @@ class ChromotingModule : public ATL::CAtlModuleT<ChromotingModule> {
   // Initializes the module. |classes| and |classes_end| must outlive |this|.
   ChromotingModule(ATL::_ATL_OBJMAP_ENTRY* classes,
                    ATL::_ATL_OBJMAP_ENTRY* classes_end);
-  virtual ~ChromotingModule();
+  ~ChromotingModule() override;
 
   // Returns the task runner used by the module. Returns nullptr if the task
   // runner hasn't been registered yet or if the server is shutting down.
@@ -47,7 +47,7 @@ class ChromotingModule : public ATL::CAtlModuleT<ChromotingModule> {
   bool Run();
 
   // ATL::CAtlModuleT<> overrides
-  virtual LONG Unlock() override;
+  LONG Unlock() override;
 
   DECLARE_LIBID(LIBID_ChromotingLib)
 
diff --git a/remoting/host/win/host_service.h b/remoting/host/win/host_service.h
index 96cfff2..0ab78fe 100644
--- a/remoting/host/win/host_service.h
+++ b/remoting/host/win/host_service.h
@@ -37,14 +37,14 @@ class HostService : public WtsTerminalMonitor {
   int Run();
 
   // WtsTerminalMonitor implementation
-  virtual bool AddWtsTerminalObserver(const std::string& terminal_id,
+  bool AddWtsTerminalObserver(const std::string& terminal_id,
                                       WtsTerminalObserver* observer) override;
-  virtual void RemoveWtsTerminalObserver(
+  void RemoveWtsTerminalObserver(
       WtsTerminalObserver* observer) override;
 
  private:
   HostService();
-  ~HostService();
+  ~HostService() override;
 
   // Notifies the service of changes in session state.
   void OnSessionChange(uint32 event, uint32 session_id);
diff --git a/remoting/host/win/rdp_client.cc b/remoting/host/win/rdp_client.cc
index f41db10..8f029ef 100644
--- a/remoting/host/win/rdp_client.cc
+++ b/remoting/host/win/rdp_client.cc
@@ -56,12 +56,12 @@ class RdpClient::Core
   void InjectSas();
 
   // RdpClientWindow::EventHandler interface.
-  virtual void OnConnected() override;
-  virtual void OnDisconnected() override;
+  void OnConnected() override;
+  void OnDisconnected() override;
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
-  virtual ~Core();
+  ~Core() override;
 
   // Helpers for the event handler's methods that make sure that OnRdpClosed()
   // is the last notification delivered and is delevered only once.
diff --git a/remoting/host/win/rdp_client_unittest.cc b/remoting/host/win/rdp_client_unittest.cc
index 1b37d5c..2093aeb 100644
--- a/remoting/host/win/rdp_client_unittest.cc
+++ b/remoting/host/win/rdp_client_unittest.cc
@@ -79,10 +79,10 @@ RdpClientModule::~RdpClientModule() {
 class RdpClientTest : public testing::Test {
  public:
   RdpClientTest();
-  virtual ~RdpClientTest();
+  ~RdpClientTest() override;
 
-  virtual void SetUp() override;
-  virtual void TearDown() override;
+  void SetUp() override;
+  void TearDown() override;
 
   // Caaled when an RDP connection is established.
   void OnRdpConnected();
diff --git a/remoting/host/win/rdp_desktop_session.h b/remoting/host/win/rdp_desktop_session.h
index 9f08692..18a1eb4 100644
--- a/remoting/host/win/rdp_desktop_session.h
+++ b/remoting/host/win/rdp_desktop_session.h
@@ -49,8 +49,8 @@ class __declspec(uuid(RDP_DESKTOP_SESSION_CLSID)) RdpDesktopSession
 
  private:
   // RdpClient::EventHandler interface.
-  virtual void OnRdpConnected() override;
-  virtual void OnRdpClosed() override;
+  void OnRdpConnected() override;
+  void OnRdpClosed() override;
 
   BEGIN_COM_MAP(RdpDesktopSession)
     COM_INTERFACE_ENTRY(IRdpDesktopSession)
diff --git a/remoting/host/win/session_desktop_environment.h b/remoting/host/win/session_desktop_environment.h
index 949fa5e..233938f 100644
--- a/remoting/host/win/session_desktop_environment.h
+++ b/remoting/host/win/session_desktop_environment.h
@@ -17,10 +17,10 @@ namespace remoting {
 // with Windows sessions.
 class SessionDesktopEnvironment : public Me2MeDesktopEnvironment {
  public:
-  virtual ~SessionDesktopEnvironment();
+  ~SessionDesktopEnvironment() override;
 
   // DesktopEnvironment implementation.
-  virtual scoped_ptr<InputInjector> CreateInputInjector() override;
+  scoped_ptr<InputInjector> CreateInputInjector() override;
 
  private:
   friend class SessionDesktopEnvironmentFactory;
@@ -44,10 +44,10 @@ class SessionDesktopEnvironmentFactory : public Me2MeDesktopEnvironmentFactory {
       scoped_refptr<base::SingleThreadTaskRunner> input_task_runner,
       scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner,
       const base::Closure& inject_sas);
-  virtual ~SessionDesktopEnvironmentFactory();
+  ~SessionDesktopEnvironmentFactory() override;
 
   // DesktopEnvironmentFactory implementation.
-  virtual scoped_ptr<DesktopEnvironment> Create(
+  scoped_ptr<DesktopEnvironment> Create(
       base::WeakPtr<ClientSessionControl> client_session_control) override;
 
  private:
diff --git a/remoting/host/win/session_input_injector.cc b/remoting/host/win/session_input_injector.cc
index bf8158e..60fe893 100644
--- a/remoting/host/win/session_input_injector.cc
+++ b/remoting/host/win/session_input_injector.cc
@@ -56,20 +56,20 @@ class SessionInputInjectorWin::Core
       const base::Closure& inject_sas);
 
   // InputInjector implementation.
-  virtual void Start(scoped_ptr<ClipboardStub> client_clipboard) override;
+  void Start(scoped_ptr<ClipboardStub> client_clipboard) override;
 
   // protocol::ClipboardStub implementation.
-  virtual void InjectClipboardEvent(const ClipboardEvent& event) override;
+  void InjectClipboardEvent(const ClipboardEvent& event) override;
 
   // protocol::InputStub implementation.
-  virtual void InjectKeyEvent(const KeyEvent& event) override;
-  virtual void InjectTextEvent(const TextEvent& event) override;
-  virtual void InjectMouseEvent(const MouseEvent& event) override;
-  virtual void InjectTouchEvent(const TouchEvent& event) override;
+  void InjectKeyEvent(const KeyEvent& event) override;
+  void InjectTextEvent(const TextEvent& event) override;
+  void InjectMouseEvent(const MouseEvent& event) override;
+  void InjectTouchEvent(const TouchEvent& event) override;
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
-  virtual ~Core();
+  ~Core() override;
 
   // Switches to the desktop receiving a user input if different from
   // the current one.
diff --git a/remoting/host/win/session_input_injector.h b/remoting/host/win/session_input_injector.h
index 99ee83d..60a626c 100644
--- a/remoting/host/win/session_input_injector.h
+++ b/remoting/host/win/session_input_injector.h
@@ -29,21 +29,21 @@ class SessionInputInjectorWin : public InputInjector {
       scoped_ptr<InputInjector> nested_executor,
       scoped_refptr<base::SingleThreadTaskRunner> inject_sas_task_runner,
       const base::Closure& inject_sas);
-  virtual ~SessionInputInjectorWin();
+  ~SessionInputInjectorWin() override;
 
   // InputInjector implementation.
-  virtual void Start(
+  void Start(
       scoped_ptr<protocol::ClipboardStub> client_clipboard) override;
 
   // protocol::ClipboardStub implementation.
-  virtual void InjectClipboardEvent(
+  void InjectClipboardEvent(
       const protocol::ClipboardEvent& event) override;
 
   // protocol::InputStub implementation.
-  virtual void InjectKeyEvent(const protocol::KeyEvent& event) override;
-  virtual void InjectTextEvent(const protocol::TextEvent& event) override;
-  virtual void InjectMouseEvent(const protocol::MouseEvent& event) override;
-  virtual void InjectTouchEvent(const protocol::TouchEvent& event) override;
+  void InjectKeyEvent(const protocol::KeyEvent& event) override;
+  void InjectTextEvent(const protocol::TextEvent& event) override;
+  void InjectMouseEvent(const protocol::MouseEvent& event) override;
+  void InjectTouchEvent(const protocol::TouchEvent& event) override;
 
  private:
   // The actual implementation resides in SessionInputInjectorWin::Core class.
diff --git a/remoting/host/win/unprivileged_process_delegate.h b/remoting/host/win/unprivileged_process_delegate.h
index 74cd8ea..8de011f 100644
--- a/remoting/host/win/unprivileged_process_delegate.h
+++ b/remoting/host/win/unprivileged_process_delegate.h
@@ -37,19 +37,19 @@ class UnprivilegedProcessDelegate
   UnprivilegedProcessDelegate(
       scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
       scoped_ptr<base::CommandLine> target_command);
-  virtual ~UnprivilegedProcessDelegate();
+  ~UnprivilegedProcessDelegate() override;
 
   // WorkerProcessLauncher::Delegate implementation.
-  virtual void LaunchProcess(WorkerProcessLauncher* event_handler) override;
-  virtual void Send(IPC::Message* message) override;
-  virtual void CloseChannel() override;
-  virtual void KillProcess() override;
+  void LaunchProcess(WorkerProcessLauncher* event_handler) override;
+  void Send(IPC::Message* message) override;
+  void CloseChannel() override;
+  void KillProcess() override;
 
  private:
   // IPC::Listener implementation.
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
-  virtual void OnChannelConnected(int32 peer_pid) override;
-  virtual void OnChannelError() override;
+  bool OnMessageReceived(const IPC::Message& message) override;
+  void OnChannelConnected(int32 peer_pid) override;
+  void OnChannelError() override;
 
   void ReportFatalError();
   void ReportProcessLaunched(base::win::ScopedHandle worker_process);
diff --git a/remoting/host/win/worker_process_launcher.h b/remoting/host/win/worker_process_launcher.h
index d48b9dc..f512a2b 100644
--- a/remoting/host/win/worker_process_launcher.h
+++ b/remoting/host/win/worker_process_launcher.h
@@ -66,7 +66,7 @@ class WorkerProcessLauncher
   // |ipc_handler| must outlive this object.
   WorkerProcessLauncher(scoped_ptr<Delegate> launcher_delegate,
                         WorkerProcessIpcDelegate* ipc_handler);
-  virtual ~WorkerProcessLauncher();
+  ~WorkerProcessLauncher() override;
 
   // Asks the worker process to crash and generate a dump, and closes the IPC
   // channel. |location| is passed to the worker so that it is on the stack in
@@ -102,7 +102,7 @@ class WorkerProcessLauncher
 
   // base::win::ObjectWatcher::Delegate implementation used to watch for
   // the worker process exiting.
-  virtual void OnObjectSignaled(HANDLE object) override;
+  void OnObjectSignaled(HANDLE object) override;
 
   // Returns true when the object is being destroyed.
   bool stopping() const { return ipc_handler_ == nullptr; }
diff --git a/remoting/host/win/worker_process_launcher_unittest.cc b/remoting/host/win/worker_process_launcher_unittest.cc
index aa6f095..9ace9a5 100644
--- a/remoting/host/win/worker_process_launcher_unittest.cc
+++ b/remoting/host/win/worker_process_launcher_unittest.cc
@@ -42,7 +42,7 @@ const char kIpcSecurityDescriptor[] = "D:(A;;GA;;;AU)";
 class MockProcessLauncherDelegate : public WorkerProcessLauncher::Delegate {
  public:
   MockProcessLauncherDelegate() {}
-  virtual ~MockProcessLauncherDelegate() {}
+  ~MockProcessLauncherDelegate() override {}
 
   // WorkerProcessLauncher::Delegate interface.
   MOCK_METHOD1(LaunchProcess, void(WorkerProcessLauncher*));
@@ -57,7 +57,7 @@ class MockProcessLauncherDelegate : public WorkerProcessLauncher::Delegate {
 class MockIpcDelegate : public WorkerProcessIpcDelegate {
  public:
   MockIpcDelegate() {}
-  virtual ~MockIpcDelegate() {}
+  ~MockIpcDelegate() override {}
 
   // WorkerProcessIpcDelegate interface.
   MOCK_METHOD1(OnChannelConnected, void(int32));
@@ -71,12 +71,12 @@ class MockIpcDelegate : public WorkerProcessIpcDelegate {
 class MockWorkerListener : public IPC::Listener {
  public:
   MockWorkerListener() {}
-  virtual ~MockWorkerListener() {}
+  ~MockWorkerListener() override {}
 
   MOCK_METHOD3(OnCrash, void(const std::string&, const std::string&, int));
 
   // IPC::Listener implementation
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
+  bool OnMessageReceived(const IPC::Message& message) override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockWorkerListener);
@@ -101,15 +101,15 @@ class WorkerProcessLauncherTest
       public IPC::Listener {
  public:
   WorkerProcessLauncherTest();
-  virtual ~WorkerProcessLauncherTest();
+  ~WorkerProcessLauncherTest() override;
 
-  virtual void SetUp() override;
-  virtual void TearDown() override;
+  void SetUp() override;
+  void TearDown() override;
 
   // IPC::Listener implementation.
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
-  virtual void OnChannelConnected(int32 peer_pid) override;
-  virtual void OnChannelError() override;
+  bool OnMessageReceived(const IPC::Message& message) override;
+  void OnChannelConnected(int32 peer_pid) override;
+  void OnChannelError() override;
 
   // WorkerProcessLauncher::Delegate mocks
   void LaunchProcess(
diff --git a/remoting/host/win/wts_session_process_delegate.cc b/remoting/host/win/wts_session_process_delegate.cc
index 66d7f0c..8130599 100644
--- a/remoting/host/win/wts_session_process_delegate.cc
+++ b/remoting/host/win/wts_session_process_delegate.cc
@@ -63,17 +63,17 @@ class WtsSessionProcessDelegate::Core
 
  private:
   friend class base::RefCountedThreadSafe<Core>;
-  virtual ~Core();
+  ~Core() override;
 
   // base::MessagePumpForIO::IOHandler implementation.
-  virtual void OnIOCompleted(base::MessagePumpForIO::IOContext* context,
-                             DWORD bytes_transferred,
-                             DWORD error) override;
+  void OnIOCompleted(base::MessagePumpForIO::IOContext* context,
+                     DWORD bytes_transferred,
+                     DWORD error) override;
 
   // IPC::Listener implementation.
-  virtual bool OnMessageReceived(const IPC::Message& message) override;
-  virtual void OnChannelConnected(int32 peer_pid) override;
-  virtual void OnChannelError() override;
+  bool OnMessageReceived(const IPC::Message& message) override;
+  void OnChannelConnected(int32 peer_pid) override;
+  void OnChannelError() override;
 
   // The actual implementation of LaunchProcess()
   void DoLaunchProcess();
diff --git a/remoting/host/win/wts_session_process_delegate.h b/remoting/host/win/wts_session_process_delegate.h
index 625c846..e99db67 100644
--- a/remoting/host/win/wts_session_process_delegate.h
+++ b/remoting/host/win/wts_session_process_delegate.h
@@ -34,16 +34,16 @@ class WtsSessionProcessDelegate
       scoped_ptr<base::CommandLine> target,
       bool launch_elevated,
       const std::string& channel_security);
-  ~WtsSessionProcessDelegate();
+  ~WtsSessionProcessDelegate() override;
 
   // Initializes the object returning true on success.
   bool Initialize(uint32 session_id);
 
   // WorkerProcessLauncher::Delegate implementation.
-  virtual void LaunchProcess(WorkerProcessLauncher* event_handler) override;
-  virtual void Send(IPC::Message* message) override;
-  virtual void CloseChannel() override;
-  virtual void KillProcess() override;
+  void LaunchProcess(WorkerProcessLauncher* event_handler) override;
+  void Send(IPC::Message* message) override;
+  void CloseChannel() override;
+  void KillProcess() override;
 
  private:
   // The actual implementation resides in WtsSessionProcessDelegate::Core class.
diff --git a/remoting/protocol/monitored_video_stub_unittest.cc b/remoting/protocol/monitored_video_stub_unittest.cc
index 67162c3..e98c0d1 100644
--- a/remoting/protocol/monitored_video_stub_unittest.cc
+++ b/remoting/protocol/monitored_video_stub_unittest.cc
@@ -24,7 +24,7 @@ static const int64 kTestOverrideDelayMilliseconds = 1;
 
 class MonitoredVideoStubTest : public testing::Test {
  protected:
-  virtual void SetUp() override {
+  void SetUp() override {
     packet_.reset(new VideoPacket());
     monitor_.reset(new MonitoredVideoStub(
         &video_stub_,
diff --git a/remoting/signaling/mock_signal_strategy.h b/remoting/signaling/mock_signal_strategy.h
index c39eba7..3245931 100644
--- a/remoting/signaling/mock_signal_strategy.h
+++ b/remoting/signaling/mock_signal_strategy.h
@@ -13,7 +13,7 @@ namespace remoting {
 class MockSignalStrategy : public SignalStrategy {
  public:
   MockSignalStrategy();
-  virtual ~MockSignalStrategy();
+  ~MockSignalStrategy() override;
 
   MOCK_METHOD0(Connect, void());
   MOCK_METHOD0(Disconnect, void());
@@ -27,7 +27,7 @@ class MockSignalStrategy : public SignalStrategy {
   // GMock currently doesn't support move-only arguments, so we have
   // to use this hack here.
   MOCK_METHOD1(SendStanzaPtr, bool(buzz::XmlElement* stanza));
-  virtual bool SendStanza(scoped_ptr<buzz::XmlElement> stanza) override {
+  bool SendStanza(scoped_ptr<buzz::XmlElement> stanza) override {
     return SendStanzaPtr(stanza.release());
   }
 };