Add Socket::ReadIfReady()

net/socket/socket_bio_adapter_unittest.cc

Index: net/socket/socket_bio_adapter_unittest.cc
diff --git a/net/socket/socket_bio_adapter_unittest.cc b/net/socket/socket_bio_adapter_unittest.cc
index 09d9a97091f65c75b6a39eee524b7aeb439c9093..a4545b8a278ceecdf5685b3b2067649bfd70bfda 100644
--- a/net/socket/socket_bio_adapter_unittest.cc
+++ b/net/socket/socket_bio_adapter_unittest.cc
@@ -12,7 +12,9 @@
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
+#include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
+#include "base/test/mock_entropy_provider.h"
 #include "crypto/openssl_util.h"
 #include "net/base/address_list.h"
 #include "net/base/net_errors.h"
@@ -27,9 +29,31 @@
 
 namespace net {
 
-class SocketBIOAdapterTest : public testing::Test,
-                             public SocketBIOAdapter::Delegate {
+enum ReadIfReadySupport {

[davidben, 2017/02/01 22:25:57]

Thanks for being thorough with testing this!

[xunjieli, 2017/02/03 16:35:33]

:)

+  // ReadIfReady() field trial is enabled, but ReadyIfReady() is unimplemented.
+  READ_IF_READY_ENABLED_SUPPORTED,
+  // ReadIfReady() field trial is enabled, and ReadyIfReady() is implemented.
+  READ_IF_READY_ENABLED_NOT_SUPPORTED,
+  // ReadIfReady() field trial is disabled.
+  READ_IF_READY_DISABLED,
+};
+
+class SocketBIOAdapterTest
+    : public testing::Test,
+      public testing::WithParamInterface<ReadIfReadySupport>,

[davidben, 2017/02/01 22:25:57]

I think you can replace this and the line above with
testing::TestWithParam<ReadIfReadySupport>. (Or do we prefer this setup in
Chromium? I could be out-of-date on style.)

[xunjieli, 2017/02/03 16:35:33]

Done. Thanks! I thought there was one class for this purpose but couldn't find
it. 

+      public SocketBIOAdapter::Delegate {
  protected:
+  void SetUp() override {
+    if (GetParam() != READ_IF_READY_DISABLED) {
+      field_trial_list_.reset(new base::FieldTrialList(
+          base::MakeUnique<base::MockEntropyProvider>()));
+      base::FieldTrialList::CreateFieldTrial(Socket::kReadIfReadyTrialName,
+                                             "enable");
+    }
+    if (GetParam() == READ_IF_READY_ENABLED_SUPPORTED)
+      factory_.set_enable_read_if_ready(true);
+  }
+
   std::unique_ptr<StreamSocket> MakeTestSocket(SocketDataProvider* data) {
     data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
     factory_.AddSocketDataProvider(data);
@@ -122,12 +146,14 @@ class SocketBIOAdapterTest : public testing::Test,
   }
 
   // SocketBIOAdapter::Delegate implementation:
-  void OnReadReady() override {
+  void OnReadReady(int rv) override {
+    DCHECK_GE(OK, rv);

[davidben, 2017/02/01 22:25:57]

Nit: EXPECT. Ditto below.

[xunjieli, 2017/02/03 16:35:33]

Done.

     EXPECT_TRUE(expect_read_ready_);
     expect_read_ready_ = false;
   }
 
-  void OnWriteReady() override {
+  void OnWriteReady(int rv) override {
+    DCHECK_GE(OK, rv);
     EXPECT_TRUE(expect_write_ready_);
     expect_write_ready_ = false;
     if (reset_on_write_ready_)
@@ -139,10 +165,17 @@ class SocketBIOAdapterTest : public testing::Test,
   bool expect_write_ready_ = false;
   MockClientSocketFactory factory_;
   std::unique_ptr<SocketBIOAdapter>* reset_on_write_ready_ = nullptr;
+  std::unique_ptr<base::FieldTrialList> field_trial_list_;
 };
 
+INSTANTIATE_TEST_CASE_P(/* no prefix */,
+                        SocketBIOAdapterTest,
+                        testing::Values(READ_IF_READY_ENABLED_SUPPORTED,
+                                        READ_IF_READY_ENABLED_NOT_SUPPORTED,
+                                        READ_IF_READY_DISABLED));
+
 // Test that data can be read synchronously.
-TEST_F(SocketBIOAdapterTest, ReadSync) {
+TEST_P(SocketBIOAdapterTest, ReadSync) {
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   MockRead reads[] = {
@@ -183,7 +216,7 @@ TEST_F(SocketBIOAdapterTest, ReadSync) {
 }
 
 // Test that data can be read asynchronously.
-TEST_F(SocketBIOAdapterTest, ReadAsync) {
+TEST_P(SocketBIOAdapterTest, ReadAsync) {
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   MockRead reads[] = {
@@ -203,9 +236,13 @@ TEST_F(SocketBIOAdapterTest, ReadAsync) {
   ExpectBlockingRead(bio, buf, sizeof(buf));
   EXPECT_FALSE(adapter->HasPendingReadData());
 
-  // After waiting, the data is available.
+  // After waiting, the data is available if Read() is used.
   WaitForReadReady();
-  EXPECT_TRUE(adapter->HasPendingReadData());
+  if (GetParam() == READ_IF_READY_ENABLED_SUPPORTED) {
+    EXPECT_FALSE(adapter->HasPendingReadData());
+  } else {
+    EXPECT_TRUE(adapter->HasPendingReadData());
+  }
 
   // The first read is now available synchronously.
   EXPECT_EQ(5, BIO_read(bio, buf, sizeof(buf)));
@@ -220,8 +257,14 @@ TEST_F(SocketBIOAdapterTest, ReadAsync) {
   // amount.
   ExpectBlockingRead(bio, buf, 1);
   EXPECT_FALSE(adapter->HasPendingReadData());
+
+  // After waiting, the data is available if Read() is used.
   WaitForReadReady();
-  EXPECT_TRUE(adapter->HasPendingReadData());
+  if (GetParam() == READ_IF_READY_ENABLED_SUPPORTED) {
+    EXPECT_FALSE(adapter->HasPendingReadData());
+  } else {
+    EXPECT_TRUE(adapter->HasPendingReadData());
+  }
 
   // The next read is now available synchronously.
   EXPECT_EQ(5, BIO_read(bio, buf, sizeof(buf)));
@@ -237,7 +280,7 @@ TEST_F(SocketBIOAdapterTest, ReadAsync) {
 }
 
 // Test that synchronous EOF is mapped to ERR_CONNECTION_CLOSED.
-TEST_F(SocketBIOAdapterTest, ReadEOFSync) {
+TEST_P(SocketBIOAdapterTest, ReadEOFSync) {
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   MockRead reads[] = {
@@ -253,7 +296,7 @@ TEST_F(SocketBIOAdapterTest, ReadEOFSync) {
 }
 
 // Test that asynchronous EOF is mapped to ERR_CONNECTION_CLOSED.
-TEST_F(SocketBIOAdapterTest, ReadEOFAsync) {
+TEST_P(SocketBIOAdapterTest, ReadEOFAsync) {
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   MockRead reads[] = {
@@ -272,7 +315,7 @@ TEST_F(SocketBIOAdapterTest, ReadEOFAsync) {
 }
 
 // Test that data can be written synchronously.
-TEST_F(SocketBIOAdapterTest, WriteSync) {
+TEST_P(SocketBIOAdapterTest, WriteSync) {
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   MockWrite writes[] = {
@@ -307,7 +350,7 @@ TEST_F(SocketBIOAdapterTest, WriteSync) {
 }
 
 // Test that data can be written asynchronously.
-TEST_F(SocketBIOAdapterTest, WriteAsync) {
+TEST_P(SocketBIOAdapterTest, WriteAsync) {
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   MockWrite writes[] = {
@@ -436,7 +479,7 @@ TEST_F(SocketBIOAdapterTest, WriteAsync) {
 
 // Test that a failed socket write is reported through BIO_read and prevents it
 // from scheduling a socket read. See https://crbug.com/249848.
-TEST_F(SocketBIOAdapterTest, WriteStopsRead) {
+TEST_P(SocketBIOAdapterTest, WriteStopsRead) {
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   MockWrite writes[] = {
@@ -459,7 +502,7 @@ TEST_F(SocketBIOAdapterTest, WriteStopsRead) {
 
 // Test that a synchronous failed socket write interrupts a blocked
 // BIO_read. See https://crbug.com/249848.
-TEST_F(SocketBIOAdapterTest, SyncWriteInterruptsRead) {
+TEST_P(SocketBIOAdapterTest, SyncWriteInterruptsRead) {
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   MockRead reads[] = {
@@ -492,7 +535,7 @@ TEST_F(SocketBIOAdapterTest, SyncWriteInterruptsRead) {
 
 // Test that an asynchronous failed socket write interrupts a blocked
 // BIO_read. See https://crbug.com/249848.
-TEST_F(SocketBIOAdapterTest, AsyncWriteInterruptsRead) {
+TEST_P(SocketBIOAdapterTest, AsyncWriteInterruptsRead) {
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   MockRead reads[] = {
@@ -527,7 +570,7 @@ TEST_F(SocketBIOAdapterTest, AsyncWriteInterruptsRead) {
 
 // Test that an asynchronous failed socket write interrupts a blocked BIO_read,
 // signaling both if the buffer was full. See https://crbug.com/249848.
-TEST_F(SocketBIOAdapterTest, AsyncWriteInterruptsBoth) {
+TEST_P(SocketBIOAdapterTest, AsyncWriteInterruptsBoth) {
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   MockRead reads[] = {
@@ -562,7 +605,7 @@ TEST_F(SocketBIOAdapterTest, AsyncWriteInterruptsBoth) {
 
 // Test that SocketBIOAdapter handles OnWriteReady deleting itself when both
 // need to be signaled.
-TEST_F(SocketBIOAdapterTest, DeleteOnWriteReady) {
+TEST_P(SocketBIOAdapterTest, DeleteOnWriteReady) {
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   MockRead reads[] = {
@@ -595,7 +638,7 @@ TEST_F(SocketBIOAdapterTest, DeleteOnWriteReady) {
 
 // Test that using a BIO after the underlying adapter is destroyed fails
 // gracefully.
-TEST_F(SocketBIOAdapterTest, Detached) {
+TEST_P(SocketBIOAdapterTest, Detached) {
   crypto::OpenSSLErrStackTracer tracer(FROM_HERE);
 
   SequencedSocketData data(nullptr, 0, nullptr, 0);