Changed the jingle network code in ChromeAsyncSocket to use the client socket pool. This also all...

jingle/notifier/base/chrome_async_socket_unittest.cc

 // Copyright (c) 2011 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 "jingle/notifier/base/chrome_async_socket.h"
 
 #include <deque>
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 #include "net/base/capturing_net_log.h"
-#include "net/base/cert_verifier.h"
 #include "net/base/net_errors.h"
 #include "net/base/ssl_config_service.h"
 #include "net/socket/socket_test_util.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "net/url_request/url_request_test_util.h"
 #include "talk/base/sigslot.h"
 #include "talk/base/socketaddress.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace notifier {
 
 namespace {
 
+// Used to return a dummy context.
+class TestURLRequestContextGetter : public net::URLRequestContextGetter {
+ public:
+  TestURLRequestContextGetter()
+      : message_loop_proxy_(base::MessageLoopProxy::CreateForCurrentThread()) {
+  }
+  virtual ~TestURLRequestContextGetter() { }
+
+  // net::URLRequestContextGetter:
+  virtual net::URLRequestContext* GetURLRequestContext() {
+    if (!context_)
+      context_ = new TestURLRequestContext();
+    return context_.get();
+  }
+  virtual scoped_refptr<base::MessageLoopProxy> GetIOMessageLoopProxy() const {
+    return message_loop_proxy_;
+  }
+
+ private:
+  scoped_refptr<net::URLRequestContext> context_;
+  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
+};
+
 // Data provider that handles reads/writes for ChromeAsyncSocket.
 class AsyncSocketDataProvider : public net::SocketDataProvider {
  public:
   AsyncSocketDataProvider() : has_pending_read_(false) {}
 
   virtual ~AsyncSocketDataProvider() {
     EXPECT_TRUE(writes_.empty());
     EXPECT_TRUE(reads_.empty());
   }
 
@@ skipping 58 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(AsyncSocketDataProvider);
 };
 
 class ChromeAsyncSocketTest
     : public testing::Test,
       public sigslot::has_slots<> {
  protected:
   ChromeAsyncSocketTest()
       : ssl_socket_data_provider_(true, net::OK),
         capturing_net_log_(net::CapturingNetLog::kUnbounded),
+        url_request_context_getter_(new TestURLRequestContextGetter()),
         addr_(0xaabbccdd, 35) {}
 
   virtual ~ChromeAsyncSocketTest() {}
 
   virtual void SetUp() {
     scoped_ptr<net::MockClientSocketFactory> mock_client_socket_factory(
         new net::MockClientSocketFactory());
     mock_client_socket_factory->AddSocketDataProvider(
         &async_socket_data_provider_);
     mock_client_socket_factory->AddSSLSocketDataProvider(
         &ssl_socket_data_provider_);
 
     chrome_async_socket_.reset(
-        new ChromeAsyncSocket(mock_client_socket_factory.release(),
-                              ssl_config_, &cert_verifier_, 14, 20,
-                              &capturing_net_log_)),
-
+        new ChromeAsyncSocket(ssl_config_, url_request_context_getter_, false,
+                              14, 20,
+                              &capturing_net_log_));
+    chrome_async_socket_->set_client_socket_factory(
+        mock_client_socket_factory.release());
     chrome_async_socket_->SignalConnected.connect(
         this, &ChromeAsyncSocketTest::OnConnect);
     chrome_async_socket_->SignalSSLConnected.connect(
         this, &ChromeAsyncSocketTest::OnSSLConnect);
     chrome_async_socket_->SignalClosed.connect(
         this, &ChromeAsyncSocketTest::OnClose);
     chrome_async_socket_->SignalRead.connect(
         this, &ChromeAsyncSocketTest::OnRead);
     chrome_async_socket_->SignalError.connect(
         this, &ChromeAsyncSocketTest::OnError);
@@ skipping 234 matching lines @@
   }
 
   // ChromeAsyncSocket expects a message loop.
   MessageLoop message_loop_;
 
   AsyncSocketDataProvider async_socket_data_provider_;
   net::SSLSocketDataProvider ssl_socket_data_provider_;
 
   net::CapturingNetLog capturing_net_log_;
   net::SSLConfig ssl_config_;
-  net::CertVerifier cert_verifier_;
+  scoped_refptr<TestURLRequestContextGetter> url_request_context_getter_;
   scoped_ptr<ChromeAsyncSocket> chrome_async_socket_;
   std::deque<SignalSocketState> signal_socket_states_;
   const talk_base::SocketAddress addr_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ChromeAsyncSocketTest);
 };
 
 TEST_F(ChromeAsyncSocketTest, InitialState) {
   ExpectClosed();
@@ skipping 23 matching lines @@
   EXPECT_TRUE(chrome_async_socket_->Close());
   ExpectClosed();
   ExpectSignalSocketState(
       SignalSocketState::NoError(
           SIGNAL_CLOSE, ChromeAsyncSocket::STATE_CLOSED));
 
   EXPECT_TRUE(chrome_async_socket_->Close());
   ExpectClosed();
 }
 
-TEST_F(ChromeAsyncSocketTest, UnresolvedConnect) {
-  const talk_base::SocketAddress unresolved_addr(0, 0);
-  EXPECT_FALSE(chrome_async_socket_->Connect(unresolved_addr));
-  ExpectErrorState(ChromeAsyncSocket::STATE_CLOSED,
-                   ChromeAsyncSocket::ERROR_DNS);
-
-  EXPECT_TRUE(chrome_async_socket_->Close());
-  ExpectClosed();
-}
-
 TEST_F(ChromeAsyncSocketTest, DoubleConnect) {
   EXPECT_DEBUG_DEATH({
     DoOpenClosed();
 
     EXPECT_FALSE(chrome_async_socket_->Connect(addr_));
     ExpectErrorState(ChromeAsyncSocket::STATE_OPEN,
                      ChromeAsyncSocket::ERROR_WRONGSTATE);
 
     DoCloseOpened(
         SignalSocketState(SIGNAL_CLOSE,
@@ skipping 574 matching lines @@
   message_loop_.RunAllPending();
 
   ExpectNoSignal();
 
   DoSSLCloseOpenedNoError();
 }
 
 }  // namespace
 
 }  // namespace notifier