Fixed some minor bugs with ChromeAsyncSocket.

chrome/browser/sync/tools/chrome_async_socket_unittest.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 "chrome/browser/sync/tools/chrome_async_socket.h"
 
 #include <deque>
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 79 matching lines @@
 
   std::deque<net::MockWrite> writes_;
 
   DISALLOW_COPY_AND_ASSIGN(AsyncSocketDataProvider);
 };
 
 class ChromeAsyncSocketTest
     : public testing::Test,
       public sigslot::has_slots<> {
  protected:
-  // TODO(akalin): test SSL states other than connection success.
   ChromeAsyncSocketTest()
       : ssl_socket_data_provider_(true, net::OK),
         capturing_net_log_(net::CapturingNetLog::kUnbounded),
         chrome_async_socket_(&mock_client_socket_factory_,
                              ssl_config_, 14, 20, &capturing_net_log_),
         addr_(0xaabbccdd, 35) {}
 
   virtual ~ChromeAsyncSocketTest() {}
 
   virtual void SetUp() {
@@ skipping 411 matching lines @@
   char buf[4096];
   size_t len_read = 10000;
   EXPECT_TRUE(chrome_async_socket_.Read(buf, sizeof(buf), &len_read));
   EXPECT_EQ(0, len_read);
 
   DoCloseOpenedNoError();
 }
 
 TEST_F(ChromeAsyncSocketTest, WrongRead) {
   EXPECT_DEBUG_DEATH({
+    async_socket_data_provider_.set_connect_data(
+        net::MockConnect(true, net::OK));
+    EXPECT_TRUE(chrome_async_socket_.Connect(addr_));
+    ExpectNonErrorState(ChromeAsyncSocket::STATE_CONNECTING);
+    ExpectNoSignal();
+
     char buf[4096];
     size_t len_read;
     EXPECT_FALSE(chrome_async_socket_.Read(buf, sizeof(buf), &len_read));
     ExpectErrorState(ChromeAsyncSocket::STATE_CLOSED,
                      ChromeAsyncSocket::ERROR_WRONGSTATE);
     EXPECT_TRUE(chrome_async_socket_.Close());
   }, "non-open");
 }
 
+TEST_F(ChromeAsyncSocketTest, WrongReadClosed) {
+  char buf[4096];
+  size_t len_read;
+  EXPECT_FALSE(chrome_async_socket_.Read(buf, sizeof(buf), &len_read));
+  ExpectErrorState(ChromeAsyncSocket::STATE_CLOSED,
+                   ChromeAsyncSocket::ERROR_WRONGSTATE);
+  EXPECT_TRUE(chrome_async_socket_.Close());
+}
+
 const char kReadData[] = "mydatatoread";
 
 TEST_F(ChromeAsyncSocketTest, Read) {
   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
   DoOpenClosed();
 
   ExpectReadSignal();
   ExpectNoSignal();
 
   EXPECT_EQ(kReadData, DrainRead(1));
@@ skipping 265 matching lines @@
     EXPECT_FALSE(chrome_async_socket_.StartTls("fakedomain.com"));
 
     DoSSLCloseOpened(
         SignalSocketState(SIGNAL_CLOSE,
                           ChromeAsyncSocket::STATE_CLOSED,
                           ChromeAsyncSocket::ERROR_WRONGSTATE,
                           net::OK));
   }, "wrong state");
 }
 
+TEST_F(ChromeAsyncSocketTest, FailedSSLConnect) {
+  ssl_socket_data_provider_.connect =
+      net::MockConnect(true, net::ERR_CERT_COMMON_NAME_INVALID),
+
+  async_socket_data_provider_.AddRead(net::MockRead(kReadData));
+  DoOpenClosed();
+  ExpectReadSignal();
+
+  EXPECT_TRUE(chrome_async_socket_.StartTls("fakedomain.com"));
+  message_loop_.RunAllPending();
+  ExpectSignalSocketState(
+      SignalSocketState(
+          SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED,
+          ChromeAsyncSocket::ERROR_WINSOCK,
+          net::ERR_CERT_COMMON_NAME_INVALID));
+
+  EXPECT_TRUE(chrome_async_socket_.Close());
+  ExpectClosed();
+}
+
 TEST_F(ChromeAsyncSocketTest, ReadDuringSSLConnecting) {
   async_socket_data_provider_.AddRead(net::MockRead(kReadData));
   DoOpenClosed();
   ExpectReadSignal();
   EXPECT_EQ(kReadData, DrainRead(1));
 
   EXPECT_TRUE(chrome_async_socket_.StartTls("fakedomain.com"));
   ExpectNoSignal();
 
   // Shouldn't do anything.
@@ skipping 136 matching lines @@
   message_loop_.RunAllPending();
 
   ExpectNoSignal();
 
   DoSSLCloseOpenedNoError();
 }
 
 }  // namespace
 
 }  // namespace sync_tools