tts_utterance_impl.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 "content/browser/speech/tts_utterance_impl.h"

#include <memory>

#include "base/values.h"
#include "content/public/browser/web_contents.h"
#include "third_party/blink/public/mojom/speech/speech_synthesis.mojom.h"

namespace content {

bool IsFinalTtsEventType(TtsEventType event_type) { … }

//
// UtteranceContinuousParameters
//

UtteranceContinuousParameters::UtteranceContinuousParameters()
    : … { … }

//
// Utterance
//

// static
int TtsUtteranceImpl::next_utterance_id_ = …;

// static
std::unique_ptr<TtsUtterance> TtsUtterance::Create(WebContents* web_contents) { … }

// static
std::unique_ptr<TtsUtterance> TtsUtterance::Create(
    BrowserContext* browser_context,
    bool should_always_be_spoken) { … }

// static
std::unique_ptr<TtsUtterance> TtsUtterance::Create() { … }

TtsUtteranceImpl::TtsUtteranceImpl(BrowserContext* browser_context,
                                   WebContents* web_contents)
    : … { … }

TtsUtteranceImpl::TtsUtteranceImpl(BrowserContext* browser_context,
                                   bool should_always_be_spoken)
    : … { … }

TtsUtteranceImpl::~TtsUtteranceImpl() { … }

void TtsUtteranceImpl::OnTtsEvent(TtsEventType event_type,
                                  int char_index,
                                  int length,
                                  const std::string& error_message) { … }

void TtsUtteranceImpl::Finish() { … }

void TtsUtteranceImpl::SetText(const std::string& text) { … }

const std::string& TtsUtteranceImpl::GetText() { … }

void TtsUtteranceImpl::SetOptions(base::Value::Dict options) { … }

const base::Value::Dict* TtsUtteranceImpl::GetOptions() { … }

void TtsUtteranceImpl::SetSrcId(int src_id) { … }

int TtsUtteranceImpl::GetSrcId() { … }

void TtsUtteranceImpl::SetSrcUrl(const GURL& src_url) { … }
const GURL& TtsUtteranceImpl::GetSrcUrl() { … }

void TtsUtteranceImpl::SetVoiceName(const std::string& voice_name) { … }

const std::string& TtsUtteranceImpl::GetVoiceName() { … }

void TtsUtteranceImpl::SetLang(const std::string& lang) { … }

const std::string& TtsUtteranceImpl::GetLang() { … }

void TtsUtteranceImpl::SetContinuousParameters(const double rate,
                                               const double pitch,
                                               const double volume) { … }

const UtteranceContinuousParameters&
TtsUtteranceImpl::GetContinuousParameters() { … }

void TtsUtteranceImpl::SetShouldClearQueue(bool value) { … }

bool TtsUtteranceImpl::GetShouldClearQueue() { … }

void TtsUtteranceImpl::SetRequiredEventTypes(
    const std::set<TtsEventType>& types) { … }

const std::set<TtsEventType>& TtsUtteranceImpl::GetRequiredEventTypes() { … }

void TtsUtteranceImpl::SetDesiredEventTypes(
    const std::set<TtsEventType>& types) { … }
const std::set<TtsEventType>& TtsUtteranceImpl::GetDesiredEventTypes() { … }

void TtsUtteranceImpl::SetEngineId(const std::string& engine_id) { … }

const std::string& TtsUtteranceImpl::GetEngineId() { … }

void TtsUtteranceImpl::SetEventDelegate(
    UtteranceEventDelegate* event_delegate) { … }

UtteranceEventDelegate* TtsUtteranceImpl::GetEventDelegate() { … }

BrowserContext* TtsUtteranceImpl::GetBrowserContext() { … }

void TtsUtteranceImpl::ClearBrowserContext() { … }

int TtsUtteranceImpl::GetId() { … }

bool TtsUtteranceImpl::IsFinished() { … }

WebContents* TtsUtteranceImpl::GetWebContents() { … }

bool TtsUtteranceImpl::ShouldAlwaysBeSpoken() { … }

}  // namespace content
chromium/content/browser/speech/tts_utterance_impl.cc
