Add Socket::ReadIfReady()

net/socket/tcp_client_socket.cc

 // Copyright (c) 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.
 
 #include "net/socket/tcp_client_socket.h"
 
 #include <utility>
 
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 82 matching lines @@
   int rv = DoConnectLoop(OK);
   if (rv == ERR_IO_PENDING) {
     connect_callback_ = callback;
   } else {
     socket_->EndLoggingMultipleConnectAttempts(rv);
   }
 
   return rv;
 }
 
+int TCPClientSocket::ReadCommon(IOBuffer* buf,
+                                int buf_len,
+                                const CompletionCallback& callback,
+                                bool read_if_ready) {
+  DCHECK(!callback.is_null());
+
+  // |socket_| is owned by |this| and the callback won't be run once |socket_|
+  // is gone/closed. Therefore, it is safe to use base::Unretained() here.
+  CompletionCallback read_callback = base::Bind(
+      &TCPClientSocket::DidCompleteRead, base::Unretained(this), callback);
+  int result = read_if_ready ? socket_->ReadIfReady(buf, buf_len, read_callback)
+                             : socket_->Read(buf, buf_len, read_callback);
+  if (result > 0) {
+    use_history_.set_was_used_to_convey_data();
+    total_received_bytes_ += result;
+  }
+
+  return result;
+}
+
 int TCPClientSocket::DoConnectLoop(int result) {
   DCHECK_NE(next_connect_state_, CONNECT_STATE_NONE);
 
   int rv = result;
   do {
     ConnectState state = next_connect_state_;
     next_connect_state_ = CONNECT_STATE_NONE;
     switch (state) {
       case CONNECT_STATE_CONNECT:
         DCHECK_EQ(OK, rv);
@@ skipping 152 matching lines @@
   return kProtoUnknown;
 }
 
 bool TCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
   return false;
 }
 
 int TCPClientSocket::Read(IOBuffer* buf,
                           int buf_len,
                           const CompletionCallback& callback) {
-  DCHECK(!callback.is_null());
+  return ReadCommon(buf, buf_len, callback, /*read_if_ready=*/false);
+}
 
-  // |socket_| is owned by this class and the callback won't be run once
-  // |socket_| is gone. Therefore, it is safe to use base::Unretained() here.
-  CompletionCallback read_callback = base::Bind(
-      &TCPClientSocket::DidCompleteRead, base::Unretained(this), callback);
-  int result = socket_->Read(buf, buf_len, read_callback);
-  if (result > 0) {
-    use_history_.set_was_used_to_convey_data();
-    total_received_bytes_ += result;
-  }
-
-  return result;
+int TCPClientSocket::ReadIfReady(IOBuffer* buf,
+                                 int buf_len,
+                                 const CompletionCallback& callback) {
+  return ReadCommon(buf, buf_len, callback, /*read_if_ready=*/true);
 }
 
 int TCPClientSocket::Write(IOBuffer* buf,
                            int buf_len,
                            const CompletionCallback& callback) {
   DCHECK(!callback.is_null());
 
   // |socket_| is owned by this class and the callback won't be run once
   // |socket_| is gone. Therefore, it is safe to use base::Unretained() here.
   CompletionCallback write_callback = base::Bind(
@@ skipping 91 matching lines @@
 void TCPClientSocket::EmitTCPMetricsHistogramsOnDisconnect() {
   base::TimeDelta rtt;
   if (socket_->GetEstimatedRoundTripTime(&rtt)) {
     UMA_HISTOGRAM_CUSTOM_TIMES("Net.TcpRtt.AtDisconnect", rtt,
                                base::TimeDelta::FromMilliseconds(1),
                                base::TimeDelta::FromMinutes(10), 100);
   }
 }
 
 }  // namespace net