Change MockRead and MockWrite (et. al.) to take an IoMode enum, instead

net/spdy/spdy_session_unittest.cc

 // Copyright (c) 2012 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/spdy/spdy_session.h"
 
 #include "net/base/ip_endpoint.h"
 #include "net/spdy/spdy_io_buffer.h"
 #include "net/spdy/spdy_session_pool.h"
 #include "net/spdy/spdy_stream.h"
@@ skipping 94 matching lines @@
 }
 
 TEST_F(SpdySessionTest, GoAway) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<spdy::SpdyFrame> goaway(ConstructSpdyGoAway());
   MockRead reads[] = {
     CreateMockRead(*goaway),
-    MockRead(false, 0, 0)  // EOF
+    MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   data.set_connect_data(connect_data);
   session_deps.socket_factory->AddSocketDataProvider(&data);
 
-  SSLSocketDataProvider ssl(false, OK);
+  SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> http_session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   const std::string kTestHost("www.foo.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
   HostPortProxyPair pair(test_host_port_pair, ProxyServer::Direct());
 
@@ skipping 33 matching lines @@
 
 TEST_F(SpdySessionTest, Ping) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<spdy::SpdyFrame> read_ping(ConstructSpdyPing());
   MockRead reads[] = {
     CreateMockRead(*read_ping),
     CreateMockRead(*read_ping),
-    MockRead(false, 0, 0)  // EOF
+    MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   scoped_ptr<spdy::SpdyFrame> write_ping(ConstructSpdyPing());
   MockRead writes[] = {
     CreateMockRead(*write_ping),
     CreateMockRead(*write_ping),
   };
   StaticSocketDataProvider data(
       reads, arraysize(reads), writes, arraysize(writes));
   data.set_connect_data(connect_data);
   session_deps.socket_factory->AddSocketDataProvider(&data);
 
-  SSLSocketDataProvider ssl(false, OK);
+  SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> http_session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   static const char kStreamUrl[] = "http://www.google.com/";
   GURL url(kStreamUrl);
 
   const std::string kTestHost("www.google.com");
   const int kTestPort = 80;
@@ skipping 57 matching lines @@
 }
 
 TEST_F(SpdySessionTest, FailedPing) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<spdy::SpdyFrame> read_ping(ConstructSpdyPing());
   MockRead reads[] = {
     CreateMockRead(*read_ping),
-    MockRead(false, 0, 0)  // EOF
+    MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
   scoped_ptr<spdy::SpdyFrame> write_ping(ConstructSpdyPing());
   MockRead writes[] = {
     CreateMockRead(*write_ping),
   };
   StaticSocketDataProvider data(
       reads, arraysize(reads), writes, arraysize(writes));
   data.set_connect_data(connect_data);
   session_deps.socket_factory->AddSocketDataProvider(&data);
 
-  SSLSocketDataProvider ssl(false, OK);
+  SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> http_session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   static const char kStreamUrl[] = "http://www.gmail.com/";
   GURL url(kStreamUrl);
 
   const std::string kTestHost("www.gmail.com");
   const int kTestPort = 80;
@@ skipping 212 matching lines @@
   const size_t max_concurrent_streams = 2;
   new_settings.push_back(spdy::SpdySetting(id, max_concurrent_streams));
 
   // Set up the socket so we read a SETTINGS frame that raises max concurrent
   // streams to 2.
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<spdy::SpdyFrame> settings_frame(
       ConstructSpdySettings(new_settings));
   MockRead reads[] = {
     CreateMockRead(*settings_frame),
-    MockRead(false, 0, 0)  // EOF
+    MockRead(SYNCHRONOUS, 0, 0)  // EOF
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   data.set_connect_data(connect_data);
   session_deps.socket_factory->AddSocketDataProvider(&data);
 
-  SSLSocketDataProvider ssl(false, OK);
+  SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> http_session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   const std::string kTestHost("www.foo.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
   HostPortProxyPair pair(test_host_port_pair, ProxyServer::Direct());
 
@@ skipping 52 matching lines @@
 
 // Start with max concurrent streams set to 1.  Request two streams.  When the
 // first completes, have the callback close itself, which should trigger the
 // second stream creation.  Then cancel that one immediately.  Don't crash.
 // http://crbug.com/63532
 TEST_F(SpdySessionTest, CancelPendingCreateStream) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   MockRead reads[] = {
-    MockRead(false, ERR_IO_PENDING)  // Stall forever.
+    MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   MockConnect connect_data(SYNCHRONOUS, OK);
 
   data.set_connect_data(connect_data);
   session_deps.socket_factory->AddSocketDataProvider(&data);
 
-  SSLSocketDataProvider ssl(false, OK);
+  SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> http_session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   const std::string kTestHost("www.foo.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
   HostPortProxyPair pair(test_host_port_pair, ProxyServer::Direct());
 
@@ skipping 56 matching lines @@
 
   // Should not crash when running the pending callback.
   MessageLoop::current()->RunAllPending();
 }
 
 TEST_F(SpdySessionTest, SendSettingsOnNewSession) {
   SpdySessionDependencies session_deps;
   session_deps.host_resolver->set_synchronous_mode(true);
 
   MockRead reads[] = {
-    MockRead(false, ERR_IO_PENDING)  // Stall forever.
+    MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
 
   // Create the bogus setting that we want to verify is sent out.
   // Note that it will be marked as SETTINGS_FLAG_PERSISTED when sent out.  But
   // to set it into the SpdySettingsStorage, we need to mark as
   // SETTINGS_FLAG_PLEASE_PERSIST.
   spdy::SpdySettings settings;
   const uint32 kBogusSettingId = 0xABAB;
   const uint32 kBogusSettingValue = 0xCDCD;
   spdy::SettingsFlagsAndId id(0);
   id.set_id(kBogusSettingId);
   id.set_flags(spdy::SETTINGS_FLAG_PERSISTED);
   settings.push_back(spdy::SpdySetting(id, kBogusSettingValue));
   MockConnect connect_data(SYNCHRONOUS, OK);
   scoped_ptr<spdy::SpdyFrame> settings_frame(
       ConstructSpdySettings(settings));
   MockWrite writes[] = {
     CreateMockWrite(*settings_frame),
   };
 
   StaticSocketDataProvider data(
       reads, arraysize(reads), writes, arraysize(writes));
   data.set_connect_data(connect_data);
   session_deps.socket_factory->AddSocketDataProvider(&data);
 
-  SSLSocketDataProvider ssl(false, OK);
+  SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> http_session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   const std::string kTestHost("www.foo.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
   HostPortProxyPair pair(test_host_port_pair, ProxyServer::Direct());
 
@@ skipping 53 matching lines @@
         info, &test_hosts[i].addresses, CompletionCallback(), NULL,
         BoundNetLog());
 
     // Setup a HostPortProxyPair
     test_hosts[i].pair = HostPortProxyPair(
         HostPortPair(test_hosts[i].name, kTestPort), ProxyServer::Direct());
   }
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
-    MockRead(false, ERR_IO_PENDING)  // Stall forever.
+    MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
 
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   data.set_connect_data(connect_data);
   session_deps.socket_factory->AddSocketDataProvider(&data);
 
-  SSLSocketDataProvider ssl(false, OK);
+  SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> http_session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   // Setup the first session to the first host.
   SpdySessionPool* spdy_session_pool(http_session->spdy_session_pool());
   EXPECT_FALSE(spdy_session_pool->HasSession(test_hosts[0].pair));
   scoped_refptr<SpdySession> session =
       spdy_session_pool->Get(test_hosts[0].pair, BoundNetLog());
@@ skipping 112 matching lines @@
   spdy_session_pool->OnIPAddressChanged();
   EXPECT_EQ(0u, test_http_server_properties->GetSpdySettings(
       test_host_port_pair).size());
 }
 
 TEST_F(SpdySessionTest, NeedsCredentials) {
   SpdySessionDependencies session_deps;
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
-    MockRead(false, ERR_IO_PENDING)  // Stall forever.
+    MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
   StaticSocketDataProvider data(reads, arraysize(reads), NULL, 0);
   data.set_connect_data(connect_data);
   session_deps.socket_factory->AddSocketDataProvider(&data);
 
-  SSLSocketDataProvider ssl(false, OK);
+  SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   ssl.origin_bound_cert_type = CLIENT_CERT_RSA_SIGN;
   ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY3;
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> http_session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   const std::string kTestHost("www.foo.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
@@ skipping 41 matching lines @@
 
   spdy_session_pool->Remove(session);
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
 }
 
 TEST_F(SpdySessionTest, SendCredentials) {
   SpdySessionDependencies session_deps;
 
   MockConnect connect_data(SYNCHRONOUS, OK);
   MockRead reads[] = {
-    MockRead(false, ERR_IO_PENDING)  // Stall forever.
+    MockRead(SYNCHRONOUS, ERR_IO_PENDING)  // Stall forever.
   };
   spdy::SpdySettings settings;
   scoped_ptr<spdy::SpdyFrame> settings_frame(
       ConstructSpdySettings(settings));
   MockWrite writes[] = {
     CreateMockWrite(*settings_frame),
   };
   StaticSocketDataProvider data(reads, arraysize(reads),
                                 writes, arraysize(writes));
   data.set_connect_data(connect_data);
   session_deps.socket_factory->AddSocketDataProvider(&data);
 
-  SSLSocketDataProvider ssl(false, OK);
+  SSLSocketDataProvider ssl(SYNCHRONOUS, OK);
   ssl.origin_bound_cert_type = CLIENT_CERT_RSA_SIGN;
   ssl.protocol_negotiated = SSLClientSocket::kProtoSPDY3;
   session_deps.socket_factory->AddSSLSocketDataProvider(&ssl);
 
   scoped_refptr<HttpNetworkSession> http_session(
       SpdySessionDependencies::SpdyCreateSession(&session_deps));
 
   const std::string kTestHost("www.foo.com");
   const int kTestPort = 80;
   HostPortPair test_host_port_pair(kTestHost, kTestPort);
@@ skipping 37 matching lines @@
   EXPECT_TRUE(session->NeedsCredentials(test_host_port_pair2));
 
   // Flush the SpdySession::OnReadComplete() task.
   MessageLoop::current()->RunAllPending();
 
   spdy_session_pool->Remove(session);
   EXPECT_FALSE(spdy_session_pool->HasSession(pair));
 }
 
 }  // namespace net