Add Socket::ReadIfReady()

net/socket/socket_posix.h

 // Copyright 2014 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 NET_SOCKET_SOCKET_POSIX_H_
 #define NET_SOCKET_SOCKET_POSIX_H_
 
 #include <memory>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/threading/thread_checker.h"
 #include "net/base/completion_callback.h"
 #include "net/base/net_export.h"
 #include "net/socket/socket_descriptor.h"
 
 namespace net {
 
 class IOBuffer;
 struct SockaddrStorage;
@@ skipping 29 matching lines @@
   bool IsConnected() const;
   bool IsConnectedAndIdle() const;
 
   // Multiple outstanding requests of the same type are not supported.
   // Full duplex mode (reading and writing at the same time) is supported.
   // On error which is not ERR_IO_PENDING, sets errno and returns a net error
   // code. On ERR_IO_PENDING, |callback| is called with a net error code, not
   // errno, though errno is set if read or write events happen with error.
   // TODO(byungchul): Need more robust way to pass system errno.
   int Read(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
+
+  // Reads as much data as possible into |buf| without blocking. If read is to
+  // be retried later, |callback| will be invoked when data is ready for
+  // reading.
+  // See socket.h for more information.
+  int ReadIfReady(IOBuffer* buf,
+                  int buf_len,
+                  const CompletionCallback& callback);
   int Write(IOBuffer* buf, int buf_len, const CompletionCallback& callback);
 
   // Waits for next write event. This is called by TCPSocketPosix for TCP
   // fastopen after sending first data. Returns ERR_IO_PENDING if it starts
   // waiting for write event successfully. Otherwise, returns a net error code.
   // It must not be called after Write() because Write() calls it internally.
   int WaitForWrite(IOBuffer* buf, int buf_len,
                    const CompletionCallback& callback);
 
   int GetLocalAddress(SockaddrStorage* address) const;
@@ skipping 16 matching lines @@
   void OnFileCanReadWithoutBlocking(int fd) override;
   void OnFileCanWriteWithoutBlocking(int fd) override;
 
   int DoAccept(std::unique_ptr<SocketPosix>* socket);
   void AcceptCompleted();
 
   int DoConnect();
   void ConnectCompleted();
 
   int DoRead(IOBuffer* buf, int buf_len);
+  void RetryRead(int rv);
   void ReadCompleted();
 
   int DoWrite(IOBuffer* buf, int buf_len);
   void WriteCompleted();
 
   void StopWatchingAndCleanUp();
 
   SocketDescriptor socket_fd_;
 
   base::MessageLoopForIO::FileDescriptorWatcher accept_socket_watcher_;
   std::unique_ptr<SocketPosix>* accept_socket_;
   CompletionCallback accept_callback_;
 
   base::MessageLoopForIO::FileDescriptorWatcher read_socket_watcher_;
+
+  // Non-null when a Read() is in progress.
   scoped_refptr<IOBuffer> read_buf_;
   int read_buf_len_;
-  // External callback; called when read is complete.
   CompletionCallback read_callback_;
 
+  // Non-null when a ReadIfReady() is in progress.
+  CompletionCallback read_if_ready_callback_;
+
   base::MessageLoopForIO::FileDescriptorWatcher write_socket_watcher_;
   scoped_refptr<IOBuffer> write_buf_;
   int write_buf_len_;
   // External callback; called when write or connect is complete.
   CompletionCallback write_callback_;
 
   // A connect operation is pending. In this case, |write_callback_| needs to be
   // called when connect is complete.
   bool waiting_connect_;
 
   std::unique_ptr<SockaddrStorage> peer_address_;
 
   base::ThreadChecker thread_checker_;
 
+  base::WeakPtrFactory<SocketPosix> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(SocketPosix);
 };
 
 }  // namespace net
 
 #endif  // NET_SOCKET_SOCKET_POSIX_H_