The MediatorThread worker thread needs to have a CertVerifier...

jingle/notifier/base/chrome_async_socket.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 "jingle/notifier/base/chrome_async_socket.h"
 
 #if defined(OS_WIN)
 #include <winsock2.h>
 #elif defined(OS_POSIX)
 #include <arpa/inet.h>
@@ skipping 15 matching lines @@
 #include "net/socket/client_socket_factory.h"
 #include "net/socket/ssl_client_socket.h"
 #include "net/socket/tcp_client_socket.h"
 #include "talk/base/socketaddress.h"
 
 namespace notifier {
 
 ChromeAsyncSocket::ChromeAsyncSocket(
     net::ClientSocketFactory* client_socket_factory,
     const net::SSLConfig& ssl_config,
+    net::CertVerifier* cert_verifier,
     size_t read_buf_size,
     size_t write_buf_size,
     net::NetLog* net_log)
     : connect_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                         &ChromeAsyncSocket::ProcessConnectDone),
       read_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                      &ChromeAsyncSocket::ProcessReadDone),
       write_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                      &ChromeAsyncSocket::ProcessWriteDone),
       ssl_connect_callback_(ALLOW_THIS_IN_INITIALIZER_LIST(this),
                             &ChromeAsyncSocket::ProcessSSLConnectDone),
       client_socket_factory_(client_socket_factory),
       ssl_config_(ssl_config),
+      cert_verifier_(cert_verifier),
       bound_net_log_(
           net::BoundNetLog::Make(net_log, net::NetLog::SOURCE_SOCKET)),
       state_(STATE_CLOSED),
       error_(ERROR_NONE),
       net_error_(net::OK),
       scoped_runnable_method_factory_(
           ALLOW_THIS_IN_INITIALIZER_LIST(this)),
       read_state_(IDLE),
       read_buf_(new net::IOBufferWithSize(read_buf_size)),
       read_start_(0U),
@@ skipping 372 matching lines @@
   DCHECK_EQ(write_end_, 0U);
 
   // Clear out any posted DoRead() tasks.
   scoped_runnable_method_factory_.RevokeAll();
 
   DCHECK(transport_socket_.get());
   transport_socket_.reset(
       client_socket_factory_->CreateSSLClientSocket(
           transport_socket_.release(), net::HostPortPair(domain_name, 443),
           ssl_config_, NULL /* ssl_host_info */,
-          NULL /* TODO(wtc): cert_verifier */));
+          cert_verifier_));
   int status = transport_socket_->Connect(&ssl_connect_callback_);
   if (status != net::ERR_IO_PENDING) {
     MessageLoop* message_loop = MessageLoop::current();
     CHECK(message_loop);
     message_loop->PostTask(
         FROM_HERE,
         scoped_runnable_method_factory_.NewRunnableMethod(
             &ChromeAsyncSocket::ProcessSSLConnectDone, status));
   }
   return true;
@@ skipping 18 matching lines @@
   }
   state_ = STATE_TLS_OPEN;
   PostDoRead();
   if (write_end_ > 0U) {
     PostDoWrite();
   }
   SignalSSLConnected();
 }
 
 }  // namespace notifier