quic/quartc/quartc_endpoint.cc

// Copyright (c) 2017 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/third_party/quiche/src/quic/quartc/quartc_endpoint.h"
#include "net/third_party/quiche/src/quic/core/quic_version_manager.h"
#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
#include "net/third_party/quiche/src/quic/quartc/quartc_connection_helper.h"
#include "net/third_party/quiche/src/quic/quartc/quartc_crypto_helpers.h"
#include "net/third_party/quiche/src/quic/quartc/quartc_dispatcher.h"

namespace quic {

namespace {

// Wrapper around a QuicAlarmFactory which delegates to the wrapped factory.
// Usee to convert an unowned pointer into an owned pointer, so that the new
// "owner" does not delete the underlying factory.  Note that this is only valid
// when the unowned pointer is already guaranteed to outlive the new "owner".
class QuartcAlarmFactoryWrapper : public QuicAlarmFactory {
 public:
  explicit QuartcAlarmFactoryWrapper(QuicAlarmFactory* impl) : impl_(impl) {}

  QuicAlarm* CreateAlarm(QuicAlarm::Delegate* delegate) override;
  QuicArenaScopedPtr<QuicAlarm> CreateAlarm(
      QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
      QuicConnectionArena* arena) override;

 private:
  QuicAlarmFactory* impl_;
};

QuicAlarm* QuartcAlarmFactoryWrapper::CreateAlarm(
    QuicAlarm::Delegate* delegate) {
  return impl_->CreateAlarm(delegate);
}

QuicArenaScopedPtr<QuicAlarm> QuartcAlarmFactoryWrapper::CreateAlarm(
    QuicArenaScopedPtr<QuicAlarm::Delegate> delegate,
    QuicConnectionArena* arena) {
  return impl_->CreateAlarm(std::move(delegate), arena);
}

QuartcFactoryConfig CreateFactoryConfig(QuicAlarmFactory* alarm_factory,
                                        const QuicClock* clock) {
  QuartcFactoryConfig config;
  config.alarm_factory = alarm_factory;
  config.clock = clock;
  return config;
}

}  // namespace

QuartcClientEndpoint::QuartcClientEndpoint(
    QuicAlarmFactory* alarm_factory,
    const QuicClock* clock,
    QuartcEndpoint::Delegate* delegate,
    QuicStringPiece serialized_server_config)
    : alarm_factory_(alarm_factory),
      clock_(clock),
      delegate_(delegate),
      serialized_server_config_(serialized_server_config),
      create_session_alarm_(QuicWrapUnique(
          alarm_factory_->CreateAlarm(new CreateSessionDelegate(this)))),
      factory_(QuicMakeUnique<QuartcFactory>(
          CreateFactoryConfig(alarm_factory, clock))) {}

void QuartcClientEndpoint::Connect(const QuartcSessionConfig& config) {
  config_ = config;
  create_session_alarm_->Set(clock_->Now());
}

void QuartcClientEndpoint::OnCreateSessionAlarm() {
  session_ =
      factory_->CreateQuartcClientSession(config_, serialized_server_config_);
  delegate_->OnSessionCreated(session_.get());
}

QuartcServerEndpoint::QuartcServerEndpoint(QuicAlarmFactory* alarm_factory,
                                           const QuicClock* clock,
                                           QuartcEndpoint::Delegate* delegate)
    : alarm_factory_(alarm_factory), clock_(clock), delegate_(delegate) {}

void QuartcServerEndpoint::Connect(const QuartcSessionConfig& config) {
  auto connection_helper = QuicMakeUnique<QuartcConnectionHelper>(clock_);
  auto crypto_config = CreateCryptoServerConfig(
      connection_helper->GetRandomGenerator(), clock_, config.pre_shared_key);
  dispatcher_ = QuicMakeUnique<QuartcDispatcher>(
      QuicMakeUnique<QuicConfig>(CreateQuicConfig(config)),
      std::move(crypto_config.config), crypto_config.serialized_crypto_config,
      QuicMakeUnique<QuicVersionManager>(AllSupportedVersions()),
      std::move(connection_helper),
      QuicMakeUnique<QuartcCryptoServerStreamHelper>(),
      QuicMakeUnique<QuartcAlarmFactoryWrapper>(alarm_factory_),
      QuicMakeUnique<QuartcPacketWriter>(config.packet_transport,
                                         config.max_packet_size),
      this);
  // The dispatcher requires at least one call to |ProcessBufferedChlos| to
  // set the number of connections it is allowed to create.
  dispatcher_->ProcessBufferedChlos(/*max_connections_to_create=*/1);
}

void QuartcServerEndpoint::OnSessionCreated(QuartcSession* session) {
  delegate_->OnSessionCreated(session);
}

}  // namespace quic