Reorder the methods in net/url_request/.

net/base/listen_socket.cc

 // Copyright (c) 2010 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.
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 // winsock2.h must be included first in order to ensure it is included before
 // windows.h.
 #include <winsock2.h>
@@ skipping 26 matching lines @@
 }  // namespace
 
 #if defined(OS_WIN)
 const SOCKET ListenSocket::kInvalidSocket = INVALID_SOCKET;
 const int ListenSocket::kSocketError = SOCKET_ERROR;
 #elif defined(OS_POSIX)
 const SOCKET ListenSocket::kInvalidSocket = -1;
 const int ListenSocket::kSocketError = -1;
 #endif
 
+ListenSocket* ListenSocket::Listen(std::string ip, int port,
+                                   ListenSocketDelegate* del) {
+  SOCKET s = Listen(ip, port);
+  if (s == kInvalidSocket) {
+    // TODO(erikkay): error handling
+  } else {
+    ListenSocket* sock = new ListenSocket(s, del);
+    sock->Listen();
+    return sock;
+  }
+  return NULL;
+}
+
+void ListenSocket::Send(const char* bytes, int len, bool append_linefeed) {
+  SendInternal(bytes, len);
+  if (append_linefeed) {
+    SendInternal("\r\n", 2);
+  }
+}
+
+void ListenSocket::Send(const std::string& str, bool append_linefeed) {
+  Send(str.data(), static_cast<int>(str.length()), append_linefeed);
+}
+
+void ListenSocket::PauseReads() {
+  DCHECK(!reads_paused_);
+  reads_paused_ = true;
+}
+
+void ListenSocket::ResumeReads() {
+  DCHECK(reads_paused_);
+  reads_paused_ = false;
+  if (has_pending_reads_) {
+    has_pending_reads_ = false;
+    Read();
+  }
+}
+
 ListenSocket::ListenSocket(SOCKET s, ListenSocketDelegate *del)
     : socket_(s),
       socket_delegate_(del),
       reads_paused_(false),
       has_pending_reads_(false) {
 #if defined(OS_WIN)
   socket_event_ = WSACreateEvent();
   // TODO(ibrar): error handling in case of socket_event_ == WSA_INVALID_EVENT
   WatchSocket(NOT_WAITING);
 #endif
@@ skipping 22 matching lines @@
       closesocket(s);
 #elif defined(OS_POSIX)
       close(s);
 #endif
       s = kInvalidSocket;
     }
   }
   return s;
 }
 
