Remove unnecessary public typedef from AsyncSocketIoHandler

base/async_socket_io_handler.h

 // Copyright 2013 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 BASE_ASYNC_SOCKET_IO_HANDLER_H_
 #define BASE_ASYNC_SOCKET_IO_HANDLER_H_
 
 #include "base/message_loop/message_loop.h"
 #include "base/sync_socket.h"
 #include "base/threading/non_thread_safe.h"
 
 namespace base {
 
-// The message loop callback interface is different based on platforms.
-#if defined(OS_WIN)
-typedef base::MessageLoopForIO::IOHandler MessageLoopIOHandler;
-#elif defined(OS_POSIX)
-typedef base::MessageLoopForIO::Watcher MessageLoopIOHandler;
-#endif
-
 // Extends the CancelableSyncSocket class to allow reading from a socket
 // asynchronously on a TYPE_IO message loop thread.  This makes it easy to share
 // a thread that uses a message loop (e.g. for IPC and other things) and not
 // require a separate thread to read from the socket.
 //
 // Example usage (also see the unit tests):
 //
 // class SocketReader {
 //  public:
 //   SocketReader(base::CancelableSyncSocket* socket)
@@ skipping 15 matching lines @@
 //     }
 //   }
 //
 //   base::AsyncSocketIoHandler io_handler;
 //   base::CancelableSyncSocket* socket_;
 //   char buffer_[kBufferSize];
 // };
 //
 class BASE_EXPORT AsyncSocketIoHandler
     : public NON_EXPORTED_BASE(base::NonThreadSafe),
-      public NON_EXPORTED_BASE(MessageLoopIOHandler) {
+// The message loop callback interface is different based on platforms.
+#if defined(OS_WIN)
+      public NON_EXPORTED_BASE(base::MessageLoopForIO::IOHandler) {
+#else
+      public NON_EXPORTED_BASE(base::MessageLoopForIO::Watcher) {
+#endif
  public:
   AsyncSocketIoHandler();
   virtual ~AsyncSocketIoHandler();
 
   // Type definition for the callback. The parameter tells how many
   // bytes were read and is 0 if an error occurred.
   typedef base::Callback<void(int)> ReadCompleteCallback;
 
   // Initializes the AsyncSocketIoHandler by hooking it up to the current
   // thread's message loop (must be TYPE_IO), to do async reads from the socket
   // on the current thread.  The |callback| will be invoked whenever a Read()
   // has completed.
   bool Initialize(base::SyncSocket::Handle socket,
                   const ReadCompleteCallback& callback);
 
   // Attempts to read from the socket.  The return value will be |false|
   // if an error occurred and |true| if data was read or a pending read
   // was issued.  Regardless of async or sync operation, the
   // ReadCompleteCallback (see above) will be called when data is available.
   bool Read(char* buffer, int buffer_len);
 
  private:
 #if defined(OS_WIN)

[darin (slow to review), 2013/08/29 01:37:16]

Another approach would have been to create an inner class to hide the OS
specific details.  You could have used a PIMPL pattern.  This seems reasonable
given how most of the member variables are not shared between POSIX and WIN.

   // Implementation of IOHandler on Windows.
   virtual void OnIOCompleted(base::MessageLoopForIO::IOContext* context,
                              DWORD bytes_transfered,
                              DWORD error) OVERRIDE;
 #elif defined(OS_POSIX)
   // Implementation of base::MessageLoopForIO::Watcher.
   virtual void OnFileCanWriteWithoutBlocking(int socket) OVERRIDE {}
   virtual void OnFileCanReadWithoutBlocking(int socket) OVERRIDE;
 
   void EnsureWatchingSocket();
@@ skipping 13 matching lines @@
   bool is_watching_;
 #endif
   ReadCompleteCallback read_complete_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncSocketIoHandler);
 };
 
 }  // namespace base.
 
 #endif  // BASE_ASYNC_SOCKET_IO_HANDLER_H_