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

jingle/notifier/listener/mediator_thread_impl.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/listener/mediator_thread_impl.h"
 
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "jingle/notifier/base/task_pump.h"
 #include "jingle/notifier/communicator/connection_options.h"
 #include "jingle/notifier/communicator/const_communicator.h"
 #include "jingle/notifier/communicator/xmpp_connection_generator.h"
 #include "jingle/notifier/listener/listen_task.h"
 #include "jingle/notifier/listener/send_update_task.h"
 #include "jingle/notifier/listener/subscribe_task.h"
+#include "net/base/cert_verifier.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/host_resolver.h"
 #include "talk/xmpp/xmppclientsettings.h"
 
 namespace notifier {
 
 MediatorThreadImpl::MediatorThreadImpl(const NotifierOptions& notifier_options)
     : observers_(new ObserverListThreadSafe<Observer>()),
       parent_message_loop_(MessageLoop::current()),
       notifier_options_(notifier_options),
@@ skipping 85 matching lines @@
 
 void MediatorThreadImpl::DoLogin(
     const buzz::XmppClientSettings& settings) {
   DCHECK_EQ(MessageLoop::current(), worker_message_loop());
   VLOG(1) << "P2P: Thread logging into talk network.";
 
   base_task_.reset();
 
   // TODO(akalin): Use an existing HostResolver from somewhere (maybe
   // the IOThread one).
+  // TODO(wtc): Sharing HostResolver and CertVerifier with the IO Thread won't
+  // work because HostResolver and CertVerifier are single-threaded.
   host_resolver_.reset(
       net::CreateSystemHostResolver(net::HostResolver::kDefaultParallelism,
                                     NULL, NULL));
+  cert_verifier_.reset(new net::CertVerifier);
 
   notifier::ServerInformation server_list[2];
   int server_list_count = 0;
 
   // Override the default servers with a test notification server if one was
   // provided.
-  if(!notifier_options_.xmpp_host_port.host().empty()) {
+  if (!notifier_options_.xmpp_host_port.host().empty()) {
     server_list[0].server = notifier_options_.xmpp_host_port;
     server_list[0].special_port_magic = false;
     server_list_count = 1;
   } else {
     // The default servers know how to serve over port 443 (that's the magic).
     server_list[0].server = net::HostPortPair("talk.google.com",
                                               notifier::kDefaultXmppPort);
     server_list[0].special_port_magic = true;
     server_list[1].server = net::HostPortPair("talkx.l.google.com",
                                               notifier::kDefaultXmppPort);
     server_list[1].special_port_magic = true;
     server_list_count = 2;
   }
 
   // Autodetect proxy is on by default.
   notifier::ConnectionOptions options;
 
   login_.reset(new notifier::Login(this,
                                    settings,
                                    options,
                                    host_resolver_.get(),
+                                   cert_verifier_.get(),
                                    server_list,
                                    server_list_count,
                                    notifier_options_.try_ssltcp_first));
   login_->StartConnection();
 }
 
 void MediatorThreadImpl::DoDisconnect() {
   DCHECK_EQ(MessageLoop::current(), worker_message_loop());
   VLOG(1) << "P2P: Thread logging out of talk network.";
   login_.reset();
+  cert_verifier_.reset();
   host_resolver_.reset();
   base_task_.reset();
 }
 
 void MediatorThreadImpl::DoSubscribeForUpdates(
     const std::vector<std::string>& subscribed_services_list) {
   DCHECK_EQ(MessageLoop::current(), worker_message_loop());
   if (!base_task_.get()) {
     return;
   }
@@ skipping 57 matching lines @@
   base_task_.reset();
   observers_->Notify(&Observer::OnConnectionStateChange, false);
 }
 
 void MediatorThreadImpl::OnSubscriptionStateChange(bool success) {
   DCHECK_EQ(MessageLoop::current(), worker_message_loop());
   observers_->Notify(&Observer::OnSubscriptionStateChange, success);
 }
 
 }  // namespace notifier