-ListenSocket* ListenSocket::Listen(std::string ip, int port,
-                                   ListenSocketDelegate* del) {
-  SOCKET s = Listen(ip, port);
-  if (s == kInvalidSocket) {
-    // TODO(erikkay): error handling
-  } else {
-    ListenSocket* sock = new ListenSocket(s, del);
-    sock->Listen();
-    return sock;
+SOCKET ListenSocket::Accept(SOCKET s) {
+  sockaddr_in from;
+  socklen_t from_len = sizeof(from);
+  SOCKET conn =
+      HANDLE_EINTR(accept(s, reinterpret_cast<sockaddr*>(&from), &from_len));
+  if (conn != kInvalidSocket) {
+    net::SetNonBlocking(conn);
   }
-  return NULL;
+  return conn;
+}
+
+void ListenSocket::SendInternal(const char* bytes, int len) {
+  char* send_buf = const_cast<char *>(bytes);
+  int len_left = len;
+  while (true) {
+    int sent = HANDLE_EINTR(send(socket_, send_buf, len_left, 0));
+    if (sent == len_left) {  // A shortcut to avoid extraneous checks.
+      break;
+    }
+    if (sent == kSocketError) {
+#if defined(OS_WIN)
+      if (WSAGetLastError() != WSAEWOULDBLOCK) {
+        LOG(ERROR) << "send failed: WSAGetLastError()==" << WSAGetLastError();
+#elif defined(OS_POSIX)
+      if (errno != EWOULDBLOCK && errno != EAGAIN) {
+        LOG(ERROR) << "send failed: errno==" << errno;
+#endif
+        break;
+      }
+      // Otherwise we would block, and now we have to wait for a retry.
+      // Fall through to PlatformThread::YieldCurrentThread()
+    } else {
+      // sent != len_left according to the shortcut above.
+      // Shift the buffer start and send the remainder after a short while.
+      send_buf += sent;
+      len_left -= sent;
+    }
+    base::PlatformThread::YieldCurrentThread();
+  }
 }
 
 void ListenSocket::Listen() {
   int backlog = 10;  // TODO(erikkay): maybe don't allow any backlog?
   listen(socket_, backlog);
   // TODO(erikkay): error handling
 #if defined(OS_POSIX)
   WatchSocket(WAITING_ACCEPT);
 #endif
 }
 
-SOCKET ListenSocket::Accept(SOCKET s) {
-  sockaddr_in from;
-  socklen_t from_len = sizeof(from);
-  SOCKET conn =
-      HANDLE_EINTR(accept(s, reinterpret_cast<sockaddr*>(&from), &from_len));
-  if (conn != kInvalidSocket) {
-    net::SetNonBlocking(conn);
-  }
-  return conn;
-}
-
 void ListenSocket::Accept() {
   SOCKET conn = Accept(socket_);
   if (conn != kInvalidSocket) {
     scoped_refptr<ListenSocket> sock(
         new ListenSocket(conn, socket_delegate_));
     // it's up to the delegate to AddRef if it wants to keep it around
 #if defined(OS_POSIX)
     sock->WatchSocket(WAITING_READ);
 #endif
     socket_delegate_->DidAccept(this, sock);
@@ skipping 27 matching lines @@
 #endif
     } else {
       // TODO(ibrar): maybe change DidRead to take a length instead
       DCHECK(len > 0 && len <= kReadBufSize);
       buf[len] = 0;  // already create a buffer with +1 length
       socket_delegate_->DidRead(this, buf, len);
     }
   } while (len == kReadBufSize);
 }
 
-void ListenSocket::CloseSocket(SOCKET s) {
-  if (s && s != kInvalidSocket) {
-    UnwatchSocket();
-#if defined(OS_WIN)
-    closesocket(s);
-#elif defined(OS_POSIX)
-    close(s);
-#endif
-  }
-}
-
 void ListenSocket::Close() {
 #if defined(OS_POSIX)
   if (wait_state_ == WAITING_CLOSE)
     return;
   wait_state_ = WAITING_CLOSE;
 #endif
   socket_delegate_->DidClose(this);
 }
 
-void ListenSocket::UnwatchSocket() {
+void ListenSocket::CloseSocket(SOCKET s) {
+  if (s && s != kInvalidSocket) {
+    UnwatchSocket();
 #if defined(OS_WIN)
-  watcher_.StopWatching();
+    closesocket(s);
 #elif defined(OS_POSIX)
-  watcher_.StopWatchingFileDescriptor();
+    close(s);
 #endif
+  }
 }
 
 void ListenSocket::WatchSocket(WaitState state) {
 #if defined(OS_WIN)
   WSAEventSelect(socket_, socket_event_, FD_ACCEPT | FD_CLOSE | FD_READ);
   watcher_.StartWatching(socket_event_, this);
 #elif defined(OS_POSIX)
   // Implicitly calls StartWatchingFileDescriptor().
   MessageLoopForIO::current()->WatchFileDescriptor(
       socket_, true, MessageLoopForIO::WATCH_READ, &watcher_, this);
   wait_state_ = state;
 #endif
 }
 
-void ListenSocket::SendInternal(const char* bytes, int len) {
-  char* send_buf = const_cast<char *>(bytes);
-  int len_left = len;
-  while (true) {
-    int sent = HANDLE_EINTR(send(socket_, send_buf, len_left, 0));
-    if (sent == len_left) {  // A shortcut to avoid extraneous checks.
-      break;
-    }
-    if (sent == kSocketError) {
+void ListenSocket::UnwatchSocket() {
 #if defined(OS_WIN)
-      if (WSAGetLastError() != WSAEWOULDBLOCK) {
-        LOG(ERROR) << "send failed: WSAGetLastError()==" << WSAGetLastError();
+  watcher_.StopWatching();
 #elif defined(OS_POSIX)
-      if (errno != EWOULDBLOCK && errno != EAGAIN) {
-        LOG(ERROR) << "send failed: errno==" << errno;
+  watcher_.StopWatchingFileDescriptor();
 #endif
-        break;
-      }
-      // Otherwise we would block, and now we have to wait for a retry.
-      // Fall through to PlatformThread::YieldCurrentThread()
-    } else {
-      // sent != len_left according to the shortcut above.
-      // Shift the buffer start and send the remainder after a short while.
-      send_buf += sent;
-      len_left -= sent;
-    }
-    base::PlatformThread::YieldCurrentThread();
-  }
-}
-
-void ListenSocket::Send(const char* bytes, int len, bool append_linefeed) {
-  SendInternal(bytes, len);
-  if (append_linefeed) {
-    SendInternal("\r\n", 2);
-  }
-}
-
-void ListenSocket::Send(const std::string& str, bool append_linefeed) {
-  Send(str.data(), static_cast<int>(str.length()), append_linefeed);
-}
-
-void ListenSocket::PauseReads() {
-  DCHECK(!reads_paused_);
-  reads_paused_ = true;
-}
-
-void ListenSocket::ResumeReads() {
-  DCHECK(reads_paused_);
-  reads_paused_ = false;
-  if (has_pending_reads_) {
-    has_pending_reads_ = false;
-    Read();
-  }
 }
 
 // TODO(ibrar): We can add these functions into OS dependent files
 #if defined(OS_WIN)
 // MessageLoop watcher callback
 void ListenSocket::OnObjectSignaled(HANDLE object) {
   WSANETWORKEVENTS ev;
   if (kSocketError == WSAEnumNetworkEvents(socket_, socket_event_, &ev)) {
     // TODO
     return;
@@ skipping 39 matching lines @@
   }
 }
 
 void ListenSocket::OnFileCanWriteWithoutBlocking(int fd) {
   // MessagePumpLibevent callback, we don't listen for write events
   // so we shouldn't ever reach here.
   NOTREACHED();
 }
 
 #endif