Fix namespace for 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 media {
+namespace base {
 
 // The message loop callback interface is different based on platforms.
 #if defined(OS_WIN)
 typedef base::MessageLoopForIO::IOHandler MessageLoopIOHandler;

[darin (slow to review), 2013/08/23 16:20:41]

nit: This appears to be defined in the wrong place. I would expect a top-level
typename that starts with MessageLoop to be defined in base/message_loop/
somewhere.

[qsr, 2013/08/26 08:36:02]

 I'm not sure we want this to be available outside of this class...

 Would putting this in a async_socket_io_handler_internal sub-namespace be fine
with you?

[tommi (sloooow) - chröme, 2013/08/26 08:46:25]

The IOHandler and Watcher interfaces actually are defined in message_loop/.  The
problem is that these interfaces have different names on Windows and Posix so an
#ifdef is needed here.
For slightly better readability (imho), I kept the #ifdef out of the class
inheritance section but you can just change that.  I.e. remove this typedef,
move the #ifdef into the inheritance section and problem solved.

 #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):
@@ skipping 12 matching lines @@
 //   }
 //
 //  private:
 //   void OnDataAvailable(int bytes_read) {
 //     if (ProcessData(&buffer_[0], bytes_read)) {
 //       // Issue another read.
 //       CHECK(io_handler.Read(&buffer_[0], sizeof(buffer_)));
 //     }
 //   }
 //
-//   media::AsyncSocketIoHandler io_handler;
+//   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) {
  public:
   AsyncSocketIoHandler();
   virtual ~AsyncSocketIoHandler();
@@ skipping 40 matching lines @@
   char* pending_buffer_;
   int pending_buffer_len_;
   // |true| iff the message loop is watching the socket for IO events.
   bool is_watching_;
 #endif
   ReadCompleteCallback read_complete_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncSocketIoHandler);
 };
 
-}  // namespace media.
+}  // namespace base.
 
 #endif  // BASE_ASYNC_SOCKET_IO_HANDLER_H_