Revert of Standardize usage of virtual/override/final in ipc/

ipc/ipc_channel_posix.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_CHANNEL_POSIX_H_
 #define IPC_IPC_CHANNEL_POSIX_H_
 
 #include "ipc/ipc_channel.h"
 
 #include <sys/socket.h>  // for CMSG macros
@@ skipping 38 matching lines @@
 #endif
 
 namespace IPC {
 
 class IPC_EXPORT ChannelPosix : public Channel,
                                 public internal::ChannelReader,
                                 public base::MessageLoopForIO::Watcher {
  public:
   ChannelPosix(const IPC::ChannelHandle& channel_handle, Mode mode,
                Listener* listener);
-  ~ChannelPosix() override;
+  virtual ~ChannelPosix();
 
   // Channel implementation
-  bool Connect() override;
-  void Close() override;
-  bool Send(Message* message) override;
-  base::ProcessId GetPeerPID() const override;
-  base::ProcessId GetSelfPID() const override;
-  int GetClientFileDescriptor() const override;
-  base::ScopedFD TakeClientFileDescriptor() override;
+  virtual bool Connect() override;
+  virtual void Close() override;
+  virtual bool Send(Message* message) override;
+  virtual base::ProcessId GetPeerPID() const override;
+  virtual base::ProcessId GetSelfPID() const override;
+  virtual int GetClientFileDescriptor() const override;
+  virtual base::ScopedFD TakeClientFileDescriptor() override;
 
   // Returns true if the channel supports listening for connections.
   bool AcceptsConnections() const;
 
   // Returns true if the channel supports listening for connections and is
   // currently connected.
   bool HasAcceptedConnection() const;
 
   // Closes any currently connected socket, and returns to a listening state
   // for more connections.
@@ skipping 16 matching lines @@
   bool ProcessOutgoingMessages();
 
   bool AcceptConnection();
   void ClosePipeOnError();
   int GetHelloMessageProcId() const;
   void QueueHelloMessage();
   void CloseFileDescriptors(Message* msg);
   void QueueCloseFDMessage(int fd, int hops);
 
   // ChannelReader implementation.
-  ReadState ReadData(char* buffer, int buffer_len, int* bytes_read) override;
-  bool WillDispatchInputMessage(Message* msg) override;
-  bool DidEmptyInputBuffers() override;
-  void HandleInternalMessage(const Message& msg) override;
+  virtual ReadState ReadData(char* buffer,
+                             int buffer_len,
+                             int* bytes_read) override;
+  virtual bool WillDispatchInputMessage(Message* msg) override;
+  virtual bool DidEmptyInputBuffers() override;
+  virtual void HandleInternalMessage(const Message& msg) override;
 
 #if defined(IPC_USES_READWRITE)
   // Reads the next message from the fd_pipe_ and appends them to the
   // input_fds_ queue. Returns false if there was a message receiving error.
   // True means there was a message and it was processed properly, or there was
   // no messages.
   bool ReadFileDescriptorsFromFDPipe();
 #endif
 
   // Finds the set of file descriptors in the given message.  On success,
   // appends the descriptors to the input_fds_ member and returns true
   //
   // Returns false if the message was truncated. In this case, any handles that
   // were sent will be closed.
   bool ExtractFileDescriptorsFromMsghdr(msghdr* msg);
 
   // Closes all handles in the input_fds_ list and clears the list. This is
   // used to clean up handles in error conditions to avoid leaking the handles.
   void ClearInputFDs();
 
   // MessageLoopForIO::Watcher implementation.
-  void OnFileCanReadWithoutBlocking(int fd) override;
-  void OnFileCanWriteWithoutBlocking(int fd) override;
+  virtual void OnFileCanReadWithoutBlocking(int fd) override;
+  virtual void OnFileCanWriteWithoutBlocking(int fd) override;
 
   Mode mode_;
 
   base::ProcessId peer_pid_;
 
   // After accepting one client connection on our server socket we want to
   // stop listening.
   base::MessageLoopForIO::FileDescriptorWatcher
   server_listen_connection_watcher_;
   base::MessageLoopForIO::FileDescriptorWatcher read_watcher_;
@@ skipping 74 matching lines @@
   // If non-zero, overrides the process ID sent in the hello message.
   static int global_pid_;
 #endif  // OS_LINUX
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(ChannelPosix);
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_POSIX_H_