chromium/third_party/blink/renderer/modules/peerconnection/rtc_encoded_audio_frame.cc

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

#include "third_party/blink/renderer/modules/peerconnection/rtc_encoded_audio_frame.h"

#include <utility>

#include "base/unguessable_token.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_rtc_encoded_audio_frame_metadata.h"
#include "third_party/blink/renderer/bindings/modules/v8/v8_rtc_encoded_audio_frame_options.h"
#include "third_party/blink/renderer/core/execution_context/execution_context.h"
#include "third_party/blink/renderer/core/typed_arrays/dom_array_buffer.h"
#include "third_party/blink/renderer/modules/peerconnection/rtc_encoded_audio_frame_delegate.h"
#include "third_party/blink/renderer/platform/bindings/exception_code.h"
#include "third_party/blink/renderer/platform/bindings/exception_state.h"
#include "third_party/blink/renderer/platform/bindings/v8_binding.h"
#include "third_party/blink/renderer/platform/wtf/text/string_builder.h"
#include "third_party/webrtc/api/frame_transformer_interface.h"

namespace blink {
namespace {

struct SetMetadataValidationOutcome { … };

SetMetadataValidationOutcome IsAllowedSetMetadataChange(
    const RTCEncodedAudioFrameMetadata* current_metadata,
    const RTCEncodedAudioFrameMetadata* new_metadata) { … }

}  // namespace

RTCEncodedAudioFrame* RTCEncodedAudioFrame::Create(
    RTCEncodedAudioFrame* original_frame,
    ExceptionState& exception_state) { … }

RTCEncodedAudioFrame* RTCEncodedAudioFrame::Create(
    RTCEncodedAudioFrame* original_frame,
    const RTCEncodedAudioFrameOptions* options_dict,
    ExceptionState& exception_state) { … }

RTCEncodedAudioFrame::RTCEncodedAudioFrame(
    std::unique_ptr<webrtc::TransformableAudioFrameInterface>
        webrtc_audio_frame)
    : … { … }

RTCEncodedAudioFrame::RTCEncodedAudioFrame(
    std::unique_ptr<webrtc::TransformableAudioFrameInterface>
        webrtc_audio_frame,
    base::UnguessableToken owner_id,
    int64_t counter)
    : … { … }

RTCEncodedAudioFrame::RTCEncodedAudioFrame(
    scoped_refptr<RTCEncodedAudioFrameDelegate> delegate)
    : … { … }

uint32_t RTCEncodedAudioFrame::timestamp() const { … }

DOMArrayBuffer* RTCEncodedAudioFrame::data(ExecutionContext* context) const { … }

RTCEncodedAudioFrameMetadata* RTCEncodedAudioFrame::getMetadata() const { … }

base::expected<void, String> RTCEncodedAudioFrame::SetMetadata(
    const RTCEncodedAudioFrameMetadata* metadata) { … }

void RTCEncodedAudioFrame::setMetadata(RTCEncodedAudioFrameMetadata* metadata,
                                       ExceptionState& exception_state) { … }

void RTCEncodedAudioFrame::setData(ExecutionContext*, DOMArrayBuffer* data) { … }

String RTCEncodedAudioFrame::toString(ExecutionContext* context) const { … }

base::UnguessableToken RTCEncodedAudioFrame::OwnerId() { … }
int64_t RTCEncodedAudioFrame::Counter() { … }

void RTCEncodedAudioFrame::SyncDelegate() const { … }

scoped_refptr<RTCEncodedAudioFrameDelegate> RTCEncodedAudioFrame::Delegate()
    const { … }

std::unique_ptr<webrtc::TransformableAudioFrameInterface>
RTCEncodedAudioFrame::PassWebRtcFrame(v8::Isolate* isolate,
                                      bool detach_frame_data) { … }

void RTCEncodedAudioFrame::Trace(Visitor* visitor) const { … }

}  // namespace blink