Land Recent QUIC Changes until 03/27/2015

net/tools/quic/quic_dispatcher.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/tools/quic/quic_dispatcher.h"
 
 #include <utility>
 
 #include "base/debug/stack_trace.h"
 #include "base/logging.h"
@@ skipping 145 matching lines @@
 QuicDispatcher::PacketWriterFactoryAdapter::~PacketWriterFactoryAdapter() {}
 
 QuicPacketWriter* QuicDispatcher::PacketWriterFactoryAdapter::Create(
     QuicConnection* connection) const {
   return dispatcher_->packet_writer_factory_->Create(
       dispatcher_->writer_.get(),
       connection);
 }
 
 QuicDispatcher::QuicDispatcher(const QuicConfig& config,
-                               const QuicCryptoServerConfig& crypto_config,
+                               const QuicCryptoServerConfig* crypto_config,
                                const QuicVersionVector& supported_versions,
                                PacketWriterFactory* packet_writer_factory,
                                QuicConnectionHelperInterface* helper)
     : config_(config),
       crypto_config_(crypto_config),
       helper_(helper),
       delete_sessions_alarm_(
           helper_->CreateAlarm(new DeleteSessionsAlarm(this))),
       packet_writer_factory_(packet_writer_factory),
       connection_writer_factory_(this),
@@ skipping 139 matching lines @@
                                                      connection->version(),
                                                      connection_close_packet);
   session_map_.erase(it);
 }
 
 void QuicDispatcher::DeleteSessions() {
   STLDeleteElements(&closed_session_list_);
 }
 
 void QuicDispatcher::OnCanWrite() {
-  // We got an EPOLLOUT: the socket should not be blocked.
+  // The socket is now writable.
   writer_->SetWritable();
 
   // Give all the blocked writers one chance to write, until we're blocked again
   // or there's no work left.
   while (!write_blocked_list_.empty() && !writer_->IsWriteBlocked()) {
     QuicBlockedWriterInterface* blocked_writer =
         write_blocked_list_.begin()->first;
     write_blocked_list_.erase(write_blocked_list_.begin());
     blocked_writer->OnCanWrite();
   }
@@ skipping 60 matching lines @@
 }
 
 QuicServerSession* QuicDispatcher::CreateQuicSession(
     QuicConnectionId connection_id,
     const IPEndPoint& server_address,
     const IPEndPoint& client_address) {
   // The QuicServerSession takes ownership of |connection| below.
   QuicConnection* connection = new QuicConnection(
       connection_id, client_address, helper_.get(), connection_writer_factory_,
       /* owns_writer= */ true, Perspective::IS_SERVER,
-      crypto_config_.HasProofSource(), supported_versions_);
+      crypto_config_->HasProofSource(), supported_versions_);
 
   QuicServerSession* session = new QuicServerSession(config_, connection, this);
-  session->InitializeSession(&crypto_config_);
+  session->InitializeSession(crypto_config_);
   return session;
 }
 
 QuicTimeWaitListManager* QuicDispatcher::CreateQuicTimeWaitListManager() {
   return new QuicTimeWaitListManager(
       writer_.get(), this, helper_.get(), supported_versions());
 }
 
 bool QuicDispatcher::HandlePacketForTimeWait(
     const QuicPacketPublicHeader& header) {
   if (header.reset_flag) {
     // Public reset packets do not have sequence numbers, so ignore the packet.
     return false;
   }
 
   // Switch the framer to the correct version, so that the sequence number can
   // be parsed correctly.
   framer_.set_version(time_wait_list_manager_->GetQuicVersionFromConnectionId(
       header.connection_id));
 
   // Continue parsing the packet to extract the sequence number.  Then
   // send it to the time wait manager in OnUnathenticatedHeader.
   return true;
 }
 
 }  // namespace tools
 }  // namespace net