cast_message_handler.cc | Explore in Territory

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

#include "components/media_router/common/providers/cast/channel/cast_message_handler.h"

#include <string>
#include <tuple>
#include <utility>
#include <vector>

#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/not_fatal_until.h"
#include "base/observer_list.h"
#include "base/rand_util.h"
#include "base/ranges/algorithm.h"
#include "base/strings/stringprintf.h"
#include "base/time/default_tick_clock.h"
#include "base/types/expected_macros.h"
#include "components/media_router/common/providers/cast/channel/cast_channel_metrics.h"
#include "components/media_router/common/providers/cast/channel/cast_message_util.h"
#include "components/media_router/common/providers/cast/channel/cast_socket_service.h"

namespace cast_channel {

namespace {

// The max launch timeout amount for session launch requests.
constexpr base::TimeDelta kLaunchMaxTimeout = …;

// The max size of Cast Message is 64KB.
constexpr int kMaxCastMessagePayload = …;

void ReportParseError(const std::string& error) { … }

}  // namespace

GetAppAvailabilityRequest::GetAppAvailabilityRequest(
    int request_id,
    GetAppAvailabilityCallback callback,
    const base::TickClock* clock,
    const std::string& app_id)
    : … { … }

GetAppAvailabilityRequest::~GetAppAvailabilityRequest() = default;

LaunchSessionCallbackWrapper::LaunchSessionCallbackWrapper() = default;
LaunchSessionCallbackWrapper::~LaunchSessionCallbackWrapper() = default;

VirtualConnection::VirtualConnection(int channel_id,
                                     std::string_view source_id,
                                     std::string_view destination_id)
    : … { … }
VirtualConnection::~VirtualConnection() = default;

bool VirtualConnection::operator<(const VirtualConnection& other) const { … }

InternalMessage::InternalMessage(CastMessageType type,
                                 std::string_view source_id,
                                 std::string_view destination_id,
                                 std::string_view message_namespace,
                                 base::Value::Dict message)
    : … { … }
InternalMessage::~InternalMessage() = default;

CastMessageHandler::Observer::~Observer() { … }

CastMessageHandler::CastMessageHandler(CastSocketService* socket_service,
                                       ParseJsonCallback parse_json,
                                       std::string_view user_agent,
                                       std::string_view browser_version,
                                       std::string_view locale)
    : … { … }

CastMessageHandler::~CastMessageHandler() { … }

void CastMessageHandler::EnsureConnection(
    int channel_id,
    const std::string& source_id,
    const std::string& destination_id,
    VirtualConnectionType connection_type) { … }

void CastMessageHandler::CloseConnection(int channel_id,
                                         const std::string& source_id,
                                         const std::string& destination_id) { … }

void CastMessageHandler::RemoveConnection(int channel_id,
                                          const std::string& source_id,
                                          const std::string& destination_id) { … }

CastMessageHandler::PendingRequests*
CastMessageHandler::GetOrCreatePendingRequests(int channel_id) { … }

void CastMessageHandler::RequestAppAvailability(
    CastSocket* socket,
    const std::string& app_id,
    GetAppAvailabilityCallback callback) { … }

void CastMessageHandler::RequestReceiverStatus(int channel_id) { … }

void CastMessageHandler::LaunchSession(
    int channel_id,
    const std::string& app_id,
    base::TimeDelta launch_timeout,
    const std::vector<std::string>& supported_app_types,
    const std::optional<base::Value>& app_params,
    LaunchSessionCallback callback) { … }

void CastMessageHandler::StopSession(
    int channel_id,
    const std::string& session_id,
    const std::optional<std::string>& client_id,
    ResultCallback callback) { … }

Result CastMessageHandler::SendCastMessage(int channel_id,
                                           const CastMessage& message) { … }

Result CastMessageHandler::SendAppMessage(int channel_id,
                                          const CastMessage& message) { … }

std::optional<int> CastMessageHandler::SendMediaRequest(
    int channel_id,
    const base::Value::Dict& body,
    const std::string& source_id,
    const std::string& destination_id) { … }

void CastMessageHandler::SendSetVolumeRequest(int channel_id,
                                              const base::Value::Dict& body,
                                              const std::string& source_id,
                                              ResultCallback callback) { … }

void CastMessageHandler::AddObserver(Observer* observer) { … }

void CastMessageHandler::RemoveObserver(Observer* observer) { … }

void CastMessageHandler::OnError(const CastSocket& socket,
                                 ChannelError error_state) { … }

void CastMessageHandler::OnMessage(const CastSocket& socket,
                                   const CastMessage& message) { … }

void CastMessageHandler::OnReadyStateChanged(const CastSocket& socket) { … }

void CastMessageHandler::HandleCastInternalMessage(
    int channel_id,
    const std::string& source_id,
    const std::string& destination_id,
    const std::string& namespace_,
    data_decoder::DataDecoder::ValueOrError parse_result) { … }

void CastMessageHandler::SendCastMessageToSocket(CastSocket* socket,
                                                 const CastMessage& message) { … }

void CastMessageHandler::DoEnsureConnection(
    CastSocket* socket,
    const std::string& source_id,
    const std::string& destination_id,
    VirtualConnectionType connection_type) { … }

void CastMessageHandler::OnMessageSent(int result) { … }

CastMessageHandler::PendingRequests::PendingRequests() = default;
CastMessageHandler::PendingRequests::~PendingRequests() { … }

bool CastMessageHandler::PendingRequests::AddAppAvailabilityRequest(
    std::unique_ptr<GetAppAvailabilityRequest> request) { … }

bool CastMessageHandler::PendingRequests::AddLaunchRequest(
    std::unique_ptr<LaunchSessionRequest> request,
    base::TimeDelta timeout) { … }

bool CastMessageHandler::PendingRequests::AddStopRequest(
    std::unique_ptr<StopSessionRequest> request) { … }

void CastMessageHandler::PendingRequests::AddVolumeRequest(
    std::unique_ptr<SetVolumeRequest> request) { … }

void CastMessageHandler::PendingRequests::HandlePendingRequest(
    int request_id,
    const base::Value::Dict& response) { … }

void CastMessageHandler::PendingRequests::AppAvailabilityTimedOut(
    int request_id) { … }

void CastMessageHandler::PendingRequests::LaunchSessionTimedOut(
    int request_id) { … }

void CastMessageHandler::PendingRequests::StopSessionTimedOut(int request_id) { … }

void CastMessageHandler::PendingRequests::SetVolumeTimedOut(int request_id) { … }

}  // namespace cast_channel
chromium/components/media_router/common/providers/cast/channel/cast_message_handler.cc
