Import Cobalt 23.lts.6.1031897
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 860c540..1155938 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -149,14 +149,6 @@
stages: [push]
always_run: true
pass_filenames: false
- - id: run-py2-tests
- name: Run Python 2 Tests
- description: Run Python 2 unittests
- entry: python precommit_hooks/run_python2_unittests.py
- language: python
- language_version: python2.7
- additional_dependencies: ['mock']
- types: [python]
- id: osslint
name: osslint
entry: python precommit_hooks/osslint_wrapper.py
diff --git a/cobalt/browser/BUILD.gn b/cobalt/browser/BUILD.gn
index 07a6de0..7dccc07 100644
--- a/cobalt/browser/BUILD.gn
+++ b/cobalt/browser/BUILD.gn
@@ -158,6 +158,7 @@
"//cobalt/browser/memory_settings:browser_memory_settings",
"//cobalt/browser/memory_tracker:memory_tracker_tool",
"//cobalt/build:cobalt_build_id",
+ "//cobalt/build:cobalt_build_info",
"//cobalt/cache",
"//cobalt/configuration",
"//cobalt/css_parser",
diff --git a/cobalt/browser/application.cc b/cobalt/browser/application.cc
index fe4c098..7e541f0 100644
--- a/cobalt/browser/application.cc
+++ b/cobalt/browser/application.cc
@@ -65,6 +65,7 @@
#include "cobalt/configuration/configuration.h"
#include "cobalt/extension/crash_handler.h"
#include "cobalt/extension/installation_manager.h"
+#include "cobalt/h5vcc/h5vcc_crash_log.h"
#include "cobalt/loader/image/image_decoder.h"
#include "cobalt/math/size.h"
#include "cobalt/script/javascript_engine.h"
@@ -589,6 +590,26 @@
}
}
+void AddCrashLogApplicationState(base::ApplicationState state) {
+ std::string application_state = std::string(GetApplicationStateString(state));
+ application_state.push_back('\0');
+
+ auto crash_handler_extension =
+ static_cast<const CobaltExtensionCrashHandlerApi*>(
+ SbSystemGetExtension(kCobaltExtensionCrashHandlerName));
+ if (crash_handler_extension && crash_handler_extension->version >= 2) {
+ if (!crash_handler_extension->SetString("application_state",
+ application_state.c_str())) {
+ LOG(ERROR) << "Could not send application state to crash handler.";
+ }
+ return;
+ }
+
+ // Crash handler is not supported, fallback to crash log dictionary.
+ h5vcc::CrashLogDictionary::GetInstance()->SetString("application_state",
+ application_state);
+}
+
} // namespace
// Helper stub to disable histogram tracking in StatisticsRecorder
@@ -1198,6 +1219,7 @@
case kSbEventTypeStop:
LOG(INFO) << "Got quit event.";
if (watchdog) watchdog->UpdateState(base::kApplicationStateStopped);
+ AddCrashLogApplicationState(base::kApplicationStateStopped);
Quit();
LOG(INFO) << "Finished quitting.";
break;
@@ -1316,6 +1338,7 @@
return;
}
if (watchdog) watchdog->UpdateState(browser_module_->GetApplicationState());
+ AddCrashLogApplicationState(browser_module_->GetApplicationState());
}
void Application::OnWindowSizeChangedEvent(const base::Event* event) {
diff --git a/cobalt/browser/web_module.cc b/cobalt/browser/web_module.cc
index 3531cbf..f1158dd 100644
--- a/cobalt/browser/web_module.cc
+++ b/cobalt/browser/web_module.cc
@@ -141,7 +141,21 @@
~Impl();
#if defined(ENABLE_DEBUGGER)
+ void EnsureDebugModule(
+ debug::backend::DebuggerState* debugger_state = nullptr) {
+ if (!debug_overlay_) {
+ debug_overlay_.reset(
+ new debug::backend::RenderOverlay(render_tree_produced_callback_));
+ }
+ if (!debug_module_) {
+ debug_module_.reset(new debug::backend::DebugModule(
+ &debugger_hooks_, web_context_->global_environment(),
+ debug_overlay_.get(), resource_provider_, window_, debugger_state));
+ }
+ }
+
debug::backend::DebugDispatcher* debug_dispatcher() {
+ EnsureDebugModule();
DCHECK(debug_module_);
return debug_module_->debug_dispatcher();
}
@@ -229,7 +243,8 @@
void FreezeDebugger(
std::unique_ptr<debug::backend::DebuggerState>* debugger_state) {
- if (debugger_state) *debugger_state = debug_module_->Freeze();
+ if (debugger_state && debug_module_)
+ *debugger_state = debug_module_->Freeze();
}
#endif // defined(ENABLE_DEBUGGER)
@@ -549,6 +564,7 @@
data.options.loader_thread_priority));
animated_image_tracker_.reset(new loader::image::AnimatedImageTracker(
+ web_context_->name().c_str(),
data.options.animated_image_decode_thread_priority));
DCHECK_LE(0, data.options.image_cache_capacity);
@@ -744,14 +760,9 @@
}
#if defined(ENABLE_DEBUGGER)
- debug_overlay_.reset(
- new debug::backend::RenderOverlay(render_tree_produced_callback_));
-
- debug_module_.reset(new debug::backend::DebugModule(
- &debugger_hooks_, web_context_->global_environment(),
- debug_overlay_.get(), resource_provider_, window_,
- data.options.debugger_state));
-#endif // ENABLE_DEBUGGER
+ if (data.options.debugger_state)
+ EnsureDebugModule(data.options.debugger_state);
+#endif
report_unload_timing_info_callback_ =
data.options.collect_unload_event_time_callback;
@@ -982,7 +993,11 @@
last_render_tree_produced_time_));
#if defined(ENABLE_DEBUGGER)
- debug_overlay_->OnRenderTreeProduced(layout_results_with_callback);
+ if (debug_overlay_) {
+ debug_overlay_->OnRenderTreeProduced(layout_results_with_callback);
+ } else {
+ render_tree_produced_callback_.Run(layout_results_with_callback);
+ }
#else // ENABLE_DEBUGGER
render_tree_produced_callback_.Run(layout_results_with_callback);
#endif // ENABLE_DEBUGGER
@@ -1003,6 +1018,7 @@
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
web_module_stat_tracker_->OnRenderTreeRasterized(produced_time,
rasterized_time);
+ animated_image_tracker_->OnRenderTreeRasterized();
if (produced_time >= last_render_tree_produced_time_) {
is_render_tree_rasterization_pending_ = false;
}
@@ -1075,7 +1091,7 @@
"\n Waiting for web debugger to connect "
"\n-------------------------------------";
// This blocks until the web debugger connects.
- debug_module_->debug_dispatcher()->SetPaused(true);
+ debug_dispatcher()->SetPaused(true);
waiting_for_web_debugger_->store(false);
}
#endif // defined(ENABLE_DEBUGGER)
@@ -1166,7 +1182,9 @@
#if defined(ENABLE_DEBUGGER)
// The debug overlay may be holding onto a render tree, clear that out.
- debug_overlay_->ClearInput();
+ if (debug_overlay_) {
+ debug_overlay_->ClearInput();
+ }
#endif
// Force garbage collection in |javascript_engine|.
diff --git a/cobalt/build/BUILD.gn b/cobalt/build/BUILD.gn
index 6c6e1e8..7b6a002 100644
--- a/cobalt/build/BUILD.gn
+++ b/cobalt/build/BUILD.gn
@@ -23,3 +23,9 @@
cobalt_version,
]
}
+
+action("cobalt_build_info") {
+ script = "build_info.py"
+ outputs = [ "$root_gen_dir/build_info.json" ]
+ args = [ rebase_path(outputs[0], root_build_dir) ]
+}
diff --git a/cobalt/build/build.id b/cobalt/build/build.id
index 3d15dd7..20a1fde 100644
--- a/cobalt/build/build.id
+++ b/cobalt/build/build.id
@@ -1 +1 @@
-1031871
\ No newline at end of file
+1031897
\ No newline at end of file
diff --git a/cobalt/build/build_info.py b/cobalt/build/build_info.py
new file mode 100755
index 0000000..52f4494
--- /dev/null
+++ b/cobalt/build/build_info.py
@@ -0,0 +1,132 @@
+#!/usr/bin/env python
+# Copyright 2023 The Cobalt Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""Generates a Cobalt Build Info json."""
+
+import datetime
+import json
+import os
+import re
+import subprocess
+import sys
+
+FILE_DIR = os.path.dirname(__file__)
+COMMIT_COUNT_BUILD_ID_OFFSET = 1000000
+
+_BUILD_ID_PATTERN = '^BUILD_NUMBER=([1-9][0-9]{6,})$'
+_GIT_REV_PATTERN = '^GitOrigin-RevId: ([0-9a-f]{40})$'
+_COBALT_VERSION_PATTERN = '^#define COBALT_VERSION "(.*)"$'
+
+
+def get_build_id_and_git_rev_from_commits(cwd):
+ # Build id and git rev must come from the same commit.
+ output = subprocess.check_output(
+ ['git', 'log', '--grep', _BUILD_ID_PATTERN, '-1', '-E', '--pretty=%b'],
+ cwd=cwd).decode()
+
+ # Gets build id.
+ compiled_build_id_pattern = re.compile(_BUILD_ID_PATTERN, flags=re.MULTILINE)
+ match_build_id = compiled_build_id_pattern.search(output)
+ if not match_build_id:
+ return None, None
+ build_id = match_build_id.group(1)
+
+ # Gets git rev.
+ compiled_git_rev_pattern = re.compile(_GIT_REV_PATTERN, flags=re.MULTILINE)
+ match_git_rev = compiled_git_rev_pattern.search(output)
+ if not match_git_rev:
+ git_rev = ''
+ else:
+ git_rev = match_git_rev.group(1)
+
+ return build_id, git_rev
+
+
+def get_build_id_from_commit_count(cwd):
+ output = subprocess.check_output(['git', 'rev-list', '--count', 'HEAD'],
+ cwd=cwd)
+ build_id = int(output.strip().decode()) + COMMIT_COUNT_BUILD_ID_OFFSET
+ return str(build_id)
+
+
+def _get_last_commit_with_format(placeholder, cwd):
+ output = subprocess.check_output(
+ ['git', 'log', '-1', f'--pretty=format:{placeholder}'], cwd=cwd)
+ return output.strip().decode()
+
+
+def _get_hash_from_last_commit(cwd):
+ return _get_last_commit_with_format(r'%H', cwd=cwd)
+
+
+def _get_author_from_last_commit(cwd):
+ return _get_last_commit_with_format(r'%an', cwd=cwd)
+
+
+def _get_subject_from_last_commit(cwd):
+ return _get_last_commit_with_format(r'%s', cwd=cwd)
+
+
+def _get_cobalt_version():
+ version_header_path = os.path.join(os.path.dirname(FILE_DIR), 'version.h')
+ contents = ''
+ with open(version_header_path, 'r', encoding='utf-8') as f:
+ contents = f.read()
+ compiled_cobalt_version_pattern = re.compile(
+ _COBALT_VERSION_PATTERN, flags=re.MULTILINE)
+ return compiled_cobalt_version_pattern.search(contents).group(1)
+
+
+def main(output_path, cwd=FILE_DIR):
+ """Writes a Cobalt build_info json file."""
+ build_rev = _get_hash_from_last_commit(cwd=cwd)
+ build_id, git_rev = get_build_id_and_git_rev_from_commits(cwd=cwd)
+ if build_id is None:
+ build_id = get_build_id_from_commit_count(cwd=cwd)
+ git_rev = build_rev
+ cobalt_version = _get_cobalt_version()
+ build_time = datetime.datetime.now().ctime()
+ author = _get_author_from_last_commit(cwd=cwd)
+ commit = _get_subject_from_last_commit(cwd=cwd)
+
+ info_json = {
+ 'build_id': build_id,
+ 'build_rev': build_rev,
+ 'git_rev': git_rev,
+ 'cobalt_version': cobalt_version,
+ 'build_time': build_time,
+ 'author': author,
+ 'commit': commit
+ }
+
+ with open(output_path, 'w', encoding='utf-8') as f:
+ f.write(json.dumps(info_json, indent=4))
+
+ # Supports legacy build_info.txt.
+ output_text_path = os.path.join(
+ os.path.dirname(output_path), 'build_info.txt')
+ with open(output_text_path, 'w', encoding='utf-8') as f:
+ f.write(f'''\
+Build ID: {build_id}
+Build Rev: {build_rev}
+Git Rev: {git_rev}
+Cobalt Version: {cobalt_version}
+Build Time: {build_time}
+Author: {author}
+Commit: {commit}
+''')
+
+
+if __name__ == '__main__':
+ main(sys.argv[1])
diff --git a/cobalt/build/get_build_id.py b/cobalt/build/get_build_id.py
index 9c19e4c..ba86bb3 100755
--- a/cobalt/build/get_build_id.py
+++ b/cobalt/build/get_build_id.py
@@ -15,35 +15,10 @@
"""Prints out the Cobalt Build ID."""
import os
-import re
-import subprocess
+from cobalt.build import build_info
from cobalt.build.build_number import GetOrGenerateNewBuildNumber
-_FILE_DIR = os.path.dirname(__file__)
-COMMIT_COUNT_BUILD_NUMBER_OFFSET = 1000000
-
-# Matches numbers > 1000000. The pattern is basic so git log --grep is able to
-# interpret it.
-GIT_BUILD_NUMBER_PATTERN = r'[1-9]' + r'[0-9]' * 6 + r'[0-9]*'
-BUILD_NUMBER_TAG_PATTERN = r'^BUILD_NUMBER={}$'
-
-# git log --grep can't handle capture groups.
-BUILD_NUBER_PATTERN_WITH_CAPTURE = f'({GIT_BUILD_NUMBER_PATTERN})'
-
-
-def get_build_number_from_commits():
- full_pattern = BUILD_NUMBER_TAG_PATTERN.format(GIT_BUILD_NUMBER_PATTERN)
- output = subprocess.check_output(
- ['git', 'log', '--grep', full_pattern, '-1', '--pretty=%b'],
- cwd=_FILE_DIR).decode()
-
- full_pattern_with_capture = re.compile(
- BUILD_NUMBER_TAG_PATTERN.format(BUILD_NUBER_PATTERN_WITH_CAPTURE),
- flags=re.MULTILINE)
- match = full_pattern_with_capture.search(output)
- return match.group(1) if match else None
-
def get_build_number_from_server():
# Note $BUILD_ID_SERVER_URL will always be set in CI.
@@ -57,24 +32,14 @@
return build_num
-def get_build_number_from_commit_count():
- output = subprocess.check_output(['git', 'rev-list', '--count', 'HEAD'],
- cwd=_FILE_DIR)
- build_number = int(output.strip().decode('utf-8'))
- return build_number + COMMIT_COUNT_BUILD_NUMBER_OFFSET
-
-
-def main():
- build_number = get_build_number_from_commits()
-
+def main(cwd=build_info.FILE_DIR):
+ build_number, _ = build_info.get_build_id_and_git_rev_from_commits(cwd=cwd)
if not build_number:
build_number = get_build_number_from_server()
-
if not build_number:
- build_number = get_build_number_from_commit_count()
-
- print(build_number)
+ build_number = build_info.get_build_id_from_commit_count(cwd=cwd)
+ return build_number
if __name__ == '__main__':
- main()
+ print(main())
diff --git a/cobalt/build/get_build_id_test.py b/cobalt/build/get_build_id_test.py
new file mode 100644
index 0000000..26e7b2b
--- /dev/null
+++ b/cobalt/build/get_build_id_test.py
@@ -0,0 +1,112 @@
+#!/usr/bin/env python3
+#
+# Copyright 2023 The Cobalt Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+"""Tests the get_build_id module."""
+
+import os
+import subprocess
+import tempfile
+import unittest
+
+from cobalt.build import build_info
+from cobalt.build import get_build_id
+
+_TEST_BUILD_NUMBER = 1234 + build_info.COMMIT_COUNT_BUILD_ID_OFFSET
+
+
+# TODO(b/282040638): fix and re-enabled this
+@unittest.skipIf(os.name == 'nt', 'Broken on Windows')
+class GetBuildIdTest(unittest.TestCase):
+
+ def setUp(self):
+ self.test_dir = tempfile.TemporaryDirectory() # pylint: disable=consider-using-with
+ self.original_cwd = os.getcwd()
+ os.chdir(self.test_dir.name)
+ subprocess.check_call(['git', 'init'])
+ subprocess.check_call(['git', 'config', 'user.name', 'pytest'])
+ subprocess.check_call(['git', 'config', 'user.email', 'pytest@pytest.com'])
+
+ def tearDown(self):
+ os.chdir(self.original_cwd)
+ self.test_dir.cleanup()
+
+ def make_commit(self, message='Temporary commit'):
+ with tempfile.NamedTemporaryFile('w', dir=self.test_dir.name) as temp_file:
+ subprocess.check_call(['git', 'add', temp_file.name])
+ subprocess.check_call(['git', 'commit', '-m', message])
+
+ def make_commit_with_build_number(self, build_number=_TEST_BUILD_NUMBER):
+ message = f'Subject line\n\nBUILD_NUMBER={build_number}'
+ self.make_commit(message)
+
+ def testSanity(self):
+ self.make_commit()
+ head_rev = subprocess.check_output(['git', 'rev-parse', 'HEAD'])
+ self.assertNotEqual(head_rev.strip().decode('utf-8'), '')
+
+ def testGetBuildNumberFromCommitsSunnyDay(self):
+ self.make_commit_with_build_number()
+ build_number, _ = build_info.get_build_id_and_git_rev_from_commits(
+ cwd=self.test_dir.name)
+ self.assertEqual(int(build_number), _TEST_BUILD_NUMBER)
+
+ def testGetBuildNumberFromCommitsSunnyDayGetMostRecent(self):
+ num_commits = 5
+ for i in range(num_commits):
+ self.make_commit_with_build_number(
+ build_info.COMMIT_COUNT_BUILD_ID_OFFSET + i)
+ build_number, _ = build_info.get_build_id_and_git_rev_from_commits(
+ cwd=self.test_dir.name)
+ self.assertEqual(
+ int(build_number),
+ num_commits + build_info.COMMIT_COUNT_BUILD_ID_OFFSET - 1)
+
+ def testGetBuildNumberFromCommitsRainyDayInvalidBuildNumber(self):
+ self.make_commit()
+ self.make_commit(f'BUILD_NUMBER={_TEST_BUILD_NUMBER}')
+ build_number, _ = build_info.get_build_id_and_git_rev_from_commits(
+ cwd=self.test_dir.name)
+ self.assertIsNone(build_number)
+
+ def testGetBuildNumberFromCommitCountSunnyDay(self):
+ num_commits = 5
+ for _ in range(num_commits):
+ self.make_commit()
+ build_number = build_info.get_build_id_from_commit_count(
+ cwd=self.test_dir.name)
+ self.assertEqual(
+ int(build_number),
+ num_commits + build_info.COMMIT_COUNT_BUILD_ID_OFFSET)
+
+ def testCommitsOutrankCommitCount(self):
+ self.make_commit()
+ self.make_commit_with_build_number()
+ self.make_commit()
+ build_number = get_build_id.main(cwd=self.test_dir.name)
+ self.assertEqual(int(build_number), _TEST_BUILD_NUMBER)
+
+ def testFallbackToCommitCount(self):
+ num_commits = 5
+ for _ in range(num_commits):
+ self.make_commit()
+ build_number = get_build_id.main(cwd=self.test_dir.name)
+ self.assertEqual(
+ int(build_number),
+ num_commits + build_info.COMMIT_COUNT_BUILD_ID_OFFSET)
+
+
+if __name__ == '__main__':
+ unittest.main()
diff --git a/cobalt/debug/BUILD.gn b/cobalt/debug/BUILD.gn
index 91c5586..0bdf9b5 100644
--- a/cobalt/debug/BUILD.gn
+++ b/cobalt/debug/BUILD.gn
@@ -17,6 +17,8 @@
sources = [
"backend/agent_base.cc",
"backend/agent_base.h",
+ "backend/cobalt_agent.cc",
+ "backend/cobalt_agent.h",
"backend/command_map.h",
"backend/css_agent.cc",
"backend/css_agent.h",
@@ -90,6 +92,9 @@
"console/command_manager.cc",
"console/command_manager.h",
]
- deps = [ "//cobalt/base" ]
+ deps = [
+ "//cobalt/base",
+ "//starboard:starboard_headers_only",
+ ]
}
}
diff --git a/cobalt/debug/backend/cobalt_agent.cc b/cobalt/debug/backend/cobalt_agent.cc
new file mode 100644
index 0000000..63901c2
--- /dev/null
+++ b/cobalt/debug/backend/cobalt_agent.cc
@@ -0,0 +1,85 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "cobalt/debug/backend/cobalt_agent.h"
+
+#include <set>
+#include <string>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/values.h"
+#include "cobalt/debug/console/command_manager.h"
+#include "cobalt/debug/json_object.h"
+
+namespace cobalt {
+namespace debug {
+namespace backend {
+
+CobaltAgent::CobaltAgent(DebugDispatcher* dispatcher)
+ : AgentBase("Cobalt", dispatcher) {
+ commands_["getConsoleCommands"] =
+ base::Bind(&CobaltAgent::GetConsoleCommands, base::Unretained(this));
+ commands_["sendConsoleCommand"] =
+ base::Bind(&CobaltAgent::SendConsoleCommand, base::Unretained(this));
+ // dispatcher_->AddDomain(domain_, commands_.Bind());
+}
+
+void CobaltAgent::GetConsoleCommands(Command command) {
+ JSONObject response(new base::DictionaryValue());
+ JSONList list(new base::ListValue());
+
+ console::ConsoleCommandManager* command_manager =
+ console::ConsoleCommandManager::GetInstance();
+ DCHECK(command_manager);
+ if (command_manager) {
+ std::set<std::string> commands = command_manager->GetRegisteredCommands();
+ for (auto& command_name : commands) {
+ JSONObject console_command(new base::DictionaryValue());
+ console_command->SetString("command", command_name);
+ console_command->SetString("shortHelp",
+ command_manager->GetShortHelp(command_name));
+ console_command->SetString("longHelp",
+ command_manager->GetLongHelp(command_name));
+ list->Append(std::move(console_command));
+ }
+ }
+
+ JSONObject commands(new base::DictionaryValue());
+ commands->Set("commands", std::move(list));
+ response->Set("result", std::move(commands));
+ command.SendResponse(response);
+}
+
+void CobaltAgent::SendConsoleCommand(Command command) {
+ JSONObject params = JSONParse(command.GetParams());
+ if (params) {
+ std::string console_command;
+ if (params->GetString("command", &console_command)) {
+ std::string message;
+ params->GetString("message", &message);
+ console::ConsoleCommandManager* console_command_manager =
+ console::ConsoleCommandManager::GetInstance();
+ DCHECK(console_command_manager);
+ console_command_manager->HandleCommand(console_command, message);
+ command.SendResponse();
+ return;
+ }
+ }
+ command.SendErrorResponse(Command::kInvalidParams, "Missing command.");
+}
+
+} // namespace backend
+} // namespace debug
+} // namespace cobalt
diff --git a/cobalt/debug/backend/cobalt_agent.h b/cobalt/debug/backend/cobalt_agent.h
new file mode 100644
index 0000000..27f8613
--- /dev/null
+++ b/cobalt/debug/backend/cobalt_agent.h
@@ -0,0 +1,47 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef COBALT_DEBUG_BACKEND_COBALT_AGENT_H_
+#define COBALT_DEBUG_BACKEND_COBALT_AGENT_H_
+
+#include "cobalt/debug/backend/agent_base.h"
+#include "cobalt/debug/backend/debug_dispatcher.h"
+#include "cobalt/debug/command.h"
+#include "cobalt/debug/json_object.h"
+#include "cobalt/dom/window.h"
+
+namespace cobalt {
+namespace debug {
+namespace backend {
+
+// Implements a small part of the the "Runtime" inspector protocol domain with
+// just enough to support console input. When using the V8 JavaScript engine,
+// this class is not needed since the V8 inspector implements the Runtime domain
+// for us.
+//
+// https://chromedevtools.github.io/devtools-protocol/tot/Runtime
+class CobaltAgent : public AgentBase {
+ public:
+ explicit CobaltAgent(DebugDispatcher* dispatcher);
+
+ private:
+ void GetConsoleCommands(Command command);
+ void SendConsoleCommand(Command command);
+};
+
+} // namespace backend
+} // namespace debug
+} // namespace cobalt
+
+#endif // COBALT_DEBUG_BACKEND_COBALT_AGENT_H_
diff --git a/cobalt/debug/backend/debug_module.cc b/cobalt/debug/backend/debug_module.cc
index 56e8b26..ea767af 100644
--- a/cobalt/debug/backend/debug_module.cc
+++ b/cobalt/debug/backend/debug_module.cc
@@ -23,6 +23,7 @@
namespace backend {
namespace {
+constexpr char kCobaltAgent[] = "CobaltAgent";
constexpr char kScriptDebuggerAgent[] = "ScriptDebuggerAgent";
constexpr char kLogAgent[] = "LogAgent";
constexpr char kDomAgent[] = "DomAgent";
@@ -140,6 +141,7 @@
// directly handle one or more protocol domains.
script_debugger_agent_.reset(
new ScriptDebuggerAgent(debug_dispatcher_.get(), script_debugger_.get()));
+ cobalt_agent_.reset(new CobaltAgent(debug_dispatcher_.get()));
log_agent_.reset(new LogAgent(debug_dispatcher_.get()));
dom_agent_.reset(new DOMAgent(debug_dispatcher_.get()));
css_agent_ = WrapRefCounted(new CSSAgent(debug_dispatcher_.get()));
@@ -178,6 +180,7 @@
base::DictionaryValue* agents_state =
data.debugger_state == nullptr ? nullptr
: data.debugger_state->agents_state.get();
+ cobalt_agent_->Thaw(RemoveAgentState(kCobaltAgent, agents_state));
script_debugger_agent_->Thaw(
RemoveAgentState(kScriptDebuggerAgent, agents_state));
log_agent_->Thaw(RemoveAgentState(kLogAgent, agents_state));
@@ -200,6 +203,7 @@
debugger_state->agents_state.reset(new base::DictionaryValue());
base::DictionaryValue* agents_state = debugger_state->agents_state.get();
+ StoreAgentState(agents_state, kCobaltAgent, cobalt_agent_->Freeze());
StoreAgentState(agents_state, kScriptDebuggerAgent,
script_debugger_agent_->Freeze());
StoreAgentState(agents_state, kLogAgent, log_agent_->Freeze());
diff --git a/cobalt/debug/backend/debug_module.h b/cobalt/debug/backend/debug_module.h
index da1778a..4736968 100644
--- a/cobalt/debug/backend/debug_module.h
+++ b/cobalt/debug/backend/debug_module.h
@@ -20,6 +20,7 @@
#include "base/message_loop/message_loop.h"
#include "cobalt/base/debugger_hooks.h"
+#include "cobalt/debug/backend/cobalt_agent.h"
#include "cobalt/debug/backend/css_agent.h"
#include "cobalt/debug/backend/debug_backend.h"
#include "cobalt/debug/backend/debug_dispatcher.h"
@@ -134,6 +135,7 @@
// Wrappable object providing native helpers for backend JavaScript.
scoped_refptr<DebugBackend> debug_backend_;
+ std::unique_ptr<CobaltAgent> cobalt_agent_;
std::unique_ptr<LogAgent> log_agent_;
std::unique_ptr<DOMAgent> dom_agent_;
scoped_refptr<CSSAgent> css_agent_;
diff --git a/cobalt/debug/backend/log_agent.cc b/cobalt/debug/backend/log_agent.cc
index 9fc974a..593fb0a 100644
--- a/cobalt/debug/backend/log_agent.cc
+++ b/cobalt/debug/backend/log_agent.cc
@@ -14,13 +14,22 @@
#include "cobalt/debug/backend/log_agent.h"
+#include "base/bind.h"
#include "base/logging.h"
+#include "cobalt/debug/console/command_manager.h"
namespace cobalt {
namespace debug {
namespace backend {
namespace {
+const char kDebugLogCommand[] = "debug_log";
+const char kDebugLogCommandShortHelp[] =
+ "Turns browser debug logging on or off.";
+const char kDebugLogCommandLongHelp[] =
+ "When turned on, browser logs are sent in such a way that they are visible "
+ "in devtools.";
+
// Error levels:
constexpr char kInfoLevel[] = "info";
constexpr char kWarningLevel[] = "warning";
@@ -42,7 +51,21 @@
}
} // namespace
-LogAgent::LogAgent(DebugDispatcher* dispatcher) : AgentBase("Log", dispatcher) {
+void LogAgent::OnDebugLog(const std::string& message) {
+ SetDebugLog(console::ConsoleCommandManager::CommandHandler::IsOnEnableOrTrue(
+ message));
+}
+void LogAgent::SetDebugLog(bool enable) {
+ event_method_ = domain_ + (enable ? ".entryAdded" : ".browserEntryAdded");
+}
+
+LogAgent::LogAgent(DebugDispatcher* dispatcher)
+ : AgentBase("Log", dispatcher),
+ debug_log_command_handler_(
+ kDebugLogCommand,
+ base::Bind(&LogAgent::OnDebugLog, base::Unretained(this)),
+ kDebugLogCommandShortHelp, kDebugLogCommandLongHelp) {
+ SetDebugLog(false);
// Get log output while still making it available elsewhere.
log_message_handler_callback_id_ =
base::LogMessageHandler::GetInstance()->AddCallback(
@@ -63,9 +86,10 @@
// except it only shows up in the debug console and not in remote devtools.
// TODO: Flesh out the rest of LogEntry properties (source, timestamp)
JSONObject params(new base::DictionaryValue());
+ params->SetString("entry.source", "other");
params->SetString("entry.text", str);
params->SetString("entry.level", GetLogLevelFromSeverity(severity));
- dispatcher_->SendEvent(domain_ + ".browserEntryAdded", params);
+ dispatcher_->SendEvent(event_method_, params);
}
// Don't suppress the log message.
diff --git a/cobalt/debug/backend/log_agent.h b/cobalt/debug/backend/log_agent.h
index 97e6fe0..5a6fb50 100644
--- a/cobalt/debug/backend/log_agent.h
+++ b/cobalt/debug/backend/log_agent.h
@@ -19,6 +19,7 @@
#include "cobalt/base/log_message_handler.h"
#include "cobalt/debug/backend/agent_base.h"
#include "cobalt/debug/backend/debug_dispatcher.h"
+#include "cobalt/debug/console/command_manager.h"
namespace cobalt {
namespace debug {
@@ -33,6 +34,9 @@
explicit LogAgent(DebugDispatcher* dispatcher);
~LogAgent();
+ void OnDebugLog(const std::string& message);
+ void SetDebugLog(bool enable);
+
private:
// Called by LogMessageHandler for each log message.
// May be called from any thread.
@@ -46,6 +50,11 @@
// The callback id of our recipient of log messages so we can unregister it.
base::LogMessageHandler::CallbackId log_message_handler_callback_id_;
+
+ std::string event_method_;
+
+ debug::console::ConsoleCommandManager::CommandHandler
+ debug_log_command_handler_;
};
} // namespace backend
diff --git a/cobalt/debug/console/command_manager.cc b/cobalt/debug/console/command_manager.cc
index a25879a..3c30ae3 100644
--- a/cobalt/debug/console/command_manager.cc
+++ b/cobalt/debug/console/command_manager.cc
@@ -15,6 +15,7 @@
#include "cobalt/debug/console/command_manager.h"
#include "base/logging.h"
+#include "starboard/string.h"
namespace cobalt {
namespace debug {
@@ -45,6 +46,16 @@
manager->UnregisterCommandHandler(this);
}
+// Returns true if the message is 'on', 'enable', or 'true'.
+// static
+bool ConsoleCommandManager::CommandHandler::IsOnEnableOrTrue(
+ const std::string& message) {
+ return (SbStringCompareNoCase("on", message.c_str()) == 0) ||
+ (SbStringCompareNoCase("enable", message.c_str()) == 0) ||
+ (SbStringCompareNoCase("true", message.c_str()) == 0);
+}
+
+
void ConsoleCommandManager::HandleCommand(const std::string& command,
const std::string& message) const {
DCHECK_GT(command.length(), size_t(0));
diff --git a/cobalt/debug/console/command_manager.h b/cobalt/debug/console/command_manager.h
index 66a5601..1ace46c 100644
--- a/cobalt/debug/console/command_manager.h
+++ b/cobalt/debug/console/command_manager.h
@@ -61,6 +61,9 @@
const std::string& short_help() const { return short_help_; }
const std::string& long_help() const { return long_help_; }
+ // Returns true if the message is 'on', 'enable', or 'true'.
+ static bool IsOnEnableOrTrue(const std::string& message);
+
private:
std::string command_;
CommandCallback callback_;
diff --git a/cobalt/demos/content/media-element-demo/src/components/player.ts b/cobalt/demos/content/media-element-demo/src/components/player.ts
index 7bd9c17..60e3a5c 100644
--- a/cobalt/demos/content/media-element-demo/src/components/player.ts
+++ b/cobalt/demos/content/media-element-demo/src/components/player.ts
@@ -25,6 +25,18 @@
/** The <video> element. */
private videoEl!: HTMLVideoElement;
+ /** The video SourceBuffer */
+ private videoSourceBuffer!: SourceBuffer;
+
+ /** The audio SourceBuffer */
+ private audioSourceBuffer!: SourceBuffer;
+
+ /** max(videoSourceBuffer.writeHead - videoEl.currentTime) */
+ private maxVideoWriteHeadDistance!: number;
+
+ /** max(audioSourceBuffer.writeHead - videoEl.currentTime) */
+ private maxAudioWriteHeadDistance!: number;
+
/** The element displaying video download buffer info. */
private videoDownloadBufferInfo!: Element;
@@ -53,6 +65,8 @@
super(props);
this.videos = convertToMediaArray(props.video);
this.audios = convertToMediaArray(props.audio);
+ this.maxVideoWriteHeadDistance = 0;
+ this.maxAudioWriteHeadDistance = 0;
}
/** @override */
@@ -93,12 +107,37 @@
}
private renderVideoInfo() {
+ var h5vccAudioConnectors = '';
+ try {
+ h5vccAudioConnectors = this.videoEl.h5vccAudioConnectors;
+ } catch (error) {}
renderComponent(
VideoInfo, {
duration: this.videoEl.duration,
currentTime: this.videoEl.currentTime,
+ audioConnectors: h5vccAudioConnectors,
},
this.videoInfo);
+ if (this.videoSourceBuffer) {
+ this.maxVideoWriteHeadDistance =
+ Math.max(this.maxVideoWriteHeadDistance,
+ this.videoSourceBuffer.writeHead - this.videoEl.currentTime);
+ renderComponent(
+ SourceBufferInfo,
+ {name: 'Video', sourceBuffer: this.videoSourceBuffer,
+ maxWriteHeadDistance: this.maxVideoWriteHeadDistance},
+ this.videoSourceBufferInfo);
+ }
+ if (this.audioSourceBuffer) {
+ this.maxAudioWriteHeadDistance =
+ Math.max(this.maxAudioWriteHeadDistance,
+ this.audioSourceBuffer.writeHead - this.videoEl.currentTime);
+ renderComponent(
+ SourceBufferInfo,
+ {name: 'Audio', sourceBuffer: this.audioSourceBuffer,
+ maxWriteHeadDistance: this.maxAudioWriteHeadDistance},
+ this.audioSourceBufferInfo);
+ }
}
private async play() {
@@ -149,7 +188,7 @@
/**
* Plays all videos as adaptive videos.
- * TODO: dynmaically calculate the source buffer MIME.
+ * TODO: dynamically calculate the source buffer MIME.
*/
private playAdaptiveVideo() {
const ms = new MediaSource();
@@ -158,12 +197,7 @@
if (this.videos.length > 0) {
const videoSourceBuffer =
ms.addSourceBuffer('video/mp4; codecs="avc1.640028"');
- videoSourceBuffer.addEventListener('updateend', () => {
- renderComponent(
- SourceBufferInfo,
- {name: 'Video', sourceBuffer: videoSourceBuffer},
- this.videoSourceBufferInfo);
- });
+ this.videoSourceBuffer = videoSourceBuffer;
const downloadBuffer = new DownloadBuffer(this.videos);
downloadBuffer.register((reportMap) => {
renderComponent(
@@ -176,12 +210,7 @@
if (this.audios.length > 0) {
const audioSourceBuffer =
ms.addSourceBuffer('audio/mp4; codecs="mp4a.40.2"');
- audioSourceBuffer.addEventListener('updateend', () => {
- renderComponent(
- SourceBufferInfo,
- {name: 'Audio', sourceBuffer: audioSourceBuffer},
- this.audioSourceBufferInfo);
- });
+ this.audioSourceBuffer = audioSourceBuffer;
const downloadBuffer = new DownloadBuffer(this.audios);
downloadBuffer.register(
(reportMap) => {renderComponent(
diff --git a/cobalt/demos/content/media-element-demo/src/components/source_buffer_info.ts b/cobalt/demos/content/media-element-demo/src/components/source_buffer_info.ts
index 92343f3..6747f66 100644
--- a/cobalt/demos/content/media-element-demo/src/components/source_buffer_info.ts
+++ b/cobalt/demos/content/media-element-demo/src/components/source_buffer_info.ts
@@ -1,9 +1,12 @@
interface Props {
sourceBuffer: SourceBuffer;
name: string;
+ maxWriteHeadDistance: number;
}
/** A component that displays the source buffer info. */
-export function SourceBufferInfo({sourceBuffer, name}: Props) {
- return `<div>${name} buffered: ${sourceBuffer.buffered.end(0)} sec</div>`;
+export function SourceBufferInfo({sourceBuffer, name, maxWriteHeadDistance}: Props) {
+ return `<div>${name} buffered: ${sourceBuffer.buffered.end(0)} sec` +
+ `, writeHead: ${sourceBuffer.writeHead} sec` +
+ `, maxWriteHeadDistance: ${maxWriteHeadDistance} sec</div>`;
}
diff --git a/cobalt/demos/content/media-element-demo/src/components/video_info.ts b/cobalt/demos/content/media-element-demo/src/components/video_info.ts
index 3f8306f..68012c8 100644
--- a/cobalt/demos/content/media-element-demo/src/components/video_info.ts
+++ b/cobalt/demos/content/media-element-demo/src/components/video_info.ts
@@ -1,9 +1,13 @@
interface Props {
duration: number;
currentTime: number;
+ audioConnectors: string;
}
/** A component that displays video info. */
-export function VideoInfo({duration, currentTime}: Props) {
+export function VideoInfo({duration, currentTime, audioConnectors}: Props) {
+ if (audioConnectors) {
+ return `<div>${currentTime} / ${duration} / audioConnectors: ${audioConnectors}</div>`;
+ }
return `<div>${currentTime} / ${duration}</div>`;
}
diff --git a/cobalt/dom/html_media_element.cc b/cobalt/dom/html_media_element.cc
index d516ac8..054209f 100644
--- a/cobalt/dom/html_media_element.cc
+++ b/cobalt/dom/html_media_element.cc
@@ -19,6 +19,7 @@
#include <limits>
#include <memory>
#include <utility>
+#include <vector>
#include "base/bind.h"
#include "base/compiler_specific.h"
@@ -26,6 +27,7 @@
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/message_loop/message_loop.h"
+#include "base/strings/string_util.h"
#include "base/trace_event/trace_event.h"
#include "cobalt/base/instance_counter.h"
#include "cobalt/base/tokens.h"
@@ -36,6 +38,7 @@
#include "cobalt/dom/media_settings.h"
#include "cobalt/dom/media_source.h"
#include "cobalt/dom/media_source_ready_state.h"
+#include "cobalt/extension/audio_write_ahead.h"
#include "cobalt/loader/fetcher_factory.h"
#include "cobalt/media/url_fetcher_data_source.h"
#include "cobalt/media/web_media_player_factory.h"
@@ -45,6 +48,7 @@
#include "cobalt/web/dom_exception.h"
#include "cobalt/web/event.h"
#include "cobalt/web/web_settings.h"
+#include "starboard/system.h"
#include "cobalt/dom/eme/media_encrypted_event.h"
#include "cobalt/dom/eme/media_encrypted_event_init.h"
@@ -641,6 +645,32 @@
event_queue_.Enqueue(event);
}
+std::string HTMLMediaElement::h5vcc_audio_connectors(
+ script::ExceptionState* exception_state) const {
+ static const CobaltExtensionConfigurableAudioWriteAheadApi* extension_api =
+ static_cast<const CobaltExtensionConfigurableAudioWriteAheadApi*>(
+ SbSystemGetExtension(
+ kCobaltExtensionConfigurableAudioWriteAheadName));
+ if (extension_api) {
+ if (!player_) {
+ web::DOMException::Raise(web::DOMException::kInvalidStateErr,
+ exception_state);
+ return std::string();
+ }
+
+ DCHECK_EQ(extension_api->name,
+ std::string(kCobaltExtensionConfigurableAudioWriteAheadName));
+ DCHECK_EQ(extension_api->version, 1u);
+
+ std::vector<std::string> configs = player_->GetAudioConnectors();
+ return base::JoinString(configs, ";");
+ }
+
+ web::DOMException::Raise(web::DOMException::kNotSupportedErr,
+ exception_state);
+ return std::string();
+}
+
void HTMLMediaElement::CreateMediaPlayer() {
TRACE_EVENT0("cobalt::dom", "HTMLMediaElement::CreateMediaPlayer()");
LOG(INFO) << "Create media player.";
diff --git a/cobalt/dom/html_media_element.h b/cobalt/dom/html_media_element.h
index 4276fd8..612e21c 100644
--- a/cobalt/dom/html_media_element.h
+++ b/cobalt/dom/html_media_element.h
@@ -146,6 +146,12 @@
// function won't modify the target of the |event| passed in.
void ScheduleEvent(const scoped_refptr<web::Event>& event);
+ // Returns semicolon separated names of audio connectors, like
+ // "hdmi;bluetooth".
+ // TODO(b/267678497): The current interface is tentative, to be refined.
+ std::string h5vcc_audio_connectors(
+ script::ExceptionState* exception_state) const;
+
// Set max video capabilities.
void SetMaxVideoCapabilities(const std::string& max_video_capabilities,
script::ExceptionState* exception_state);
diff --git a/cobalt/dom/html_media_element.idl b/cobalt/dom/html_media_element.idl
index 4a1a509..401060a 100644
--- a/cobalt/dom/html_media_element.idl
+++ b/cobalt/dom/html_media_element.idl
@@ -61,4 +61,10 @@
attribute boolean controls;
[RaisesException] attribute double volume;
attribute boolean muted;
+
+ // non standard, semicolon separated names of audio connectors, like
+ // "hdmi;bluetooth". It raises `NotSupportedError` on apps doesn't support
+ // this feature, or `InvalidStateError` if there isn't an active playback.
+ // TODO(b/267678497): The current interface is tentative, to be refined.
+ [RaisesException] readonly attribute DOMString h5vccAudioConnectors;
};
diff --git a/cobalt/dom/source_buffer.cc b/cobalt/dom/source_buffer.cc
index 267677b..039303f 100644
--- a/cobalt/dom/source_buffer.cc
+++ b/cobalt/dom/source_buffer.cc
@@ -453,6 +453,17 @@
track_defaults_ = track_defaults;
}
+double SourceBuffer::write_head(script::ExceptionState* exception_state) const {
+ if (media_source_ == NULL) {
+ web::DOMException::Raise(web::DOMException::kInvalidStateErr,
+ exception_state);
+ return 0.0;
+ }
+
+ DCHECK(chunk_demuxer_);
+ return chunk_demuxer_->GetWriteHead(id_).InSecondsF();
+}
+
void SourceBuffer::OnRemovedFromMediaSource() {
if (media_source_ == NULL) {
return;
diff --git a/cobalt/dom/source_buffer.h b/cobalt/dom/source_buffer.h
index c611177..76d0aa7 100644
--- a/cobalt/dom/source_buffer.h
+++ b/cobalt/dom/source_buffer.h
@@ -134,6 +134,9 @@
// Custom, not in any spec.
//
+ // Return the highest presentation timestamp written to SbPlayer.
+ double write_head(script::ExceptionState* exception_state) const;
+
void OnRemovedFromMediaSource();
double GetHighestPresentationTimestamp() const;
diff --git a/cobalt/dom/source_buffer.idl b/cobalt/dom/source_buffer.idl
index 1fd8053..bb755e2 100644
--- a/cobalt/dom/source_buffer.idl
+++ b/cobalt/dom/source_buffer.idl
@@ -38,4 +38,10 @@
// [RaisesException] void abort();
[RaisesException] void remove(double start, unrestricted double end);
[RaisesException] attribute TrackDefaultList trackDefaults;
+
+ // Non standard interface (b/267678497).
+ // Returns the highest presentation timestamp written to SbPlayer, raises
+ // `InvalidStateError` if the SourceBuffer object has been removed from the
+ // MediaSource object.
+ [RaisesException] readonly attribute double writeHead;
};
diff --git a/cobalt/extension/audio_write_ahead.h b/cobalt/extension/audio_write_ahead.h
new file mode 100644
index 0000000..985b6d3
--- /dev/null
+++ b/cobalt/extension/audio_write_ahead.h
@@ -0,0 +1,75 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef COBALT_EXTENSION_AUDIO_WRITE_AHEAD_H_
+#define COBALT_EXTENSION_AUDIO_WRITE_AHEAD_H_
+
+#include "starboard/media.h"
+#include "starboard/player.h"
+#include "starboard/time.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define kCobaltExtensionConfigurableAudioWriteAheadName \
+ "dev.cobalt.extension.ConfigurableAudioWriteAhead"
+
+#define kCobaltExtensionPlayerWriteDurationLocal (kSbTimeSecond / 2)
+#define kCobaltExtensionPlayerWriteDurationRemote (kSbTimeSecond * 10)
+
+typedef enum CobaltExtensionMediaAudioConnector {
+ kCobaltExtensionMediaAudioConnectorUnknown,
+
+ kCobaltExtensionMediaAudioConnectorAnalog,
+ kCobaltExtensionMediaAudioConnectorBluetooth,
+ kCobaltExtensionMediaAudioConnectorBuiltIn,
+ kCobaltExtensionMediaAudioConnectorHdmi,
+ kCobaltExtensionMediaAudioConnectorRemoteWired,
+ kCobaltExtensionMediaAudioConnectorRemoteWireless,
+ kCobaltExtensionMediaAudioConnectorRemoteOther,
+ kCobaltExtensionMediaAudioConnectorSpdif,
+ kCobaltExtensionMediaAudioConnectorUsb,
+} CobaltExtensionMediaAudioConnector;
+
+typedef struct CobaltExtensionMediaAudioConfiguration {
+ int index;
+ CobaltExtensionMediaAudioConnector connector;
+ SbTime latency;
+ SbMediaAudioCodingType coding_type;
+ int number_of_channels;
+} CobaltExtensionMediaAudioConfiguration;
+
+typedef struct CobaltExtensionConfigurableAudioWriteAheadApi {
+ // Name should be the string
+ // |kCobaltExtensionConfigurableAudioWriteAheadName|. This helps to validate
+ // that the extension API is correct.
+ const char* name;
+
+ // This specifies the version of the API that is implemented.
+ uint32_t version;
+
+ // The fields below this point were added in version 1 or later.
+
+ bool (*PlayerGetAudioConfiguration)(
+ SbPlayer player, int index,
+ CobaltExtensionMediaAudioConfiguration* out_audio_configuration);
+
+} CobaltExtensionConfigurableAudioWriteAheadApi;
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // COBALT_EXTENSION_AUDIO_WRITE_AHEAD_H_
diff --git a/cobalt/extension/extension_test.cc b/cobalt/extension/extension_test.cc
index b6cf3bc..2dfdae9 100644
--- a/cobalt/extension/extension_test.cc
+++ b/cobalt/extension/extension_test.cc
@@ -20,6 +20,7 @@
#include "cobalt/extension/font.h"
#include "cobalt/extension/free_space.h"
#include "cobalt/extension/graphics.h"
+#include "cobalt/extension/ifa.h"
#include "cobalt/extension/installation_manager.h"
#include "cobalt/extension/javascript_cache.h"
#include "cobalt/extension/media_session.h"
@@ -382,5 +383,27 @@
EXPECT_EQ(second_extension_api, extension_api)
<< "Extension struct should be a singleton";
}
+
+TEST(ExtensionTest, Ifa) {
+ typedef StarboardExtensionIfaApi ExtensionApi;
+ const char* kExtensionName = kStarboardExtensionIfaName;
+
+ const ExtensionApi* extension_api =
+ static_cast<const ExtensionApi*>(SbSystemGetExtension(kExtensionName));
+ if (!extension_api) {
+ return;
+ }
+
+ EXPECT_STREQ(extension_api->name, kExtensionName);
+ EXPECT_EQ(extension_api->version, 1u);
+ EXPECT_NE(extension_api->GetAdvertisingId, nullptr);
+ EXPECT_NE(extension_api->GetLimitAdTracking, nullptr);
+
+ const ExtensionApi* second_extension_api =
+ static_cast<const ExtensionApi*>(SbSystemGetExtension(kExtensionName));
+ EXPECT_EQ(second_extension_api, extension_api)
+ << "Extension struct should be a singleton";
+}
+
} // namespace extension
} // namespace cobalt
diff --git a/cobalt/extension/ifa.h b/cobalt/extension/ifa.h
new file mode 100644
index 0000000..a207049
--- /dev/null
+++ b/cobalt/extension/ifa.h
@@ -0,0 +1,58 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef STARBOARD_EXTENSION_IFA_H_
+#define STARBOARD_EXTENSION_IFA_H_
+
+#include <stdint.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define kStarboardExtensionIfaName "dev.cobalt.extension.Ifa"
+
+typedef struct StarboardExtensionIfaApi {
+ // Name should be the string |kCobaltExtensionIfaName|.
+ // This helps to validate that the extension API is correct.
+ const char* name;
+
+ // This specifies the version of the API that is implemented.
+ uint32_t version;
+
+ // The fields below this point were added in version 1 or later.
+
+ // Advertising ID or IFA, typically a 128-bit UUID
+ // Please see https://iabtechlab.com/OTT-IFA for details.
+ // Corresponds to 'ifa' field. Note: `ifa_type` field is not provided.
+ // In Starboard 14 this the value is retrieved through the system
+ // property `kSbSystemPropertyAdvertisingId` defined in
+ // `starboard/system.h`.
+ bool (*GetAdvertisingId)(char* out_value, int value_length);
+
+ // Limit advertising tracking, treated as boolean. Set to nonzero to indicate
+ // a true value. Corresponds to 'lmt' field.
+ // In Starboard 14 this the value is retrieved through the system
+ // property `kSbSystemPropertyLimitAdTracking` defined in
+ // `starboard/system.h`.
+
+ bool (*GetLimitAdTracking)(char* out_value, int value_length);
+
+} CobaltExtensionIfaApi;
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+
+#endif // STARBOARD_EXTENSION_IFA_H_
diff --git a/cobalt/h5vcc/h5vcc_crash_log.cc b/cobalt/h5vcc/h5vcc_crash_log.cc
index a240d92..4088a84 100644
--- a/cobalt/h5vcc/h5vcc_crash_log.cc
+++ b/cobalt/h5vcc/h5vcc_crash_log.cc
@@ -31,70 +31,49 @@
namespace cobalt {
namespace h5vcc {
-// We keep a global mapping of all registered logs. When a crash occurs, we
-// will iterate through the mapping in this dictionary to extract all
-// logged entries and write them to the system's crash logger via Starboard.
-class CrashLogDictionary {
- public:
- static CrashLogDictionary* GetInstance() {
- return base::Singleton<CrashLogDictionary, base::DefaultSingletonTraits<
- CrashLogDictionary> >::get();
- }
+CrashLogDictionary* CrashLogDictionary::GetInstance() {
+ return base::Singleton<CrashLogDictionary, base::DefaultSingletonTraits<
+ CrashLogDictionary>>::get();
+}
- void SetString(const std::string& key, const std::string& value) {
- base::AutoLock lock(mutex_);
- // While the lock prevents contention between other calls to SetString(),
- // the atomics guard against OnCrash(), which doesn't acquire |mutex_|, from
- // accessing the data at the same time. In the case that OnCrash() is
- // being called, we give up and skip adding the data.
- if (base::subtle::Acquire_CompareAndSwap(&accessing_log_data_, 0, 1) == 0) {
- string_log_map_[key] = value;
- base::subtle::Release_Store(&accessing_log_data_, 0);
- }
+void CrashLogDictionary::SetString(const std::string& key,
+ const std::string& value) {
+ base::AutoLock lock(mutex_);
+ // While the lock prevents contention between other calls to SetString(),
+ // the atomics guard against OnCrash(), which doesn't acquire |mutex_|, from
+ // accessing the data at the same time. In the case that OnCrash() is
+ // being called, we give up and skip adding the data.
+ if (base::subtle::Acquire_CompareAndSwap(&accessing_log_data_, 0, 1) == 0) {
+ string_log_map_[key] = value;
+ base::subtle::Release_Store(&accessing_log_data_, 0);
}
+}
- private:
- CrashLogDictionary() : accessing_log_data_(0) {
+CrashLogDictionary::CrashLogDictionary() : accessing_log_data_(0) {
#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
- SbCoreDumpRegisterHandler(&CoreDumpHandler, this);
+ SbCoreDumpRegisterHandler(&CoreDumpHandler, this);
#endif
- }
+}
- static void CoreDumpHandler(void* context) {
- CrashLogDictionary* crash_log_dictionary =
- static_cast<CrashLogDictionary*>(context);
- crash_log_dictionary->OnCrash();
- }
+void CrashLogDictionary::CoreDumpHandler(void* context) {
+ CrashLogDictionary* crash_log_dictionary =
+ static_cast<CrashLogDictionary*>(context);
+ crash_log_dictionary->OnCrash();
+}
- void OnCrash() {
+void CrashLogDictionary::OnCrash() {
#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
- // Check that we're not already updating log data. If we are, we just
- // give up and skip recording any crash data, but hopefully this is rare.
- if (base::subtle::Acquire_CompareAndSwap(&accessing_log_data_, 0, 1) == 0) {
- for (StringMap::const_iterator iter = string_log_map_.begin();
- iter != string_log_map_.end(); ++iter) {
- SbCoreDumpLogString(iter->first.c_str(), iter->second.c_str());
- }
- base::subtle::Release_Store(&accessing_log_data_, 0);
+ // Check that we're not already updating log data. If we are, we just
+ // give up and skip recording any crash data, but hopefully this is rare.
+ if (base::subtle::Acquire_CompareAndSwap(&accessing_log_data_, 0, 1) == 0) {
+ for (StringMap::const_iterator iter = string_log_map_.begin();
+ iter != string_log_map_.end(); ++iter) {
+ SbCoreDumpLogString(iter->first.c_str(), iter->second.c_str());
}
-#endif
+ base::subtle::Release_Store(&accessing_log_data_, 0);
}
-
- friend struct base::DefaultSingletonTraits<CrashLogDictionary>;
-
- base::subtle::Atomic32 accessing_log_data_;
-
- // It is possible for multiple threads to call the H5VCC interface at the
- // same time, and they will all forward to this global singleton, so we
- // use this mutex to protect against concurrent access.
- base::Lock mutex_;
-
- typedef std::map<std::string, std::string> StringMap;
- // Keeps track of all string values to be logged when a crash occurs.
- StringMap string_log_map_;
-
- DISALLOW_COPY_AND_ASSIGN(CrashLogDictionary);
-};
+#endif
+}
bool H5vccCrashLog::SetString(const std::string& key,
const std::string& value) {
diff --git a/cobalt/h5vcc/h5vcc_crash_log.h b/cobalt/h5vcc/h5vcc_crash_log.h
index b85c0c5..bb20a48 100644
--- a/cobalt/h5vcc/h5vcc_crash_log.h
+++ b/cobalt/h5vcc/h5vcc_crash_log.h
@@ -15,8 +15,10 @@
#ifndef COBALT_H5VCC_H5VCC_CRASH_LOG_H_
#define COBALT_H5VCC_H5VCC_CRASH_LOG_H_
+#include <map>
#include <string>
+#include "base/memory/singleton.h"
#include "cobalt/h5vcc/h5vcc_crash_type.h"
#include "cobalt/h5vcc/watchdog_replace.h"
#include "cobalt/h5vcc/watchdog_state.h"
@@ -26,6 +28,38 @@
namespace cobalt {
namespace h5vcc {
+// We keep a global mapping of all registered logs. When a crash occurs, we
+// will iterate through the mapping in this dictionary to extract all
+// logged entries and write them to the system's crash logger via Starboard.
+class CrashLogDictionary {
+ public:
+ static CrashLogDictionary* GetInstance();
+
+ void SetString(const std::string& key, const std::string& value);
+
+ private:
+ CrashLogDictionary();
+
+ static void CoreDumpHandler(void* context);
+
+ void OnCrash();
+
+ friend struct base::DefaultSingletonTraits<CrashLogDictionary>;
+
+ base::subtle::Atomic32 accessing_log_data_;
+
+ // It is possible for multiple threads to call the H5VCC interface at the
+ // same time, and they will all forward to this global singleton, so we
+ // use this mutex to protect against concurrent access.
+ base::Lock mutex_;
+
+ typedef std::map<std::string, std::string> StringMap;
+ // Keeps track of all string values to be logged when a crash occurs.
+ StringMap string_log_map_;
+
+ DISALLOW_COPY_AND_ASSIGN(CrashLogDictionary);
+};
+
class H5vccCrashLog : public script::Wrappable {
public:
H5vccCrashLog() {}
diff --git a/cobalt/h5vcc/h5vcc_system.cc b/cobalt/h5vcc/h5vcc_system.cc
index b28e941..ad4de95 100644
--- a/cobalt/h5vcc/h5vcc_system.cc
+++ b/cobalt/h5vcc/h5vcc_system.cc
@@ -20,6 +20,10 @@
#include "cobalt_build_id.h" // NOLINT(build/include_subdir)
#include "starboard/system.h"
+#if SB_API_VERSION < 14
+#include "cobalt/extension/ifa.h"
+#endif // SB_API_VERSION < 14
+
namespace cobalt {
namespace h5vcc {
@@ -54,29 +58,58 @@
std::string H5vccSystem::advertising_id() const {
std::string result;
-#if SB_API_VERSION >= 14
const size_t kSystemPropertyMaxLength = 1024;
char property[kSystemPropertyMaxLength] = {0};
+#if SB_API_VERSION >= 14
if (!SbSystemGetProperty(kSbSystemPropertyAdvertisingId, property,
SB_ARRAY_SIZE_INT(property))) {
DLOG(FATAL) << "Failed to get kSbSystemPropertyAdvertisingId.";
} else {
result = property;
}
+#else
+ static auto const* ifa_extension =
+ static_cast<const StarboardExtensionIfaApi*>(
+ SbSystemGetExtension(kStarboardExtensionIfaName));
+ if (ifa_extension &&
+ strcmp(ifa_extension->name, kStarboardExtensionIfaName) == 0 &&
+ ifa_extension->version >= 1) {
+ if (!ifa_extension->GetAdvertisingId(property,
+ SB_ARRAY_SIZE_INT(property))) {
+ DLOG(FATAL) << "Failed to get AdvertisingId from IFA extension.";
+ } else {
+ result = property;
+ }
+ }
#endif
return result;
}
bool H5vccSystem::limit_ad_tracking() const {
bool result = false;
-#if SB_API_VERSION >= 14
const size_t kSystemPropertyMaxLength = 1024;
char property[kSystemPropertyMaxLength] = {0};
+#if SB_API_VERSION >= 14
if (!SbSystemGetProperty(kSbSystemPropertyLimitAdTracking, property,
SB_ARRAY_SIZE_INT(property))) {
DLOG(FATAL) << "Failed to get kSbSystemPropertyAdvertisingId.";
} else {
result = std::atoi(property);
}
+#else
+ static auto const* ifa_extension =
+ static_cast<const StarboardExtensionIfaApi*>(
+ SbSystemGetExtension(kStarboardExtensionIfaName));
+
+ if (ifa_extension &&
+ strcmp(ifa_extension->name, kStarboardExtensionIfaName) == 0 &&
+ ifa_extension->version >= 1) {
+ if (!ifa_extension->GetLimitAdTracking(property,
+ SB_ARRAY_SIZE_INT(property))) {
+ DLOG(FATAL) << "Failed to get LimitAdTracking from IFA extension.";
+ } else {
+ result = std::atoi(property);
+ }
+ }
#endif
return result;
}
diff --git a/cobalt/loader/image/animated_image_tracker.cc b/cobalt/loader/image/animated_image_tracker.cc
index 98dadca..c7a3e73 100644
--- a/cobalt/loader/image/animated_image_tracker.cc
+++ b/cobalt/loader/image/animated_image_tracker.cc
@@ -15,7 +15,9 @@
#include "cobalt/loader/image/animated_image_tracker.h"
#include <algorithm>
+#include <utility>
+#include "base/strings/stringprintf.h"
#include "base/trace_event/trace_event.h"
#include "cobalt/base/polymorphic_downcast.h"
@@ -24,8 +26,22 @@
namespace image {
AnimatedImageTracker::AnimatedImageTracker(
+ const char* name,
base::ThreadPriority animated_image_decode_thread_priority)
- : animated_image_decode_thread_("AnimatedImage") {
+ : animated_image_decode_thread_("AnimatedImage"),
+ name_(name),
+ count_animated_images_active(
+ base::StringPrintf("Count.%s.AnimatedImage.Active", name), 0,
+ "Total number of active animated image decoders."),
+ count_animated_frames_decoded(
+ base::StringPrintf("Count.%s.AnimatedImage.DecodedFrames", name), 0,
+ "Total number of decoded animated image frames."),
+ count_animated_frames_decoding_underrun(
+ base::StringPrintf("Count.%s.AnimatedImage.DecodingUnderruns", name),
+ 0, "Number of underruns from decoding animated images"),
+ count_animated_frames_decoding_overrun(
+ base::StringPrintf("Count.%s.AnimatedImage.DecodingOverruns", name),
+ 0, "Number of overruns from decoding animated images") {
TRACE_EVENT0("cobalt::loader::image", "AnimatedImageTracker::RecordImage()");
base::Thread::Options options(base::MessageLoop::TYPE_DEFAULT,
0 /* default stack size */);
@@ -123,6 +139,17 @@
playing_urls_.clear();
}
+void AnimatedImageTracker::OnRenderTreeRasterized() {
+ count_animated_images_active = playing_urls_.size();
+ for (const auto& playing_url : playing_urls_) {
+ auto image = image_map_[playing_url.first].get();
+ auto stats = image->GetFrameDeltaStats();
+ count_animated_frames_decoded += stats.frames_decoded;
+ count_animated_frames_decoding_underrun += stats.frames_underrun;
+ count_animated_frames_decoding_overrun += stats.frames_overrun;
+ }
+}
+
} // namespace image
} // namespace loader
} // namespace cobalt
diff --git a/cobalt/loader/image/animated_image_tracker.h b/cobalt/loader/image/animated_image_tracker.h
index f6f38e4..6df920b 100644
--- a/cobalt/loader/image/animated_image_tracker.h
+++ b/cobalt/loader/image/animated_image_tracker.h
@@ -20,6 +20,7 @@
#include "base/containers/small_map.h"
#include "base/threading/thread.h"
+#include "cobalt/base/c_val.h"
#include "cobalt/base/unused.h"
#include "cobalt/loader/image/image.h"
#include "url/gurl.h"
@@ -33,7 +34,8 @@
// playing status is updated hence decoding is turned on / off for it.
class AnimatedImageTracker {
public:
- explicit AnimatedImageTracker(
+ AnimatedImageTracker(
+ const char* name,
base::ThreadPriority animated_image_decode_thread_priority);
~AnimatedImageTracker();
@@ -54,6 +56,9 @@
// animations.
void Reset();
+ // Called from WebModule to compute image animation related stats.
+ void OnRenderTreeRasterized();
+
private:
void OnDisplayStart(loader::image::AnimatedImage* image);
void OnDisplayEnd(loader::image::AnimatedImage* image);
@@ -72,6 +77,15 @@
URLToIntMap current_url_counts_;
URLSet playing_urls_;
+ // The name of the WebModule this AnimatedImage tracker belongs to, for CVals.
+ const std::string name_;
+
+ // Animated image counters
+ base::CVal<int, base::CValPublic> count_animated_images_active;
+ base::CVal<int, base::CValPublic> count_animated_frames_decoded;
+ base::CVal<int, base::CValPublic> count_animated_frames_decoding_underrun;
+ base::CVal<int, base::CValPublic> count_animated_frames_decoding_overrun;
+
// Used to ensure that all AnimatedImageTracker methods are called on the
// same thread (*not* |animated_image_decode_thread_|), the thread that we
// were constructed on.
diff --git a/cobalt/loader/image/animated_webp_image.cc b/cobalt/loader/image/animated_webp_image.cc
index ed0b959..8689168 100644
--- a/cobalt/loader/image/animated_webp_image.cc
+++ b/cobalt/loader/image/animated_webp_image.cc
@@ -148,6 +148,8 @@
return;
}
is_playing_ = true;
+ current_stats.frames_underrun = 0;
+ current_stats.frames_overrun = 0;
if (received_first_frame_) {
StartDecoding();
@@ -171,7 +173,8 @@
void AnimatedWebPImage::StartDecoding() {
TRACE_EVENT0("cobalt::loader::image", "AnimatedWebPImage::StartDecoding()");
lock_.AssertAcquired();
- current_frame_time_ = base::TimeTicks::Now();
+ decoding_start_time_ = current_frame_time_ = base::TimeTicks::Now();
+ current_stats.frames_decoded = 0;
if (task_runner_->BelongsToCurrentThread()) {
DecodeFrames();
} else {
@@ -269,6 +272,7 @@
LOG(ERROR) << "Failed to decode WebP image frame.";
return false;
}
+ current_stats.frames_decoded++;
}
// Alpha blend the current frame on top of the buffer.
@@ -354,6 +358,7 @@
// Always wait for a consumer to consume the previous frame before moving
// forward with decoding the next frame.
if (!frame_provider_->FrameConsumed()) {
+ current_stats.frames_overrun++;
return false;
}
@@ -386,6 +391,7 @@
if (next_frame_time_ < current_time) {
// Don't let the animation fall back for more than a frame.
next_frame_time_ = current_time;
+ current_stats.frames_underrun++;
}
return true;
@@ -431,6 +437,25 @@
return target_canvas;
}
+AnimatedImage::AnimatedImageDecodingStats
+AnimatedWebPImage::GetFrameDeltaStats() {
+ AnimatedImageDecodingStats result;
+ if (current_stats.frames_decoded >= last_stats.frames_decoded) {
+ result.frames_decoded =
+ current_stats.frames_decoded - last_stats.frames_decoded;
+ result.frames_underrun =
+ current_stats.frames_underrun - last_stats.frames_underrun;
+ result.frames_overrun =
+ current_stats.frames_overrun - last_stats.frames_overrun;
+ } else {
+ // There was a reset somewhere
+ // Simply return total, this discards any overflow data we might have had.
+ result = current_stats;
+ }
+ last_stats = current_stats;
+ return result;
+}
+
} // namespace image
} // namespace loader
} // namespace cobalt
diff --git a/cobalt/loader/image/animated_webp_image.h b/cobalt/loader/image/animated_webp_image.h
index 135bf6a..4d1be04 100644
--- a/cobalt/loader/image/animated_webp_image.h
+++ b/cobalt/loader/image/animated_webp_image.h
@@ -66,6 +66,8 @@
// Returns the render image of the frame for debugging
scoped_refptr<render_tree::Image> GetFrameForDebugging(int target_frame);
+ AnimatedImageDecodingStats GetFrameDeltaStats() override;
+
private:
~AnimatedWebPImage() override;
@@ -119,12 +121,17 @@
base::CancelableClosure decode_closure_;
base::TimeTicks current_frame_time_;
base::Optional<base::TimeTicks> next_frame_time_;
+
// The original encoded data.
std::vector<uint8> data_buffer_;
scoped_refptr<render_tree::Image> current_canvas_;
scoped_refptr<FrameProvider> frame_provider_;
base::Lock lock_;
+ base::TimeTicks decoding_start_time_;
+ AnimatedImageDecodingStats current_stats;
+ AnimatedImageDecodingStats last_stats;
+
// Makes sure that the thread that sets the task_runner is always consistent.
// This is the thread sending Play()/Stop() calls, and is not necessarily
// the same thread that the task_runner itself is running on.
diff --git a/cobalt/loader/image/image.h b/cobalt/loader/image/image.h
index af99363..bac9849 100644
--- a/cobalt/loader/image/image.h
+++ b/cobalt/loader/image/image.h
@@ -145,6 +145,16 @@
image_node_builder->destination_rect = destination_rect;
image_node_builder->local_transform = local_transform;
}
+
+ // Frame counters for decoding.
+ struct AnimatedImageDecodingStats {
+ unsigned int frames_decoded = 0;
+ unsigned int frames_underrun = 0;
+ unsigned int frames_overrun = 0;
+ };
+
+ // Returns decoded frame stats since the last call, as a delta.
+ virtual AnimatedImageDecodingStats GetFrameDeltaStats() = 0;
};
} // namespace image
diff --git a/cobalt/media/base/pipeline.h b/cobalt/media/base/pipeline.h
index ccb3a1b..d2d8296 100644
--- a/cobalt/media/base/pipeline.h
+++ b/cobalt/media/base/pipeline.h
@@ -98,6 +98,7 @@
const GetDecodeTargetGraphicsContextProviderFunc&
get_decode_target_graphics_context_provider_func,
bool allow_resume_after_suspend, bool allow_batched_sample_write,
+ SbTime audio_write_duration_local, SbTime audio_write_duration_remote,
MediaLog* media_log, DecodeTargetProvider* decode_target_provider);
virtual ~Pipeline() {}
@@ -217,6 +218,9 @@
// be 0.
virtual void GetNaturalVideoSize(gfx::Size* out_size) const = 0;
+ // Gets the names of audio connectors used by the audio output.
+ virtual std::vector<std::string> GetAudioConnectors() const = 0;
+
// Return true if loading progress has been made since the last time this
// method was called.
virtual bool DidLoadingProgress() const = 0;
diff --git a/cobalt/media/base/sbplayer_bridge.cc b/cobalt/media/base/sbplayer_bridge.cc
index 10674e3..7d45642 100644
--- a/cobalt/media/base/sbplayer_bridge.cc
+++ b/cobalt/media/base/sbplayer_bridge.cc
@@ -370,6 +370,36 @@
GetInfo_Locked(video_frames_decoded, video_frames_dropped, media_time);
}
+std::vector<CobaltExtensionMediaAudioConfiguration>
+SbPlayerBridge::GetAudioConfigurations() {
+ DCHECK(sbplayer_interface_->IsAudioWriteAheadExtensionEnabled());
+ base::AutoLock auto_lock(lock_);
+
+ if (!SbPlayerIsValid(player_)) {
+ return std::vector<CobaltExtensionMediaAudioConfiguration>();
+ }
+
+ std::vector<CobaltExtensionMediaAudioConfiguration> configurations;
+
+ // Set a limit to avoid infinite loop.
+ constexpr int kMaxAudioConfigurations = 32;
+
+ for (int i = 0; i < kMaxAudioConfigurations; ++i) {
+ CobaltExtensionMediaAudioConfiguration configuration;
+ if (!sbplayer_interface_->GetAudioConfiguration(player_, i,
+ &configuration)) {
+ break;
+ }
+
+ configurations.push_back(configuration);
+ }
+
+ LOG_IF(WARNING, configurations.empty())
+ << "Failed to find any audio configurations.";
+
+ return configurations;
+}
+
#if SB_HAS(PLAYER_WITH_URL)
void SbPlayerBridge::GetUrlPlayerBufferedTimeRanges(
base::TimeDelta* buffer_start_time, base::TimeDelta* buffer_length_time) {
diff --git a/cobalt/media/base/sbplayer_bridge.h b/cobalt/media/base/sbplayer_bridge.h
index efb6ea8..80f1215 100644
--- a/cobalt/media/base/sbplayer_bridge.h
+++ b/cobalt/media/base/sbplayer_bridge.h
@@ -24,6 +24,7 @@
#include "base/message_loop/message_loop.h"
#include "base/synchronization/lock.h"
#include "base/time/time.h"
+#include "cobalt/extension/audio_write_ahead.h"
#include "cobalt/media/base/cval_stats.h"
#include "cobalt/media/base/decode_target_provider.h"
#include "cobalt/media/base/decoder_buffer_cache.h"
@@ -115,6 +116,7 @@
void SetPlaybackRate(double playback_rate);
void GetInfo(uint32* video_frames_decoded, uint32* video_frames_dropped,
base::TimeDelta* media_time);
+ std::vector<CobaltExtensionMediaAudioConfiguration> GetAudioConfigurations();
#if SB_HAS(PLAYER_WITH_URL)
void GetUrlPlayerBufferedTimeRanges(base::TimeDelta* buffer_start_time,
diff --git a/cobalt/media/base/sbplayer_interface.cc b/cobalt/media/base/sbplayer_interface.cc
index 7c44dae..968d526 100644
--- a/cobalt/media/base/sbplayer_interface.cc
+++ b/cobalt/media/base/sbplayer_interface.cc
@@ -14,9 +14,29 @@
#include "cobalt/media/base/sbplayer_interface.h"
+#include <string>
+
namespace cobalt {
namespace media {
+DefaultSbPlayerInterface::DefaultSbPlayerInterface() {
+ const CobaltExtensionConfigurableAudioWriteAheadApi* extension_api =
+ static_cast<const CobaltExtensionConfigurableAudioWriteAheadApi*>(
+ SbSystemGetExtension(
+ kCobaltExtensionConfigurableAudioWriteAheadName));
+ if (!extension_api) {
+ return;
+ }
+
+ DCHECK_EQ(extension_api->name,
+ std::string(kCobaltExtensionConfigurableAudioWriteAheadName));
+ DCHECK_EQ(extension_api->version, 1u);
+ DCHECK_NE(extension_api->PlayerGetAudioConfiguration, nullptr);
+
+ audio_write_duration_player_get_audio_configuration_ =
+ extension_api->PlayerGetAudioConfiguration;
+}
+
SbPlayer DefaultSbPlayerInterface::Create(
SbWindow window, const SbPlayerCreationParam* creation_param,
SbPlayerDeallocateSampleFunc sample_deallocate_func,
@@ -109,5 +129,17 @@
}
#endif // SB_HAS(PLAYER_WITH_URL)
+bool DefaultSbPlayerInterface::IsAudioWriteAheadExtensionEnabled() const {
+ return audio_write_duration_player_get_audio_configuration_ != nullptr;
+}
+
+bool DefaultSbPlayerInterface::GetAudioConfiguration(
+ SbPlayer player, int index,
+ CobaltExtensionMediaAudioConfiguration* out_audio_configuration) {
+ DCHECK(IsAudioWriteAheadExtensionEnabled());
+ return audio_write_duration_player_get_audio_configuration_(
+ player, index, out_audio_configuration);
+}
+
} // namespace media
} // namespace cobalt
diff --git a/cobalt/media/base/sbplayer_interface.h b/cobalt/media/base/sbplayer_interface.h
index e79c1e6..751ff11 100644
--- a/cobalt/media/base/sbplayer_interface.h
+++ b/cobalt/media/base/sbplayer_interface.h
@@ -15,6 +15,7 @@
#ifndef COBALT_MEDIA_BASE_SBPLAYER_INTERFACE_H_
#define COBALT_MEDIA_BASE_SBPLAYER_INTERFACE_H_
+#include "cobalt/extension/audio_write_ahead.h"
#include "cobalt/media/base/cval_stats.h"
#include "starboard/player.h"
@@ -68,6 +69,11 @@
SbPlayer player, SbUrlPlayerExtraInfo* out_url_player_info) = 0;
#endif // SB_HAS(PLAYER_WITH_URL)
+ virtual bool IsAudioWriteAheadExtensionEnabled() const = 0;
+ virtual bool GetAudioConfiguration(
+ SbPlayer player, int index,
+ CobaltExtensionMediaAudioConfiguration* out_audio_configuration) = 0;
+
// disabled by default, but can be enabled via h5vcc setting.
void EnableCValStats(bool should_enable) {
cval_stats_.Enable(should_enable);
@@ -77,6 +83,8 @@
class DefaultSbPlayerInterface final : public SbPlayerInterface {
public:
+ DefaultSbPlayerInterface();
+
SbPlayer Create(
SbWindow window, const SbPlayerCreationParam* creation_param,
SbPlayerDeallocateSampleFunc sample_deallocate_func,
@@ -113,6 +121,17 @@
void GetUrlPlayerExtraInfo(
SbPlayer player, SbUrlPlayerExtraInfo* out_url_player_info) override;
#endif // SB_HAS(PLAYER_WITH_URL)
+
+ bool IsAudioWriteAheadExtensionEnabled() const override;
+ bool GetAudioConfiguration(
+ SbPlayer player, int index,
+ CobaltExtensionMediaAudioConfiguration* out_audio_configuration) override;
+
+ private:
+ bool (*audio_write_duration_player_get_audio_configuration_)(
+ SbPlayer player, int index,
+ CobaltExtensionMediaAudioConfiguration* out_audio_configuration) =
+ nullptr;
};
diff --git a/cobalt/media/base/sbplayer_pipeline.cc b/cobalt/media/base/sbplayer_pipeline.cc
index 261af02..e14d0d0 100644
--- a/cobalt/media/base/sbplayer_pipeline.cc
+++ b/cobalt/media/base/sbplayer_pipeline.cc
@@ -30,12 +30,14 @@
#include "base/trace_event/trace_event.h"
#include "cobalt/base/c_val.h"
#include "cobalt/base/startup_timer.h"
+#include "cobalt/extension/audio_write_ahead.h"
#include "cobalt/math/size.h"
#include "cobalt/media/base/media_export.h"
#include "cobalt/media/base/pipeline.h"
#include "cobalt/media/base/playback_statistics.h"
#include "cobalt/media/base/sbplayer_bridge.h"
#include "cobalt/media/base/sbplayer_set_bounds_helper.h"
+#include "starboard/common/media.h"
#include "starboard/common/string.h"
#include "starboard/configuration_constants.h"
#include "starboard/time.h"
@@ -66,6 +68,7 @@
using ::media::PipelineStatistics;
using ::media::PipelineStatusCallback;
using ::media::VideoDecoderConfig;
+using ::starboard::GetCobaltExtensionMediaAudioConnectorName;
static const int kRetryDelayAtSuspendInMilliseconds = 100;
@@ -90,6 +93,35 @@
#endif // SB_HAS(PLAYER_WITH_URL)
};
+bool HasRemoteAudioOutputs(
+ const std::vector<CobaltExtensionMediaAudioConfiguration>& configurations) {
+ for (auto&& configuration : configurations) {
+ const auto connector = configuration.connector;
+ switch (connector) {
+ case kCobaltExtensionMediaAudioConnectorUnknown:
+ case kCobaltExtensionMediaAudioConnectorAnalog:
+ case kCobaltExtensionMediaAudioConnectorBuiltIn:
+ case kCobaltExtensionMediaAudioConnectorHdmi:
+ case kCobaltExtensionMediaAudioConnectorSpdif:
+ case kCobaltExtensionMediaAudioConnectorUsb:
+ LOG(INFO) << "Encountered local audio connector: "
+ << GetCobaltExtensionMediaAudioConnectorName(connector);
+ break;
+ case kCobaltExtensionMediaAudioConnectorBluetooth:
+ case kCobaltExtensionMediaAudioConnectorRemoteWired:
+ case kCobaltExtensionMediaAudioConnectorRemoteWireless:
+ case kCobaltExtensionMediaAudioConnectorRemoteOther:
+ LOG(INFO) << "Encountered remote audio connector: "
+ << GetCobaltExtensionMediaAudioConnectorName(connector);
+ return true;
+ }
+ }
+
+ LOG(INFO) << "No remote audio outputs found.";
+
+ return false;
+}
+
// SbPlayerPipeline is a PipelineBase implementation that uses the SbPlayer
// interface internally.
class MEDIA_EXPORT SbPlayerPipeline : public Pipeline,
@@ -103,6 +135,7 @@
const GetDecodeTargetGraphicsContextProviderFunc&
get_decode_target_graphics_context_provider_func,
bool allow_resume_after_suspend, bool allow_batched_sample_write,
+ SbTime audio_write_duration_local, SbTime audio_write_duration_remote,
MediaLog* media_log, DecodeTargetProvider* decode_target_provider);
~SbPlayerPipeline() override;
@@ -148,6 +181,7 @@
TimeDelta GetMediaStartDate() const override;
#endif // SB_HAS(PLAYER_WITH_URL)
void GetNaturalVideoSize(gfx::Size* out_size) const override;
+ std::vector<std::string> GetAudioConnectors() const override;
bool DidLoadingProgress() const override;
PipelineStatistics GetStatistics() const override;
@@ -322,19 +356,30 @@
DecodeTargetProvider* decode_target_provider_;
+ // The following two variables are used only when the Configurable Audio Write
+ // Ahead extension is enabled.
+ SbTime audio_write_duration_local_;
+ SbTime audio_write_duration_remote_;
+
+ // When the Configurable Audio Write Ahead extension is enabled,
+ // the two variables below should always contain the same value.
+ //
// Read audio from the stream if |timestamp_of_last_written_audio_| is less
- // than |seek_time_| + |kAudioPrerollLimit|, this effectively allows 10
- // seconds of audio to be written to the SbPlayer after playback startup or
- // seek.
- static const SbTime kAudioPrerollLimit = 10 * kSbTimeSecond;
- // Don't read audio from the stream more than |kAudioLimit| ahead of the
- // current media time during playing.
- static const SbTime kAudioLimit = kSbTimeSecond;
+ // than |seek_time_| + |audio_write_duration_for_preroll_|. When the
+ // Configurable Audio Write Ahead extension is disabled, this effectively
+ // allows 10 seconds of audio to be written to the SbPlayer after playback
+ // startup or seek.
+ SbTime audio_write_duration_ = kSbTimeSecond;
+ // Don't read audio from the stream more than |audio_write_duration_| ahead of
+ // the current media time during playing.
+ SbTime audio_write_duration_for_preroll_ = 10 * kSbTimeSecond;
+
// Only call GetMediaTime() from OnNeedData if it has been
// |kMediaTimeCheckInterval| since the last call to GetMediaTime().
static const SbTime kMediaTimeCheckInterval = 0.1 * kSbTimeSecond;
// Timestamp for the last written audio.
SbTime timestamp_of_last_written_audio_ = 0;
+
// Last media time reported by GetMediaTime().
base::CVal<SbTime> last_media_time_;
// Time when we last checked the media time.
@@ -357,6 +402,7 @@
const GetDecodeTargetGraphicsContextProviderFunc&
get_decode_target_graphics_context_provider_func,
bool allow_resume_after_suspend, bool allow_batched_sample_write,
+ SbTime audio_write_duration_local, SbTime audio_write_duration_remote,
MediaLog* media_log, DecodeTargetProvider* decode_target_provider)
: pipeline_identifier_(
base::StringPrintf("%X", g_pipeline_identifier_counter++)),
@@ -406,7 +452,16 @@
pipeline_identifier_.c_str()),
"", "The max video capabilities required for the media pipeline."),
playback_statistics_(pipeline_identifier_) {
- SbMediaSetAudioWriteDuration(kAudioLimit);
+ SbMediaSetAudioWriteDuration(audio_write_duration_);
+ DCHECK(sbplayer_interface_);
+ if (sbplayer_interface_->IsAudioWriteAheadExtensionEnabled()) {
+ audio_write_duration_local_ = audio_write_duration_local;
+ audio_write_duration_remote_ = audio_write_duration_remote;
+ } else {
+ LOG(INFO) << "Setting audio write duration to " << audio_write_duration_
+ << ", the duration during preroll is "
+ << audio_write_duration_for_preroll_;
+ }
}
SbPlayerPipeline::~SbPlayerPipeline() { DCHECK(!player_bridge_); }
@@ -571,6 +626,8 @@
if (demuxer_) {
stop_cb_ = stop_cb;
demuxer_->Stop();
+ video_stream_ = nullptr;
+ audio_stream_ = nullptr;
OnDemuxerStopped();
} else {
stop_cb.Run();
@@ -780,6 +837,27 @@
*out_size = natural_size_;
}
+std::vector<std::string> SbPlayerPipeline::GetAudioConnectors() const {
+ if (sbplayer_interface_->IsAudioWriteAheadExtensionEnabled()) {
+ base::AutoLock auto_lock(lock_);
+ if (!player_bridge_) {
+ return std::vector<std::string>();
+ }
+
+ std::vector<std::string> connectors;
+
+ auto configurations = player_bridge_->GetAudioConfigurations();
+ for (auto&& configuration : configurations) {
+ connectors.push_back(
+ GetCobaltExtensionMediaAudioConnectorName(configuration.connector));
+ }
+
+ return connectors;
+ }
+
+ return std::vector<std::string>();
+}
+
bool SbPlayerPipeline::DidLoadingProgress() const {
base::AutoLock auto_lock(lock_);
bool ret = did_loading_progress_;
@@ -1035,6 +1113,18 @@
*decode_to_texture_output_mode_, decode_target_provider_,
max_video_capabilities_, pipeline_identifier_));
if (player_bridge_->IsValid()) {
+ if (sbplayer_interface_->IsAudioWriteAheadExtensionEnabled()) {
+ // TODO(b/267678497): When `player_bridge_->GetAudioConfigurations()`
+ // returns no audio configurations, update the write durations again
+ // before the SbPlayer reaches `kSbPlayerStatePresenting`.
+ audio_write_duration_for_preroll_ = audio_write_duration_ =
+ HasRemoteAudioOutputs(player_bridge_->GetAudioConfigurations())
+ ? audio_write_duration_remote_
+ : audio_write_duration_local_;
+ LOG(INFO) << "SbPlayerBridge created, with audio write duration at "
+ << audio_write_duration_for_preroll_;
+ }
+
SetPlaybackRateTask(playback_rate_);
SetVolumeTask(volume_);
} else {
@@ -1268,17 +1358,18 @@
GetMediaTime();
}
- // Delay reading audio more than |kAudioLimit| ahead of playback after the
- // player has received enough audio for preroll, taking into account that
- // our estimate of playback time might be behind by
+ // Delay reading audio more than |audio_write_duration_| ahead of playback
+ // after the player has received enough audio for preroll, taking into
+ // account that our estimate of playback time might be behind by
// |kMediaTimeCheckInterval|.
if (timestamp_of_last_written_audio_ - seek_time_.ToSbTime() >
- kAudioPrerollLimit) {
+ audio_write_duration_for_preroll_) {
// The estimated time ahead of playback may be negative if no audio has
// been written.
SbTime time_ahead_of_playback =
timestamp_of_last_written_audio_ - last_media_time_;
- if (time_ahead_of_playback > (kAudioLimit + kMediaTimeCheckInterval)) {
+ if (time_ahead_of_playback >
+ (audio_write_duration_ + kMediaTimeCheckInterval)) {
task_runner_->PostDelayedTask(
FROM_HERE,
base::Bind(&SbPlayerPipeline::DelayedNeedData, this, max_buffers),
@@ -1348,6 +1439,15 @@
playback_statistics_.OnPresenting(
video_stream_->video_decoder_config());
}
+ if (sbplayer_interface_->IsAudioWriteAheadExtensionEnabled()) {
+ audio_write_duration_for_preroll_ = audio_write_duration_ =
+ HasRemoteAudioOutputs(player_bridge_->GetAudioConfigurations())
+ ? audio_write_duration_remote_
+ : audio_write_duration_local_;
+ LOG(INFO)
+ << "SbPlayerBridge reaches kSbPlayerStatePresenting, with audio"
+ << " write duration at " << audio_write_duration_;
+ }
break;
}
case kSbPlayerStateEndOfStream:
@@ -1535,6 +1635,8 @@
std::string SbPlayerPipeline::AppendStatisticsString(
const std::string& message) const {
+ DCHECK(task_runner_->BelongsToCurrentThread());
+
if (nullptr == video_stream_) {
return message + ", playback statistics: n/a.";
} else {
@@ -1602,12 +1704,14 @@
const GetDecodeTargetGraphicsContextProviderFunc&
get_decode_target_graphics_context_provider_func,
bool allow_resume_after_suspend, bool allow_batched_sample_write,
+ SbTime audio_write_duration_local, SbTime audio_write_duration_remote,
MediaLog* media_log, DecodeTargetProvider* decode_target_provider) {
- return new SbPlayerPipeline(interface, window, task_runner,
- get_decode_target_graphics_context_provider_func,
- allow_resume_after_suspend,
- allow_batched_sample_write, media_log,
- decode_target_provider);
+ return new SbPlayerPipeline(
+ interface, window, task_runner,
+ get_decode_target_graphics_context_provider_func,
+ allow_resume_after_suspend, allow_batched_sample_write,
+ audio_write_duration_local, audio_write_duration_remote, media_log,
+ decode_target_provider);
}
} // namespace media
diff --git a/cobalt/media/media_module.cc b/cobalt/media/media_module.cc
index 95965a5..aedc5c6 100644
--- a/cobalt/media/media_module.cc
+++ b/cobalt/media/media_module.cc
@@ -194,6 +194,18 @@
LOG(INFO) << (value ? "Enabling" : "Disabling")
<< " media metrics collection.";
return true;
+ } else if (sbplayer_interface_->IsAudioWriteAheadExtensionEnabled()) {
+ if (name == "AudioWriteDurationLocal" && value > 0) {
+ audio_write_duration_local_ = value;
+ LOG(INFO) << "Set AudioWriteDurationLocal to "
+ << audio_write_duration_local_;
+ return true;
+ } else if (name == "AudioWriteDurationRemote" && value > 0) {
+ audio_write_duration_remote_ = value;
+ LOG(INFO) << "Set AudioWriteDurationRemote to "
+ << audio_write_duration_remote_;
+ return true;
+ }
}
return false;
}
@@ -206,12 +218,21 @@
window = system_window_->GetSbWindow();
}
+ SbTime audio_write_duration_local = -1;
+ SbTime audio_write_duration_remote = -1;
+
+ if (sbplayer_interface_->IsAudioWriteAheadExtensionEnabled()) {
+ audio_write_duration_local = audio_write_duration_local_;
+ audio_write_duration_remote = audio_write_duration_remote_;
+ }
+
return std::unique_ptr<WebMediaPlayer>(new media::WebMediaPlayerImpl(
sbplayer_interface_.get(), window,
base::Bind(&MediaModule::GetSbDecodeTargetGraphicsContextProvider,
base::Unretained(this)),
client, this, options_.allow_resume_after_suspend,
- allow_batched_sample_write_, &media_log_));
+ allow_batched_sample_write_, audio_write_duration_local,
+ audio_write_duration_remote, &media_log_));
}
void MediaModule::Suspend() {
diff --git a/cobalt/media/media_module.h b/cobalt/media/media_module.h
index 6ca47b8..f4c2594 100644
--- a/cobalt/media/media_module.h
+++ b/cobalt/media/media_module.h
@@ -24,6 +24,7 @@
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/optional.h"
+#include "cobalt/extension/audio_write_ahead.h"
#include "cobalt/math/size.h"
#include "cobalt/media/base/sbplayer_interface.h"
#include "cobalt/media/can_play_type_handler.h"
@@ -123,6 +124,12 @@
bool allow_batched_sample_write_ = false;
+ // The following two variables are used only when the Configurable Audio Write
+ // Ahead extension is enabled.
+ SbTime audio_write_duration_local_ = kCobaltExtensionPlayerWriteDurationLocal;
+ SbTime audio_write_duration_remote_ =
+ kCobaltExtensionPlayerWriteDurationRemote;
+
DecoderBufferAllocator decoder_buffer_allocator_;
};
diff --git a/cobalt/media/player/web_media_player.h b/cobalt/media/player/web_media_player.h
index 1322473..459ec6e 100644
--- a/cobalt/media/player/web_media_player.h
+++ b/cobalt/media/player/web_media_player.h
@@ -130,6 +130,9 @@
virtual int GetNaturalWidth() const = 0;
virtual int GetNaturalHeight() const = 0;
+ // Names of audio connectors used by the playback.
+ virtual std::vector<std::string> GetAudioConnectors() const = 0;
+
// Getters of playback state.
virtual bool IsPaused() const = 0;
virtual bool IsSeeking() const = 0;
diff --git a/cobalt/media/player/web_media_player_impl.cc b/cobalt/media/player/web_media_player_impl.cc
index 8073366..8f9ba9a 100644
--- a/cobalt/media/player/web_media_player_impl.cc
+++ b/cobalt/media/player/web_media_player_impl.cc
@@ -118,6 +118,7 @@
get_decode_target_graphics_context_provider_func,
WebMediaPlayerClient* client, WebMediaPlayerDelegate* delegate,
bool allow_resume_after_suspend, bool allow_batched_sample_write,
+ SbTime audio_write_duration_local, SbTime audio_write_duration_remote,
::media::MediaLog* const media_log)
: pipeline_thread_("media_pipeline"),
network_state_(WebMediaPlayer::kNetworkStateEmpty),
@@ -146,6 +147,7 @@
Pipeline::Create(interface, window, pipeline_thread_.task_runner(),
get_decode_target_graphics_context_provider_func,
allow_resume_after_suspend_, allow_batched_sample_write_,
+ audio_write_duration_local, audio_write_duration_remote,
media_log_, decode_target_provider_.get());
// Also we want to be notified of |main_loop_| destruction.
@@ -428,6 +430,11 @@
return size.height();
}
+std::vector<std::string> WebMediaPlayerImpl::GetAudioConnectors() const {
+ DCHECK_EQ(main_loop_, base::MessageLoop::current());
+ return pipeline_->GetAudioConnectors();
+}
+
bool WebMediaPlayerImpl::IsPaused() const {
DCHECK_EQ(main_loop_, base::MessageLoop::current());
diff --git a/cobalt/media/player/web_media_player_impl.h b/cobalt/media/player/web_media_player_impl.h
index b64f318..9139ce8 100644
--- a/cobalt/media/player/web_media_player_impl.h
+++ b/cobalt/media/player/web_media_player_impl.h
@@ -110,6 +110,8 @@
WebMediaPlayerDelegate* delegate,
bool allow_resume_after_suspend,
bool allow_batched_sample_write,
+ SbTime audio_write_duration_local,
+ SbTime audio_write_duration_remote,
::media::MediaLog* const media_log);
~WebMediaPlayerImpl() override;
@@ -146,6 +148,9 @@
int GetNaturalWidth() const override;
int GetNaturalHeight() const override;
+ // Names of audio connectors used by the playback.
+ std::vector<std::string> GetAudioConnectors() const override;
+
// Getters of playback state.
bool IsPaused() const override;
bool IsSeeking() const override;
diff --git a/cobalt/persistent_storage/persistent_settings.cc b/cobalt/persistent_storage/persistent_settings.cc
index c4db368..c93ff54 100644
--- a/cobalt/persistent_storage/persistent_settings.cc
+++ b/cobalt/persistent_storage/persistent_settings.cc
@@ -201,7 +201,7 @@
void PersistentSettings::SetPersistentSetting(
const std::string& key, std::unique_ptr<base::Value> value,
- base::OnceClosure closure) {
+ base::OnceClosure closure, bool blocking) {
if (key == kValidated) {
LOG(ERROR) << "Cannot set protected persistent setting: " << key;
return;
@@ -209,12 +209,12 @@
message_loop()->task_runner()->PostTask(
FROM_HERE, base::BindOnce(&PersistentSettings::SetPersistentSettingHelper,
base::Unretained(this), key, std::move(value),
- std::move(closure)));
+ std::move(closure), blocking));
}
void PersistentSettings::SetPersistentSettingHelper(
const std::string& key, std::unique_ptr<base::Value> value,
- base::OnceClosure closure) {
+ base::OnceClosure closure, bool blocking) {
DCHECK_EQ(base::MessageLoop::current(), message_loop());
if (validated_initial_settings_) {
base::AutoLock auto_lock(pref_store_lock_);
@@ -223,7 +223,7 @@
WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
writeable_pref_store()->SetValue(
key, std::move(value), WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
- writeable_pref_store()->CommitPendingWrite();
+ commit_pending_write(blocking);
} else {
LOG(ERROR) << "Cannot set persistent setting while unvalidated: " << key;
}
@@ -231,15 +231,17 @@
}
void PersistentSettings::RemovePersistentSetting(const std::string& key,
- base::OnceClosure closure) {
+ base::OnceClosure closure,
+ bool blocking) {
message_loop()->task_runner()->PostTask(
FROM_HERE,
base::BindOnce(&PersistentSettings::RemovePersistentSettingHelper,
- base::Unretained(this), key, std::move(closure)));
+ base::Unretained(this), key, std::move(closure),
+ blocking));
}
void PersistentSettings::RemovePersistentSettingHelper(
- const std::string& key, base::OnceClosure closure) {
+ const std::string& key, base::OnceClosure closure, bool blocking) {
DCHECK_EQ(base::MessageLoop::current(), message_loop());
if (validated_initial_settings_) {
base::AutoLock auto_lock(pref_store_lock_);
@@ -248,7 +250,7 @@
WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
writeable_pref_store()->RemoveValue(
key, WriteablePrefStore::DEFAULT_PREF_WRITE_FLAGS);
- writeable_pref_store()->CommitPendingWrite();
+ commit_pending_write(blocking);
} else {
LOG(ERROR) << "Cannot remove persistent setting while unvalidated: " << key;
}
diff --git a/cobalt/persistent_storage/persistent_settings.h b/cobalt/persistent_storage/persistent_settings.h
index 0cf789f..ff3ea58 100644
--- a/cobalt/persistent_storage/persistent_settings.h
+++ b/cobalt/persistent_storage/persistent_settings.h
@@ -71,11 +71,13 @@
void SetPersistentSetting(
const std::string& key, std::unique_ptr<base::Value> value,
- base::OnceClosure closure = std::move(base::DoNothing()));
+ base::OnceClosure closure = std::move(base::DoNothing()),
+ bool blocking = false);
void RemovePersistentSetting(
const std::string& key,
- base::OnceClosure closure = std::move(base::DoNothing()));
+ base::OnceClosure closure = std::move(base::DoNothing()),
+ bool blocking = false);
void DeletePersistentSettings(
base::OnceClosure closure = std::move(base::DoNothing()));
@@ -89,10 +91,10 @@
void SetPersistentSettingHelper(const std::string& key,
std::unique_ptr<base::Value> value,
- base::OnceClosure closure);
+ base::OnceClosure closure, bool blocking);
void RemovePersistentSettingHelper(const std::string& key,
- base::OnceClosure closure);
+ base::OnceClosure closure, bool blocking);
void DeletePersistentSettingsHelper(base::OnceClosure closure);
@@ -101,6 +103,18 @@
return pref_store_;
}
+ void commit_pending_write(bool blocking) {
+ if (blocking) {
+ base::WaitableEvent written;
+ writeable_pref_store()->CommitPendingWrite(
+ base::OnceClosure(),
+ base::BindOnce(&base::WaitableEvent::Signal, Unretained(&written)));
+ written.Wait();
+ } else {
+ writeable_pref_store()->CommitPendingWrite();
+ }
+ }
+
// Persistent settings file path.
std::string persistent_settings_file_;
diff --git a/cobalt/persistent_storage/persistent_settings_test.cc b/cobalt/persistent_storage/persistent_settings_test.cc
index 3f88397..91b2bce 100644
--- a/cobalt/persistent_storage/persistent_settings_test.cc
+++ b/cobalt/persistent_storage/persistent_settings_test.cc
@@ -12,6 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+#include "cobalt/persistent_storage/persistent_settings.h"
+
#include <utility>
#include <vector>
@@ -20,9 +22,7 @@
#include "base/callback_forward.h"
#include "base/synchronization/waitable_event.h"
#include "base/test/scoped_task_environment.h"
-#include "base/threading/platform_thread.h"
#include "base/values.h"
-#include "cobalt/persistent_storage/persistent_settings.h"
#include "starboard/common/file.h"
#include "starboard/common/log.h"
#include "starboard/configuration_constants.h"
@@ -81,13 +81,13 @@
base::OnceClosure closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsInt("key", true));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(4.2), std::move(closure));
+ "key", std::make_unique<base::Value>(4.2), std::move(closure), true);
test_done_.Wait();
}
@@ -99,32 +99,32 @@
base::OnceClosure closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsBool("key", true));
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsBool("key", false));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(true), std::move(closure));
+ "key", std::make_unique<base::Value>(true), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_FALSE(
+ EXPECT_FALSE(
persistent_settings->GetPersistentSettingAsBool("key", true));
- ASSERT_FALSE(
+ EXPECT_FALSE(
persistent_settings->GetPersistentSettingAsBool("key", false));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(false), std::move(closure));
+ "key", std::make_unique<base::Value>(false), std::move(closure), true);
test_done_.Wait();
}
@@ -143,13 +143,13 @@
base::OnceClosure closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_EQ(8, persistent_settings->GetPersistentSettingAsInt("key", 8));
+ EXPECT_EQ(8, persistent_settings->GetPersistentSettingAsInt("key", 8));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(4.2), std::move(closure));
+ "key", std::make_unique<base::Value>(4.2), std::move(closure), true);
test_done_.Wait();
}
@@ -161,36 +161,36 @@
base::OnceClosure closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_EQ(-1, persistent_settings->GetPersistentSettingAsInt("key", 8));
+ EXPECT_EQ(-1, persistent_settings->GetPersistentSettingAsInt("key", 8));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(-1), std::move(closure));
+ "key", std::make_unique<base::Value>(-1), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_EQ(0, persistent_settings->GetPersistentSettingAsInt("key", 8));
+ EXPECT_EQ(0, persistent_settings->GetPersistentSettingAsInt("key", 8));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(0), std::move(closure));
+ "key", std::make_unique<base::Value>(0), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_EQ(42, persistent_settings->GetPersistentSettingAsInt("key", 8));
+ EXPECT_EQ(42, persistent_settings->GetPersistentSettingAsInt("key", 8));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(42), std::move(closure));
+ "key", std::make_unique<base::Value>(42), std::move(closure), true);
test_done_.Wait();
}
@@ -214,13 +214,13 @@
base::OnceClosure closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_EQ("hello", persistent_settings->GetPersistentSettingAsString(
+ EXPECT_EQ("hello", persistent_settings->GetPersistentSettingAsString(
"key", "hello"));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(4.2), std::move(closure));
+ "key", std::make_unique<base::Value>(4.2), std::move(closure), true);
test_done_.Wait();
}
@@ -232,21 +232,21 @@
base::OnceClosure closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_EQ("", persistent_settings->GetPersistentSettingAsString(
+ EXPECT_EQ("", persistent_settings->GetPersistentSettingAsString(
"key", "hello"));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(""), std::move(closure));
+ "key", std::make_unique<base::Value>(""), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_EQ(
+ EXPECT_EQ(
"hello there",
persistent_settings->GetPersistentSettingAsString("key", "hello"));
test_done->Signal();
@@ -254,46 +254,47 @@
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>("hello there"), std::move(closure));
+ "key", std::make_unique<base::Value>("hello there"), std::move(closure),
+ true);
test_done_.Wait();
test_done_.Reset();
closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_EQ("42", persistent_settings->GetPersistentSettingAsString(
+ EXPECT_EQ("42", persistent_settings->GetPersistentSettingAsString(
"key", "hello"));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>("42"), std::move(closure));
+ "key", std::make_unique<base::Value>("42"), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_EQ("\n", persistent_settings->GetPersistentSettingAsString(
+ EXPECT_EQ("\n", persistent_settings->GetPersistentSettingAsString(
"key", "hello"));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>("\n"), std::move(closure));
+ "key", std::make_unique<base::Value>("\n"), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_EQ("\\n", persistent_settings->GetPersistentSettingAsString(
+ EXPECT_EQ("\\n", persistent_settings->GetPersistentSettingAsString(
"key", "hello"));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>("\\n"), std::move(closure));
+ "key", std::make_unique<base::Value>("\\n"), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
}
@@ -307,10 +308,10 @@
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
auto test_list = persistent_settings->GetPersistentSettingAsList("key");
- ASSERT_FALSE(test_list.empty());
- ASSERT_EQ(1, test_list.size());
- ASSERT_TRUE(test_list[0].is_string());
- ASSERT_EQ("hello", test_list[0].GetString());
+ EXPECT_FALSE(test_list.empty());
+ EXPECT_EQ(1, test_list.size());
+ EXPECT_TRUE(test_list[0].is_string());
+ EXPECT_EQ("hello", test_list[0].GetString());
test_done->Signal();
},
persistent_settings.get(), &test_done_);
@@ -318,7 +319,7 @@
std::vector<base::Value> list;
list.emplace_back("hello");
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(list), std::move(closure));
+ "key", std::make_unique<base::Value>(list), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
@@ -326,19 +327,19 @@
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
auto test_list = persistent_settings->GetPersistentSettingAsList("key");
- ASSERT_FALSE(test_list.empty());
- ASSERT_EQ(2, test_list.size());
- ASSERT_TRUE(test_list[0].is_string());
- ASSERT_EQ("hello", test_list[0].GetString());
- ASSERT_TRUE(test_list[1].is_string());
- ASSERT_EQ("there", test_list[1].GetString());
+ EXPECT_FALSE(test_list.empty());
+ EXPECT_EQ(2, test_list.size());
+ EXPECT_TRUE(test_list[0].is_string());
+ EXPECT_EQ("hello", test_list[0].GetString());
+ EXPECT_TRUE(test_list[1].is_string());
+ EXPECT_EQ("there", test_list[1].GetString());
test_done->Signal();
},
persistent_settings.get(), &test_done_);
list.emplace_back("there");
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(list), std::move(closure));
+ "key", std::make_unique<base::Value>(list), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
@@ -346,21 +347,21 @@
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
auto test_list = persistent_settings->GetPersistentSettingAsList("key");
- ASSERT_FALSE(test_list.empty());
- ASSERT_EQ(3, test_list.size());
- ASSERT_TRUE(test_list[0].is_string());
- ASSERT_EQ("hello", test_list[0].GetString());
- ASSERT_TRUE(test_list[1].is_string());
- ASSERT_EQ("there", test_list[1].GetString());
- ASSERT_TRUE(test_list[2].is_int());
- ASSERT_EQ(42, test_list[2].GetInt());
+ EXPECT_FALSE(test_list.empty());
+ EXPECT_EQ(3, test_list.size());
+ EXPECT_TRUE(test_list[0].is_string());
+ EXPECT_EQ("hello", test_list[0].GetString());
+ EXPECT_TRUE(test_list[1].is_string());
+ EXPECT_EQ("there", test_list[1].GetString());
+ EXPECT_TRUE(test_list[2].is_int());
+ EXPECT_EQ(42, test_list[2].GetInt());
test_done->Signal();
},
persistent_settings.get(), &test_done_);
list.emplace_back(42);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(list), std::move(closure));
+ "key", std::make_unique<base::Value>(list), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
}
@@ -375,10 +376,10 @@
base::WaitableEvent* test_done) {
auto test_dict =
persistent_settings->GetPersistentSettingAsDictionary("key");
- ASSERT_FALSE(test_dict.empty());
- ASSERT_EQ(1, test_dict.size());
- ASSERT_TRUE(test_dict["key_string"]->is_string());
- ASSERT_EQ("hello", test_dict["key_string"]->GetString());
+ EXPECT_FALSE(test_dict.empty());
+ EXPECT_EQ(1, test_dict.size());
+ EXPECT_TRUE(test_dict["key_string"]->is_string());
+ EXPECT_EQ("hello", test_dict["key_string"]->GetString());
test_done->Signal();
},
persistent_settings.get(), &test_done_);
@@ -386,7 +387,7 @@
base::flat_map<std::string, std::unique_ptr<base::Value>> dict;
dict.try_emplace("key_string", std::make_unique<base::Value>("hello"));
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(dict), std::move(closure));
+ "key", std::make_unique<base::Value>(dict), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
@@ -395,19 +396,19 @@
base::WaitableEvent* test_done) {
auto test_dict =
persistent_settings->GetPersistentSettingAsDictionary("key");
- ASSERT_FALSE(test_dict.empty());
- ASSERT_EQ(2, test_dict.size());
- ASSERT_TRUE(test_dict["key_string"]->is_string());
- ASSERT_EQ("hello", test_dict["key_string"]->GetString());
- ASSERT_TRUE(test_dict["key_int"]->is_int());
- ASSERT_EQ(42, test_dict["key_int"]->GetInt());
+ EXPECT_FALSE(test_dict.empty());
+ EXPECT_EQ(2, test_dict.size());
+ EXPECT_TRUE(test_dict["key_string"]->is_string());
+ EXPECT_EQ("hello", test_dict["key_string"]->GetString());
+ EXPECT_TRUE(test_dict["key_int"]->is_int());
+ EXPECT_EQ(42, test_dict["key_int"]->GetInt());
test_done->Signal();
},
persistent_settings.get(), &test_done_);
dict.try_emplace("key_int", std::make_unique<base::Value>(42));
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(dict), std::move(closure));
+ "key", std::make_unique<base::Value>(dict), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
}
@@ -425,10 +426,10 @@
base::WaitableEvent* test_done) {
auto test_dict = persistent_settings->GetPersistentSettingAsDictionary(
"http://127.0.0.1:45019/");
- ASSERT_FALSE(test_dict.empty());
- ASSERT_EQ(1, test_dict.size());
- ASSERT_TRUE(test_dict["http://127.0.0.1:45019/"]->is_string());
- ASSERT_EQ("Dictionary URL Key Works!",
+ EXPECT_FALSE(test_dict.empty());
+ EXPECT_EQ(1, test_dict.size());
+ EXPECT_TRUE(test_dict["http://127.0.0.1:45019/"]->is_string());
+ EXPECT_EQ("Dictionary URL Key Works!",
test_dict["http://127.0.0.1:45019/"]->GetString());
test_done->Signal();
},
@@ -441,7 +442,7 @@
std::make_unique<base::Value>("Dictionary URL Key Works!"));
persistent_settings->SetPersistentSetting("http://127.0.0.1:45019/",
std::make_unique<base::Value>(dict),
- std::move(closure));
+ std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
@@ -450,12 +451,12 @@
base::WaitableEvent* test_done) {
auto test_dict = persistent_settings->GetPersistentSettingAsDictionary(
"http://127.0.0.1:45019/");
- ASSERT_TRUE(test_dict.empty());
+ EXPECT_TRUE(test_dict.empty());
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->RemovePersistentSetting("http://127.0.0.1:45019/",
- std::move(closure));
+ std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
}
@@ -471,29 +472,29 @@
base::OnceClosure closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsBool("key", true));
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsBool("key", false));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(true), std::move(closure));
+ "key", std::make_unique<base::Value>(true), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsBool("key", true));
- ASSERT_FALSE(
+ EXPECT_FALSE(
persistent_settings->GetPersistentSettingAsBool("key", false));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
- persistent_settings->RemovePersistentSetting("key", std::move(closure));
+ persistent_settings->RemovePersistentSetting("key", std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
}
@@ -509,24 +510,24 @@
base::OnceClosure closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsBool("key", true));
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsBool("key", false));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(true), std::move(closure));
+ "key", std::make_unique<base::Value>(true), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsBool("key", true));
- ASSERT_FALSE(
+ EXPECT_FALSE(
persistent_settings->GetPersistentSettingAsBool("key", false));
test_done->Signal();
},
@@ -547,22 +548,18 @@
base::OnceClosure closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsBool("key", true));
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsBool("key", false));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(true), std::move(closure));
+ "key", std::make_unique<base::Value>(true), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
- // Sleep for one second to allow for the previous persistent_setting's
- // JsonPrefStore instance time to write to disk before creating a new
- // persistent_settings and JsonPrefStore instance.
- base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
persistent_settings =
std::make_unique<PersistentSettings>(kPersistentSettingsJson);
ASSERT_TRUE(persistent_settings->GetPersistentSettingAsBool("key", true));
@@ -571,15 +568,15 @@
closure = base::BindOnce(
[](PersistentSettings* persistent_settings,
base::WaitableEvent* test_done) {
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsBool("key", true));
- ASSERT_TRUE(
+ EXPECT_TRUE(
persistent_settings->GetPersistentSettingAsBool("key", false));
test_done->Signal();
},
persistent_settings.get(), &test_done_);
persistent_settings->SetPersistentSetting(
- "key", std::make_unique<base::Value>(false), std::move(closure));
+ "key", std::make_unique<base::Value>(false), std::move(closure), true);
test_done_.Wait();
test_done_.Reset();
diff --git a/cobalt/version.h b/cobalt/version.h
index 3182bc9..74f79af 100644
--- a/cobalt/version.h
+++ b/cobalt/version.h
@@ -35,6 +35,6 @@
// release is cut.
//.
-#define COBALT_VERSION "23.lts.5"
+#define COBALT_VERSION "23.lts.6"
#endif // COBALT_VERSION_H_
diff --git a/docker-compose-windows.yml b/docker-compose-windows.yml
index e577ee4..c60c372 100644
--- a/docker-compose-windows.yml
+++ b/docker-compose-windows.yml
@@ -98,3 +98,14 @@
depends_on:
- cobalt-build-win32-base
image: cobalt-build-win-win32
+
+ runner-win-win32:
+ <<: *common-definitions
+ build:
+ context: ./docker/windows/runner
+ dockerfile: ./Dockerfile
+ args:
+ - RUNNER_VERSION=2.294.0
+ depends_on:
+ - cobalt-build-win32-base
+ image: cobalt-runner-win-win32
diff --git a/docker/linux/base/build/Dockerfile b/docker/linux/base/build/Dockerfile
index 60533d6..26590dd 100644
--- a/docker/linux/base/build/Dockerfile
+++ b/docker/linux/base/build/Dockerfile
@@ -26,7 +26,6 @@
ninja-build \
pkgconf \
unzip \
- yasm \
&& /opt/clean-after-apt.sh
# === Get Nodejs pinned LTS version via NVM
diff --git a/docker/windows/base/build/Dockerfile b/docker/windows/base/build/Dockerfile
index 19aa9b6..6e76594 100644
--- a/docker/windows/base/build/Dockerfile
+++ b/docker/windows/base/build/Dockerfile
@@ -29,10 +29,14 @@
# of the execution, i.e. the full invocation string.
COPY ./list_python_processes.py /list_python_processes.py
+# Pin Choco to 1.4.0 to avoid required reboot in 2.0.0
+ENV chocolateyVersion '1.4.0'
# Install deps via chocolatey.
RUN iex ((New-Object System.Net.WebClient).DownloadString('https://chocolatey.org/install.ps1'));`
mkdir C:\choco-cache;`
- choco install -y -c C:\choco-cache python3 -ia '/quiet InstallAllUsers=1 PrependPath=1 TargetDir="C:\Python3"';`
+ # Note: We pinned python 3.11.0 version here because 3.11.2 has a regression
+ # where the install arguments like TargetDir were being ignored.
+ choco install -y -c C:\choco-cache python3 --version 3.11.0 -ia '/quiet InstallAllUsers=1 PrependPath=1 TargetDir="C:\Python3"';`
choco install -y -c C:\choco-cache winflexbison3 --params '/InstallDir:C:\bison';`
choco install -y -c C:\choco-cache ninja;`
choco install -y -c C:\choco-cache nodejs-lts;`
diff --git a/docker/windows/runner/Dockerfile b/docker/windows/runner/Dockerfile
new file mode 100644
index 0000000..a494811
--- /dev/null
+++ b/docker/windows/runner/Dockerfile
@@ -0,0 +1,34 @@
+# Copyright 2022 The Cobalt Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+FROM cobalt-build-win32-base
+
+SHELL ["powershell", "-Command", "$ErrorActionPreference = 'Stop';$ProgressPreference='silentlyContinue';"]
+
+ARG RUNNER_VERSION
+
+RUN Invoke-WebRequest -Uri 'https://aka.ms/install-powershell.ps1' -OutFile install-powershell.ps1; \
+ powershell -ExecutionPolicy Unrestricted -File ./install-powershell.ps1 -AddToPath
+
+RUN Invoke-WebRequest -Uri https://github.com/actions/runner/releases/download/v$env:RUNNER_VERSION/actions-runner-win-x64-$env:RUNNER_VERSION.zip -OutFile runner.zip; \
+ Expand-Archive -Path C:/runner.zip -DestinationPath C:/actions-runner; \
+ Remove-Item -Path C:\runner.zip; \
+ setx /M PATH $(${Env:PATH} + \";${Env:ProgramFiles}\Git\bin\")
+
+# Required for packaging artifacts.
+RUN choco install -f -y 7zip --version=19.0
+
+ENV TMP "C:\Users\ContainerAdministrator\AppData\Local\Temp2"
+
+ADD runner.ps1 C:/runner.ps1
+CMD ["pwsh", "-ExecutionPolicy", "Unrestricted", "-File", ".\\runner.ps1"]
diff --git a/docker/windows/runner/runner.ps1 b/docker/windows/runner/runner.ps1
new file mode 100644
index 0000000..9e96a5e
--- /dev/null
+++ b/docker/windows/runner/runner.ps1
@@ -0,0 +1,2 @@
+.\actions-runner\config.cmd --unattended --replace --url https://github.com/${env:RUNNER_REPO} --token $env:RUNNER_TOKEN --name $env:RUNNER_NAME --work $env:RUNNER_WORKDIR --labels $env:RUNNER_LABELS;
+.\actions-runner\run.cmd;
diff --git a/net/url_request/url_fetcher_core.cc b/net/url_request/url_fetcher_core.cc
index 0d77b78..6835662 100644
--- a/net/url_request/url_fetcher_core.cc
+++ b/net/url_request/url_fetcher_core.cc
@@ -175,8 +175,9 @@
}
void URLFetcherCore::Stop() {
- if (delegate_task_runner_) // May be NULL in tests.
+ if (delegate_task_runner_) { // May be NULL in tests.
DCHECK(delegate_task_runner_->RunsTasksInCurrentSequence());
+ }
delegate_ = NULL;
fetcher_ = NULL;
@@ -783,8 +784,11 @@
if (!extra_request_headers_.IsEmpty())
request_->SetExtraRequestHeaders(extra_request_headers_);
+#if defined(STARBOARD)
request_->SetLoadTimingInfoCallback(base::Bind(&URLFetcherCore::GetLoadTimingInfo,
base::Unretained(this)));
+#endif
+
request_->Start();
}
@@ -1133,6 +1137,14 @@
#if defined(STARBOARD)
void URLFetcherCore::GetLoadTimingInfo(
const net::LoadTimingInfo& timing_info) {
+ delegate_task_runner_->PostTask(
+ FROM_HERE,
+ base::Bind(&URLFetcherCore::GetLoadTimingInfoInDelegateThread,
+ this, timing_info));
+}
+
+void URLFetcherCore::GetLoadTimingInfoInDelegateThread(
+ const net::LoadTimingInfo& timing_info) {
// Check if the URLFetcherCore has been stopped before.
if (delegate_) {
delegate_->ReportLoadTimingInfo(timing_info);
diff --git a/net/url_request/url_fetcher_core.h b/net/url_request/url_fetcher_core.h
index 02048d1..cfbd717 100644
--- a/net/url_request/url_fetcher_core.h
+++ b/net/url_request/url_fetcher_core.h
@@ -165,6 +165,7 @@
static void SetIgnoreCertificateRequests(bool ignored);
#if defined (STARBOARD)
void GetLoadTimingInfo(const net::LoadTimingInfo& timing_info);
+ void GetLoadTimingInfoInDelegateThread(const net::LoadTimingInfo& timing_info);
#endif // defined(STARBOARD)
private:
friend class base::RefCountedThreadSafe<URLFetcherCore>;
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecBridge.java b/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecBridge.java
index 1478b37..7efa465 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecBridge.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecBridge.java
@@ -498,6 +498,9 @@
return;
}
nativeOnMediaCodecOutputFormatChanged(mNativeMediaCodecBridge);
+ if (mFrameRateEstimator != null) {
+ mFrameRateEstimator.reset();
+ }
}
}
};
diff --git a/starboard/common/media.cc b/starboard/common/media.cc
index eb74ac8..f9cdac0 100644
--- a/starboard/common/media.cc
+++ b/starboard/common/media.cc
@@ -639,6 +639,55 @@
return "invalid";
}
+const char* GetMediaAudioConnectorName(SbMediaAudioConnector connector) {
+ switch (connector) {
+ case kSbMediaAudioConnectorNone:
+ return "none";
+ case kSbMediaAudioConnectorAnalog:
+ return "analog";
+ case kSbMediaAudioConnectorBluetooth:
+ return "bluetooth";
+ case kSbMediaAudioConnectorHdmi:
+ return "hdmi";
+ case kSbMediaAudioConnectorNetwork:
+ return "network";
+ case kSbMediaAudioConnectorSpdif:
+ return "spdif";
+ case kSbMediaAudioConnectorUsb:
+ return "usb";
+ }
+ SB_NOTREACHED();
+ return "invalid";
+}
+
+const char* GetCobaltExtensionMediaAudioConnectorName(
+ CobaltExtensionMediaAudioConnector connector) {
+ switch (connector) {
+ case kCobaltExtensionMediaAudioConnectorUnknown:
+ return "unknown";
+ case kCobaltExtensionMediaAudioConnectorAnalog:
+ return "analog";
+ case kCobaltExtensionMediaAudioConnectorBluetooth:
+ return "bluetooth";
+ case kCobaltExtensionMediaAudioConnectorBuiltIn:
+ return "builtin";
+ case kCobaltExtensionMediaAudioConnectorHdmi:
+ return "hdmi";
+ case kCobaltExtensionMediaAudioConnectorRemoteWired:
+ return "remote-wired";
+ case kCobaltExtensionMediaAudioConnectorRemoteWireless:
+ return "remote-wireless";
+ case kCobaltExtensionMediaAudioConnectorRemoteOther:
+ return "remote-other";
+ case kCobaltExtensionMediaAudioConnectorSpdif:
+ return "spdif";
+ case kCobaltExtensionMediaAudioConnectorUsb:
+ return "usb";
+ }
+ SB_NOTREACHED();
+ return "invalid";
+}
+
const char* GetMediaPrimaryIdName(SbMediaPrimaryId primary_id) {
switch (primary_id) {
case kSbMediaPrimaryIdReserved0:
diff --git a/starboard/common/media.h b/starboard/common/media.h
index a51641e..401551d 100644
--- a/starboard/common/media.h
+++ b/starboard/common/media.h
@@ -17,12 +17,16 @@
#include <ostream>
+#include "cobalt/extension/audio_write_ahead.h"
#include "starboard/media.h"
namespace starboard {
const char* GetMediaAudioCodecName(SbMediaAudioCodec codec);
const char* GetMediaVideoCodecName(SbMediaVideoCodec codec);
+const char* GetMediaAudioConnectorName(SbMediaAudioConnector connector);
+const char* GetCobaltExtensionMediaAudioConnectorName(
+ CobaltExtensionMediaAudioConnector connector);
const char* GetMediaPrimaryIdName(SbMediaPrimaryId primary_id);
const char* GetMediaTransferIdName(SbMediaTransferId transfer_id);
const char* GetMediaMatrixIdName(SbMediaMatrixId matrix_id);
diff --git a/starboard/doc/evergreen/cobalt_evergreen_overview.md b/starboard/doc/evergreen/cobalt_evergreen_overview.md
index cc21fa2..e3ce087 100644
--- a/starboard/doc/evergreen/cobalt_evergreen_overview.md
+++ b/starboard/doc/evergreen/cobalt_evergreen_overview.md
@@ -90,38 +90,43 @@
### Building Cobalt Evergreen Components
-Cobalt Evergreen requires that there are two separate build(`gyp`)
+Cobalt Evergreen requires that there are two separate build
configurations used due to the separation of the Cobalt core(`libcobalt.so`) and
-the platform-specific Starboard layer(`loader_app`). As a result, you will have
-to initiate a separate gyp process for each. This is required since the Cobalt
-core binary is built with the Google toolchain settings and the
-platform-specific Starboard layer is built with partner toolchain
-configurations.
+the platform-specific layers. As a result, you will have to run `gen gn`
+separately for each. This is required since the Cobalt core binary is built
+with the Google toolchain settings and the components in the platform-specific
+Starboard layer are built with partner toolchain configurations.
-Cobalt Evergreen is built by a separate gyp platform using the Google toolchain:
+Cobalt Evergreen is built by a separate GN platform using the Google toolchain.
+For example:
```
-$ cobalt/build/gn.py -p evergreen-arm-softfp -c qa
-$ ninja -C out/evergreen-arm-softfp_qa cobalt
+$ gn gen out/evergreen-arm-softfp_qa --args="target_platform=\"evergreen-arm-softfp\" build_type=\"qa\" target_cpu=\"arm\" target_os=\"linux\" sb_api_version=14"
+$ ninja -C out/evergreen-arm-softfp_qa cobalt_install
```
Which produces a shared library `libcobalt.so` targeted for specific
architecture, ABI and Starboard version.
-The gyp variable `sb_evergreen` is set to 1 when building `libcobalt.so`.
+The GN variable `sb_is_evergreen` is set to `true` when building `libcobalt.so`.
+
+Finally, note that these instructions are for producing a local build of
+`libcobalt.so`. For submissions to YTS and deployments to users' devices, an
+official release build of `libcobalt.so` should be downloaded from GitHub.
The partner port of Starboard is built with the partner’s toolchain and is
linked into the `loader_app` which knows how to dynamically load
`libcobalt.so`, and the `crashpad_handler` which handles crashes.
```
-$ cobalt/build/gn.py -p <partner_port_name> -c qa
+$ gn gen out/<partner_port_name>_qa --args='target_platform="<partner_port_name>" build_type="qa" sb_api_version=14'
$ ninja -C out/<partner_port_name>_qa loader_app crashpad_handler
```
-Partners should set `sb_evergreen_compatible` to 1 in their gyp platform config.
-DO NOT set the `sb_evergreen` to 1 in your platform-specific configuration as it
-is used only by Cobalt when building with the Google toolchain.
+Partners should set `sb_is_evergreen_compatible` to `true` in their GN platform
+config. DO NOT set the `sb_is_evergreen` to `true` in your platform-specific
+configuration as it is used only by Cobalt when building with the Google
+toolchain.
Additionally, partners should install crash handlers as instructed in the
[Installing Crash Handlers for Cobalt guide](../crash_handlers.md).
diff --git a/starboard/linux/shared/BUILD.gn b/starboard/linux/shared/BUILD.gn
index f097404..f313fde 100644
--- a/starboard/linux/shared/BUILD.gn
+++ b/starboard/linux/shared/BUILD.gn
@@ -56,6 +56,10 @@
sources = [
"//starboard/linux/shared/atomic_public.h",
"//starboard/linux/shared/audio_sink_type_dispatcher.cc",
+ "//starboard/linux/shared/audio_write_ahead.cc",
+ "//starboard/linux/shared/audio_write_ahead.h",
+ "//starboard/linux/shared/audio_write_ahead_player_get_audio_configuration.cc",
+ "//starboard/linux/shared/audio_write_ahead_player_get_audio_configuration.h",
"//starboard/linux/shared/configuration.cc",
"//starboard/linux/shared/configuration.h",
"//starboard/linux/shared/configuration_constants.cc",
@@ -64,6 +68,8 @@
"//starboard/linux/shared/decode_target_internal.cc",
"//starboard/linux/shared/decode_target_internal.h",
"//starboard/linux/shared/decode_target_release.cc",
+ "//starboard/linux/shared/ifa.cc",
+ "//starboard/linux/shared/ifa.h",
"//starboard/linux/shared/media_is_audio_supported.cc",
"//starboard/linux/shared/media_is_video_supported.cc",
"//starboard/linux/shared/netlink.cc",
diff --git a/starboard/linux/shared/audio_write_ahead.cc b/starboard/linux/shared/audio_write_ahead.cc
new file mode 100644
index 0000000..ffcf1f1
--- /dev/null
+++ b/starboard/linux/shared/audio_write_ahead.cc
@@ -0,0 +1,43 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "starboard/linux/shared/audio_write_ahead.h"
+
+#include "cobalt/extension/audio_write_ahead.h"
+#include "starboard/common/log.h"
+#include "starboard/linux/shared/audio_write_ahead_player_get_audio_configuration.h"
+
+// Omit namespace linux due to symbol name conflict.
+
+namespace starboard {
+namespace shared {
+
+namespace {
+
+const CobaltExtensionConfigurableAudioWriteAheadApi
+ kConfigurableAudioWriteAheadApi = {
+ kCobaltExtensionConfigurableAudioWriteAheadName,
+ 1,
+ &ConfigurableAudioWriteAheadPlayerGetAudioConfiguration,
+};
+
+} // namespace
+
+const void* GetConfigurableAudioWriteAheadApi() {
+ SB_LOG(INFO) << "Audio write ahead extension enabled.";
+ return &kConfigurableAudioWriteAheadApi;
+}
+
+} // namespace shared
+} // namespace starboard
diff --git a/starboard/linux/shared/audio_write_ahead.h b/starboard/linux/shared/audio_write_ahead.h
new file mode 100644
index 0000000..15d19e8
--- /dev/null
+++ b/starboard/linux/shared/audio_write_ahead.h
@@ -0,0 +1,28 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef STARBOARD_SHARED_AUDIO_WRITE_AHEAD_H_
+#define STARBOARD_SHARED_AUDIO_WRITE_AHEAD_H_
+
+// Omit namespace linux due to symbol name conflict.
+
+namespace starboard {
+namespace shared {
+
+const void* GetConfigurableAudioWriteAheadApi();
+
+} // namespace shared
+} // namespace starboard
+
+#endif // STARBOARD_SHARED_AUDIO_WRITE_AHEAD_H_
diff --git a/starboard/linux/shared/audio_write_ahead_player_get_audio_configuration.cc b/starboard/linux/shared/audio_write_ahead_player_get_audio_configuration.cc
new file mode 100644
index 0000000..c2e5f00
--- /dev/null
+++ b/starboard/linux/shared/audio_write_ahead_player_get_audio_configuration.cc
@@ -0,0 +1,56 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "starboard/linux/shared/audio_write_ahead_player_get_audio_configuration.h"
+
+#include <string>
+
+#include "starboard/audio_sink.h"
+#include "starboard/common/log.h"
+#include "starboard/system.h"
+
+// Omit namespace linux due to symbol name conflict.
+
+namespace starboard {
+namespace shared {
+
+bool ConfigurableAudioWriteAheadPlayerGetAudioConfiguration(
+ SbPlayer player,
+ int index,
+ CobaltExtensionMediaAudioConfiguration* out_audio_configuration) {
+ SB_DCHECK(SbPlayerIsValid(player));
+ SB_DCHECK(index >= 0);
+ SB_DCHECK(out_audio_configuration);
+
+ if (index > 0) {
+ // We assume that |player| only uses the primary (index 0) audio output.
+ // For playbacks using more than one audio outputs, or using audio outputs
+ // other than the primary one, the platform should have its own
+ // `SbPlayerGetAudioConfiguration()` implementation.
+ return false;
+ }
+
+ *out_audio_configuration = {};
+
+ out_audio_configuration->connector =
+ kCobaltExtensionMediaAudioConnectorUnknown;
+ out_audio_configuration->latency = 0;
+ out_audio_configuration->coding_type = kSbMediaAudioCodingTypePcm;
+ out_audio_configuration->number_of_channels = SbAudioSinkGetMaxChannels();
+
+ return true;
+}
+
+} // namespace shared
+} // namespace starboard
diff --git a/starboard/linux/shared/audio_write_ahead_player_get_audio_configuration.h b/starboard/linux/shared/audio_write_ahead_player_get_audio_configuration.h
new file mode 100644
index 0000000..08126df
--- /dev/null
+++ b/starboard/linux/shared/audio_write_ahead_player_get_audio_configuration.h
@@ -0,0 +1,35 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef STARBOARD_SHARED_AUDIO_WRITE_AHEAD_PLAYER_GET_AUDIO_CONFIGURATION_H_
+#define STARBOARD_SHARED_AUDIO_WRITE_AHEAD_PLAYER_GET_AUDIO_CONFIGURATION_H_
+
+#include "cobalt/extension/audio_write_ahead.h"
+
+#include "starboard/player.h"
+
+// Omit namespace linux due to symbol name conflict.
+
+namespace starboard {
+namespace shared {
+
+bool ConfigurableAudioWriteAheadPlayerGetAudioConfiguration(
+ SbPlayer player,
+ int index,
+ CobaltExtensionMediaAudioConfiguration* out_audio_configuration);
+
+} // namespace shared
+} // namespace starboard
+
+#endif // STARBOARD_SHARED_AUDIO_WRITE_AHEAD_PLAYER_GET_AUDIO_CONFIGURATION_H_
diff --git a/starboard/linux/shared/ifa.cc b/starboard/linux/shared/ifa.cc
new file mode 100644
index 0000000..548f9bb
--- /dev/null
+++ b/starboard/linux/shared/ifa.cc
@@ -0,0 +1,65 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "starboard/linux/shared/ifa.h"
+
+#include "cobalt/extension/ifa.h"
+
+#include "starboard/common/string.h"
+#include "starboard/shared/environment.h"
+
+namespace starboard {
+namespace shared {
+
+namespace {
+
+bool CopyStringAndTestIfSuccess(char* out_value,
+ int value_length,
+ const char* from_value) {
+ if (strlen(from_value) + 1 > value_length)
+ return false;
+ starboard::strlcpy(out_value, from_value, value_length);
+ return true;
+}
+
+// Definitions of any functions included as components in the extension
+// are added here.
+
+bool GetAdvertisingId(char* out_value, int value_length) {
+ return CopyStringAndTestIfSuccess(
+ out_value, value_length,
+ starboard::GetEnvironment("COBALT_ADVERTISING_ID").c_str());
+}
+
+bool GetLimitAdTracking(char* out_value, int value_length) {
+ return CopyStringAndTestIfSuccess(
+ out_value, value_length,
+ GetEnvironment("COBALT_LIMIT_AD_TRACKING").c_str());
+}
+
+const StarboardExtensionIfaApi kIfaApi = {
+ kStarboardExtensionIfaName,
+ 1, // API version that's implemented.
+ &GetAdvertisingId,
+ &GetLimitAdTracking,
+};
+
+} // namespace
+
+const void* GetIfaApi() {
+ return &kIfaApi;
+}
+
+} // namespace shared
+} // namespace starboard
diff --git a/starboard/linux/shared/ifa.h b/starboard/linux/shared/ifa.h
new file mode 100644
index 0000000..fbe61ab
--- /dev/null
+++ b/starboard/linux/shared/ifa.h
@@ -0,0 +1,27 @@
+// Copyright 2023 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef STARBOARD_LINUX_SHARED_IFA_H_
+#define STARBOARD_LINUX_SHARED_IFA_H_
+
+// Omit namespace linux due to symbol name conflict.
+namespace starboard {
+namespace shared {
+
+const void* GetIfaApi();
+
+} // namespace shared
+} // namespace starboard
+
+#endif // STARBOARD_LINUX_SHARED_IFA_H_
diff --git a/starboard/linux/shared/system_get_extensions.cc b/starboard/linux/shared/system_get_extensions.cc
index fba44bd..f6a7e8d 100644
--- a/starboard/linux/shared/system_get_extensions.cc
+++ b/starboard/linux/shared/system_get_extensions.cc
@@ -14,13 +14,16 @@
#include "starboard/system.h"
+#include "cobalt/extension/audio_write_ahead.h"
#include "cobalt/extension/configuration.h"
#include "cobalt/extension/crash_handler.h"
#include "cobalt/extension/demuxer.h"
#include "cobalt/extension/free_space.h"
+#include "cobalt/extension/ifa.h"
#include "cobalt/extension/memory_mapped_file.h"
#include "cobalt/extension/platform_service.h"
#include "starboard/common/string.h"
+#include "starboard/linux/shared/ifa.h"
#include "starboard/linux/shared/soft_mic_platform_service.h"
#include "starboard/shared/ffmpeg/ffmpeg_demuxer.h"
#include "starboard/shared/posix/free_space.h"
@@ -30,6 +33,7 @@
#if SB_IS(EVERGREEN_COMPATIBLE)
#include "starboard/elf_loader/evergreen_config.h"
#endif
+#include "starboard/linux/shared/audio_write_ahead.h"
#include "starboard/linux/shared/configuration.h"
const void* SbSystemGetExtension(const char* name) {
@@ -59,6 +63,9 @@
if (strcmp(name, kCobaltExtensionFreeSpaceName) == 0) {
return starboard::shared::posix::GetFreeSpaceApi();
}
+ if (strcmp(name, kCobaltExtensionConfigurableAudioWriteAheadName) == 0) {
+ return starboard::shared::GetConfigurableAudioWriteAheadApi();
+ }
if (strcmp(name, kCobaltExtensionDemuxerApi) == 0) {
auto command_line =
starboard::shared::starboard::Application::Get()->GetCommandLine();
@@ -67,5 +74,10 @@
return use_ffmpeg_demuxer ? starboard::shared::ffmpeg::GetFFmpegDemuxerApi()
: NULL;
}
+#if SB_API_VERSION < 14
+ if (strcmp(name, kStarboardExtensionIfaName) == 0) {
+ return starboard::shared::GetIfaApi();
+ }
+#endif // SB_API_VERSION < 14
return NULL;
}
diff --git a/starboard/shared/win32/video_decoder.cc b/starboard/shared/win32/video_decoder.cc
index fe58e7b..dd588a3 100644
--- a/starboard/shared/win32/video_decoder.cc
+++ b/starboard/shared/win32/video_decoder.cc
@@ -468,8 +468,9 @@
ComPtr<IMFAttributes> attributes = transform->GetAttributes();
SB_DCHECK(attributes);
- CheckResult(attributes->SetUINT32(MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT,
- kMaxOutputSamples));
+ CheckResult(
+ attributes->SetUINT32(MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT,
+ static_cast<UINT32>(GetMaxNumberOfCachedFrames())));
UpdateVideoArea(transform->GetCurrentOutputType());
@@ -704,7 +705,7 @@
// MF_SA_MINIMUM_OUTPUT_SAMPLE_COUNT.
thread_lock_.Acquire();
bool input_full = thread_events_.size() >= kMaxInputSamples;
- bool output_full = thread_outputs_.size() >= kMaxOutputSamples;
+ bool output_full = thread_outputs_.size() >= GetMaxNumberOfCachedFrames();
thread_lock_.Release();
Status status = input_full ? kBufferFull : kNeedMoreInput;
diff --git a/third_party/angle/include/GLSLANG/ShaderVars.h b/third_party/angle/include/GLSLANG/ShaderVars.h
index 52f6ad0..5d2d146 100644
--- a/third_party/angle/include/GLSLANG/ShaderVars.h
+++ b/third_party/angle/include/GLSLANG/ShaderVars.h
@@ -12,6 +12,7 @@
#include <algorithm>
#include <array>
+#include <cstdint>
#include <string>
#include <vector>
diff --git a/third_party/angle/src/common/angleutils.h b/third_party/angle/src/common/angleutils.h
index 3a1391e..c8d36f5 100644
--- a/third_party/angle/src/common/angleutils.h
+++ b/third_party/angle/src/common/angleutils.h
@@ -14,6 +14,7 @@
#include <climits>
#include <cstdarg>
#include <cstddef>
+#include <cstdint>
#include <set>
#include <sstream>
#include <string>
diff --git a/third_party/chromium/media/filters/chunk_demuxer.cc b/third_party/chromium/media/filters/chunk_demuxer.cc
index 1d6e475..2b729a4 100644
--- a/third_party/chromium/media/filters/chunk_demuxer.cc
+++ b/third_party/chromium/media/filters/chunk_demuxer.cc
@@ -180,6 +180,9 @@
DCHECK(state_ == UNINITIALIZED || state_ == RETURNING_ABORT_FOR_READS)
<< state_;
+#if defined(STARBOARD)
+ write_head_ = time;
+#endif // defined (STARBOARD)
stream_->Seek(time);
}
@@ -225,6 +228,15 @@
return stream_->GarbageCollectIfNeeded(media_time, newDataSize);
}
+#if defined(STARBOARD)
+
+base::TimeDelta ChunkDemuxerStream::GetWriteHead() const {
+ base::AutoLock auto_lock(lock_);
+ return write_head_;
+}
+
+#endif // defined(STARBOARD)
+
void ChunkDemuxerStream::OnMemoryPressure(
base::TimeDelta media_time,
base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level,
@@ -473,6 +485,7 @@
DemuxerStream::Status status = DemuxerStream::kAborted;
std::vector<scoped_refptr<DecoderBuffer>> buffers;
+ base::TimeDelta write_head = write_head_;
if (pending_config_change_) {
status = kConfigChanged;
@@ -491,6 +504,7 @@
<< buffer->timestamp().InSecondsF() << ", dur "
<< buffer->duration().InSecondsF() << ", key "
<< buffer->is_key_frame();
+ write_head = std::max(write_head, buffer->timestamp());
buffers.push_back(std::move(buffer));
status = DemuxerStream::kOk;
} else if (stream_status == SourceBufferStreamStatus::kEndOfStream) {
@@ -529,6 +543,8 @@
return;
}
+ DCHECK_LE(write_head_, write_head);
+ write_head_ = write_head;
std::move(read_cb_).Run(status, buffers);
}
#else // defined(STARBOARD)
@@ -1077,6 +1093,25 @@
return itr->second->EvictCodedFrames(currentMediaTime, newDataSize);
}
+#if defined(STARBOARD)
+
+base::TimeDelta ChunkDemuxer::GetWriteHead(const std::string& id) const {
+ base::AutoLock auto_lock(lock_);
+ DCHECK(IsValidId(id));
+
+ auto iter = id_to_streams_map_.find(id);
+ if (iter == id_to_streams_map_.end() ||
+ iter->second.empty()) {
+ // Handled just in case.
+ SB_NOTREACHED();
+ return base::TimeDelta();
+ }
+
+ return iter->second[0]->GetWriteHead();
+}
+
+#endif // defined(STARBOARD)
+
bool ChunkDemuxer::AppendData(const std::string& id,
const uint8_t* data,
size_t length,
diff --git a/third_party/chromium/media/filters/chunk_demuxer.h b/third_party/chromium/media/filters/chunk_demuxer.h
index fd67e6f..2e71291 100644
--- a/third_party/chromium/media/filters/chunk_demuxer.h
+++ b/third_party/chromium/media/filters/chunk_demuxer.h
@@ -79,6 +79,10 @@
// https://w3c.github.io/media-source/#sourcebuffer-coded-frame-eviction
bool EvictCodedFrames(base::TimeDelta media_time, size_t newDataSize);
+#if defined(STARBOARD)
+ base::TimeDelta GetWriteHead() const;
+#endif // defined(STARBOARD)
+
void OnMemoryPressure(
base::TimeDelta media_time,
base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level,
@@ -207,6 +211,9 @@
State state_ GUARDED_BY(lock_);
ReadCB read_cb_ GUARDED_BY(lock_);
bool is_enabled_ GUARDED_BY(lock_);
+#if defined(STARBOARD)
+ base::TimeDelta write_head_ GUARDED_BY(lock_);
+#endif // defined(STARBOARD)
DISALLOW_IMPLICIT_CONSTRUCTORS(ChunkDemuxerStream);
};
@@ -383,6 +390,10 @@
base::TimeDelta currentMediaTime,
size_t newDataSize) WARN_UNUSED_RESULT;
+#if defined(STARBOARD)
+ base::TimeDelta GetWriteHead(const std::string& id) const;
+#endif // defined(STARBOARD)
+
void OnMemoryPressure(
base::TimeDelta currentMediaTime,
base::MemoryPressureListener::MemoryPressureLevel memory_pressure_level,
diff --git a/third_party/crashpad/util/misc/reinterpret_bytes.cc b/third_party/crashpad/util/misc/reinterpret_bytes.cc
index 65ec33f..3fee722 100644
--- a/third_party/crashpad/util/misc/reinterpret_bytes.cc
+++ b/third_party/crashpad/util/misc/reinterpret_bytes.cc
@@ -17,6 +17,7 @@
#include <string.h>
#include <algorithm>
+#include <cstdint>
#include "base/logging.h"
diff --git a/third_party/devtools/front_end/cobalt/cobalt.js b/third_party/devtools/front_end/cobalt/cobalt.js
index a085c62..c65ff59 100644
--- a/third_party/devtools/front_end/cobalt/cobalt.js
+++ b/third_party/devtools/front_end/cobalt/cobalt.js
@@ -14,6 +14,7 @@
this._target = UI.context.flavor(SDK.Target);
this._runtimeAgent = this._target.runtimeAgent();
+ this._cobaltAgent = this._target.cobaltAgent();
this.element = this._shadowRoot.createChild('div');
this.element.textContent = 'Cobalt Console';
@@ -32,7 +33,7 @@
this.run(`(function() { window.h5vcc.traceEvent.stop();})()`);
console.log("Stopped Trace");
}));
- trace_files.forEach( (file) => {
+ trace_files.forEach((file) => {
traceContainer.appendChild(UI.createTextButton(Common.UIString('Download ' + file[0]), event => {
console.log("Download Trace");
const filename = file[1];
@@ -46,6 +47,39 @@
});
}));
});
+ const debugLogContainer = this.element.createChild('div', 'debug-log-container');
+ debugLogContainer.appendChild(UI.createTextButton(Common.UIString('DebugLog On'), event => {
+ this._cobaltAgent.invoke_sendConsoleCommand({
+ command: 'debug_log', message: 'on'
+ });
+ }));
+ debugLogContainer.appendChild(UI.createTextButton(Common.UIString('DebugLog Off'), event => {
+ this._cobaltAgent.invoke_sendConsoleCommand({
+ command: 'debug_log', message: 'off'
+ });
+ }));
+ const consoleContainer = this.element.createChild('div', 'console-container');
+ consoleContainer.appendChild(UI.createTextButton(Common.UIString('DebugCommand'), event => {
+ const outputElement = document.getElementsByClassName('console-output')[0];
+ const command = document.getElementsByClassName('debug-command')[0].value;
+ if (command.length == 0) {
+ const result = this._cobaltAgent.invoke_getConsoleCommands().then(result => {
+ outputElement.innerHTML = JSON.stringify(result.commands, undefined, 2);
+ });
+ } else {
+ const result = this._cobaltAgent.invoke_sendConsoleCommand({
+ command: command,
+ message: document.getElementsByClassName('debug-message')[0].value
+ }).then(result => {
+ outputElement.innerHTML = JSON.stringify(result, undefined, 2);
+ });
+ }
+ }));
+ consoleContainer.appendChild(UI.createLabel('Command:'));
+ consoleContainer.appendChild(UI.createInput('debug-command', 'text'));
+ consoleContainer.appendChild(UI.createLabel('Message:'));
+ consoleContainer.appendChild(UI.createInput('debug-message', 'text'));
+ consoleContainer.createChild('pre', 'console-output');
}
async run(expression) {
diff --git a/third_party/devtools/third_party/blink/public/devtools_protocol/browser_protocol.pdl b/third_party/devtools/third_party/blink/public/devtools_protocol/browser_protocol.pdl
index 0091c32..e98162f 100644
--- a/third_party/devtools/third_party/blink/public/devtools_protocol/browser_protocol.pdl
+++ b/third_party/devtools/third_party/blink/public/devtools_protocol/browser_protocol.pdl
@@ -8,6 +8,27 @@
major 1
minor 3
+# The Cobalt domain defines custom methods and events for Cobalt
+experimental domain Cobalt
+ command disable
+
+ command enable
+
+ experimental type ConsoleCommand extends object
+ properties
+ string command
+ string shortHelp
+ string longHelp
+
+ experimental command getConsoleCommands
+ returns
+ array of ConsoleCommand commands
+
+ experimental command sendConsoleCommand
+ parameters
+ string command
+ optional string message
+
experimental domain Accessibility
depends on DOM
diff --git a/third_party/v8/src/base/logging.h b/third_party/v8/src/base/logging.h
index fe39f98..dbe1305 100644
--- a/third_party/v8/src/base/logging.h
+++ b/third_party/v8/src/base/logging.h
@@ -5,6 +5,7 @@
#ifndef V8_BASE_LOGGING_H_
#define V8_BASE_LOGGING_H_
+#include <cstdint>
#include <cstring>
#include <sstream>
#include <string>
diff --git a/third_party/v8/src/base/macros.h b/third_party/v8/src/base/macros.h
index 515a9e3..a7cd7c0 100644
--- a/third_party/v8/src/base/macros.h
+++ b/third_party/v8/src/base/macros.h
@@ -5,6 +5,7 @@
#ifndef V8_BASE_MACROS_H_
#define V8_BASE_MACROS_H_
+#include <cstdint>
#include <limits>
#include <type_traits>
diff --git a/third_party/v8/src/inspector/v8-string-conversions.h b/third_party/v8/src/inspector/v8-string-conversions.h
index c1d69c1..eb33c68 100644
--- a/third_party/v8/src/inspector/v8-string-conversions.h
+++ b/third_party/v8/src/inspector/v8-string-conversions.h
@@ -5,6 +5,7 @@
#ifndef V8_INSPECTOR_V8_STRING_CONVERSIONS_H_
#define V8_INSPECTOR_V8_STRING_CONVERSIONS_H_
+#include <cstdint>
#include <string>
// Conversion routines between UT8 and UTF16, used by string-16.{h,cc}. You may
diff --git a/tools/copy_and_filter_out_dir.py b/tools/copy_and_filter_out_dir.py
index 8e01bf8..080a69f 100755
--- a/tools/copy_and_filter_out_dir.py
+++ b/tools/copy_and_filter_out_dir.py
@@ -102,6 +102,12 @@
return 0
_IterateAndFilter(source_out_dir, dest_out_dir, copies)
+
+ # Add build_info json to the out directory root.
+ source_build_info = os.path.join(source_out_dir, 'gen', 'build_info.json')
+ dest_build_info = os.path.join(dest_out_dir, 'build_info.json')
+ copies[source_build_info] = dest_build_info
+
for source, dest in copies.items():
dirname = os.path.dirname(dest)
if not os.path.exists(dirname):
diff --git a/tools/lz4_compress/lz4_compress.cc b/tools/lz4_compress/lz4_compress.cc
index 26421dc..08a79f5 100644
--- a/tools/lz4_compress/lz4_compress.cc
+++ b/tools/lz4_compress/lz4_compress.cc
@@ -22,6 +22,7 @@
#include <stdio.h>
+#include <cstdint>
#include <iostream>
#include <vector>
