Integrating the QuicStreamFactory into the network stack.

net/quic/quic_stream_factory.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/quic/quic_stream_factory.h"
 
 #include <set>
 
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 138 matching lines @@
   io_state_ = STATE_CONNECT;
   return OK;
 }
 
 QuicStreamRequest::QuicStreamRequest(QuicStreamFactory* factory)
     : factory_(factory),
       stream_(NULL){
 }
 
 QuicStreamRequest::~QuicStreamRequest() {
-  if (factory_)
+  if (factory_ && !callback_.is_null())
     factory_->CancelRequest(this);
 }
 
 int QuicStreamRequest::Request(
     const HostPortProxyPair& host_port_proxy_pair,
     const BoundNetLog& net_log,
     const CompletionCallback& callback) {
   DCHECK(!stream_);
   DCHECK(callback_.is_null());
   int rv = factory_->Create(host_port_proxy_pair, net_log, this);
@@ skipping 39 matching lines @@
   DCHECK(!factory_->HasActiveSession(host_port_proxy_pair_));
   factory_->ActivateSession(host_port_proxy_pair_, session_);
 
   return OK;
 }
 
 QuicStreamFactory::QuicStreamFactory(
     HostResolver* host_resolver,
     ClientSocketFactory* client_socket_factory,
     const RandomUint64Callback& random_uint64_callback,
-    const QuicClock* clock)
+    QuicClock* clock)
     : host_resolver_(host_resolver),
       client_socket_factory_(client_socket_factory),
       random_uint64_callback_(random_uint64_callback),
       clock_(clock),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {
 }
 
 QuicStreamFactory::~QuicStreamFactory() {
   STLDeleteElements(&all_sessions_);
   STLDeleteValues(&active_jobs_);
@@ skipping 105 matching lines @@
   IPEndPoint addr = *address_list_.begin();
   DatagramClientSocket* socket =
       client_socket_factory_->CreateDatagramClientSocket(
           DatagramSocket::DEFAULT_BIND, base::Bind(&base::RandInt),
           net_log.net_log(), net_log.source());
   socket->Connect(addr);
   socket->GetLocalAddress(&addr);
 
   QuicConnectionHelper* helper = new QuicConnectionHelper(
       MessageLoop::current()->message_loop_proxy(),
-      clock_, socket);
+      clock_.get(), socket);
 
   QuicConnection* connection = new QuicConnection(guid, addr, helper);
   QuicClientSession* session = new QuicClientSession(connection, helper, this);
   all_sessions_.insert(session);  // owning pointer
   return session;
 }
 
 bool QuicStreamFactory::HasActiveJob(
     const HostPortProxyPair& host_port_proxy_pair) {
   return ContainsKey(active_jobs_, host_port_proxy_pair);
 }
 
 void QuicStreamFactory::ActivateSession(
     const HostPortProxyPair& host_port_proxy_pair,
     QuicClientSession* session) {
   DCHECK(!HasActiveSession(host_port_proxy_pair));
   active_sessions_[host_port_proxy_pair] = session;
   session_aliases_[session].insert(host_port_proxy_pair);
 }
 
 
 }  // namespace net