Standardize usage of virtual/override/final in ipc/

ipc/ipc_sync_channel.h

 // 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.
 
 #ifndef IPC_IPC_SYNC_CHANNEL_H_
 #define IPC_IPC_SYNC_CHANNEL_H_
 
 #include <string>
 #include <deque>
 
@@ skipping 73 matching lines @@
       base::WaitableEvent* shutdown_event);
 
   // Creates an uninitialized sync channel. Call ChannelProxy::Init to
   // initialize the channel. This two-step setup allows message filters to be
   // added before any messages are sent or received.
   static scoped_ptr<SyncChannel> Create(
       Listener* listener,
       const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner,
       base::WaitableEvent* shutdown_event);
 
-  virtual ~SyncChannel();
+  ~SyncChannel() override;
 
-  virtual bool Send(Message* message) override;
+  bool Send(Message* message) override;
 
   // Sets the dispatch group for this channel, to only allow re-entrant dispatch
   // of messages to other channels in the same group.
   //
   // Normally, any unblocking message coming from any channel can be dispatched
   // when any (possibly other) channel is blocked on sending a message. This is
   // needed in some cases to unblock certain loops (e.g. necessary when some
   // processes share a window hierarchy), but may cause re-entrancy issues in
   // some cases where such loops are not possible. This flags allows the tagging
   // of some particular channels to only re-enter in known correct cases.
@@ skipping 56 matching lines @@
       restrict_dispatch_group_ = group;
     }
 
     int restrict_dispatch_group() const {
       return restrict_dispatch_group_;
     }
 
     base::WaitableEventWatcher::EventCallback MakeWaitableEventCallback();
 
    private:
-    virtual ~SyncContext();
+    ~SyncContext() override;
     // ChannelProxy methods that we override.
 
     // Called on the listener thread.
-    virtual void Clear() override;
+    void Clear() override;
 
     // Called on the IPC thread.
-    virtual bool OnMessageReceived(const Message& msg) override;
-    virtual void OnChannelError() override;
-    virtual void OnChannelOpened() override;
-    virtual void OnChannelClosed() override;
+    bool OnMessageReceived(const Message& msg) override;
+    void OnChannelError() override;
+    void OnChannelOpened() override;
+    void OnChannelClosed() override;
 
     // Cancels all pending Send calls.
     void CancelPendingSends();
 
     void OnWaitableEventSignaled(base::WaitableEvent* event);
 
     typedef std::deque<PendingSyncMsg> PendingSyncMessageQueue;
     PendingSyncMessageQueue deserializers_;
     base::Lock deserializers_lock_;
 
@@ skipping 32 matching lines @@
   // Used to signal events between the IPC and listener threads.
   base::WaitableEventWatcher dispatch_watcher_;
   base::WaitableEventWatcher::EventCallback dispatch_watcher_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncChannel);
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_SYNC_CHANNEL_H_