ftl_signal_strategy.cc | Explore in Territory

// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "remoting/signaling/ftl_signal_strategy.h"

#include <utility>

#include "base/functional/bind.h"
#include "base/logging.h"
#include "base/memory/ptr_util.h"
#include "base/memory/weak_ptr.h"
#include "base/observer_list.h"
#include "base/rand_util.h"
#include "base/sequence_checker.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/sequenced_task_runner.h"
#include "remoting/base/logging.h"
#include "remoting/base/oauth_token_getter.h"
#include "remoting/base/protobuf_http_status.h"
#include "remoting/signaling/ftl_device_id_provider.h"
#include "remoting/signaling/ftl_messaging_client.h"
#include "remoting/signaling/ftl_registration_manager.h"
#include "remoting/signaling/signaling_address.h"
#include "remoting/signaling/xmpp_constants.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"
#include "third_party/libjingle_xmpp/xmllite/xmlelement.h"

namespace remoting {

class FtlSignalStrategy::Core { … };

FtlSignalStrategy::Core::Core(
    std::unique_ptr<OAuthTokenGetter> oauth_token_getter,
    std::unique_ptr<RegistrationManager> registration_manager,
    std::unique_ptr<MessagingClient> messaging_client) { … }

FtlSignalStrategy::Core::~Core() { … }

void FtlSignalStrategy::Core::Connect() { … }

void FtlSignalStrategy::Core::Disconnect() { … }

SignalStrategy::State FtlSignalStrategy::Core::GetState() const { … }

SignalStrategy::Error FtlSignalStrategy::Core::GetError() const { … }

const SignalingAddress& FtlSignalStrategy::Core::GetLocalAddress() const { … }

void FtlSignalStrategy::Core::AddListener(Listener* listener) { … }

void FtlSignalStrategy::Core::RemoveListener(Listener* listener) { … }

bool FtlSignalStrategy::Core::SendStanza(
    std::unique_ptr<jingle_xmpp::XmlElement> stanza) { … }

bool FtlSignalStrategy::Core::SendMessage(
    const SignalingAddress& destination_address,
    const ftl::ChromotingMessage& message) { … }

bool FtlSignalStrategy::Core::IsSignInError() const { … }

void FtlSignalStrategy::Core::OnGetOAuthTokenResponse(
    OAuthTokenGetter::Status status,
    const std::string& user_email,
    const std::string& access_token) { … }

void FtlSignalStrategy::Core::OnSignInGaiaResponse(
    const ProtobufHttpStatus& status) { … }

void FtlSignalStrategy::Core::StartReceivingMessages() { … }

void FtlSignalStrategy::Core::OnReceiveMessagesStreamStarted() { … }

void FtlSignalStrategy::Core::OnReceiveMessagesStreamClosed(
    const ProtobufHttpStatus& status) { … }

void FtlSignalStrategy::Core::OnMessageReceived(
    const ftl::Id& sender_id,
    const std::string& sender_registration_id,
    const ftl::ChromotingMessage& message) { … }

void FtlSignalStrategy::Core::SendMessageImpl(
    const SignalingAddress& receiver,
    const ftl::ChromotingMessage& message,
    MessagingClient::DoneCallback callback) { … }

void FtlSignalStrategy::Core::OnSendMessageResponse(
    const SignalingAddress& receiver,
    const std::string& stanza_id,
    const ProtobufHttpStatus& status) { … }

void FtlSignalStrategy::Core::HandleProtobufHttpStatusError(
    const base::Location& location,
    const ProtobufHttpStatus& status) { … }

void FtlSignalStrategy::Core::OnStanza(
    const SignalingAddress& sender_address,
    std::unique_ptr<jingle_xmpp::XmlElement> stanza) { … }

FtlSignalStrategy::FtlSignalStrategy(
    std::unique_ptr<OAuthTokenGetter> oauth_token_getter,
    scoped_refptr<network::SharedURLLoaderFactory> url_loader_factory,
    std::unique_ptr<FtlDeviceIdProvider> device_id_provider,
    SignalingTracker* signaling_tracker) { … }

FtlSignalStrategy::FtlSignalStrategy(
    std::unique_ptr<OAuthTokenGetter> oauth_token_getter,
    std::unique_ptr<RegistrationManager> registration_manager,
    std::unique_ptr<MessagingClient> messaging_client) { … }

FtlSignalStrategy::~FtlSignalStrategy() { … }

void FtlSignalStrategy::Connect() { … }

void FtlSignalStrategy::Disconnect() { … }

SignalStrategy::State FtlSignalStrategy::GetState() const { … }

SignalStrategy::Error FtlSignalStrategy::GetError() const { … }

const SignalingAddress& FtlSignalStrategy::GetLocalAddress() const { … }

void FtlSignalStrategy::AddListener(Listener* listener) { … }

void FtlSignalStrategy::RemoveListener(Listener* listener) { … }

bool FtlSignalStrategy::SendStanza(
    std::unique_ptr<jingle_xmpp::XmlElement> stanza) { … }

bool FtlSignalStrategy::SendMessage(const SignalingAddress& destination_address,
                                    const ftl::ChromotingMessage& message) { … }

std::string FtlSignalStrategy::GetNextId() { … }

bool FtlSignalStrategy::IsSignInError() const { … }

void FtlSignalStrategy::CreateCore(
    std::unique_ptr<OAuthTokenGetter> oauth_token_getter,
    std::unique_ptr<RegistrationManager> registration_manager,
    std::unique_ptr<MessagingClient> messaging_client) { … }

}  // namespace remoting
chromium/remoting/signaling/ftl_signal_strategy.cc
