Import Cobalt 23.lts.1.309088
diff --git a/cobalt/bindings/path_generator.py b/cobalt/bindings/path_generator.py
index 192ff59..ee91538 100644
--- a/cobalt/bindings/path_generator.py
+++ b/cobalt/bindings/path_generator.py
@@ -63,22 +63,7 @@
rel_idl_path = os.path.relpath(idl_path, self.interfaces_root)
components = os.path.dirname(rel_idl_path).split(os.sep)
-
- # Check if this IDL's path lies in our interfaces root. If it does not,
- # we treat it as an extension IDL.
- real_interfaces_root = os.path.realpath(self.interfaces_root)
- real_idl_path = os.path.realpath(os.path.dirname(idl_path))
- interfaces_root_is_in_components_path = (
- os.path.commonprefix([real_interfaces_root,
- real_idl_path]) == real_interfaces_root)
-
- if interfaces_root_is_in_components_path:
- return [os.path.basename(self.interfaces_root)] + components
- else:
- # If our IDL path lies outside of the cobalt/ directory, assume it is
- # an externally defined web extension and assign it the 'webapi_extension'
- # namespace.
- return [os.path.basename(self.interfaces_root), 'webapi_extension']
+ return [os.path.basename(self.interfaces_root)] + components
def Namespace(self, interface_name):
"""Get the interface's namespace."""
diff --git a/cobalt/bindings/testing/BUILD.gn b/cobalt/bindings/testing/BUILD.gn
index 523ca00..b97f61c 100644
--- a/cobalt/bindings/testing/BUILD.gn
+++ b/cobalt/bindings/testing/BUILD.gn
@@ -94,6 +94,7 @@
"promise_interface.idl",
"put_forwards_interface.idl",
"sequence_user.idl",
+ "serialize_script_value_interface.idl",
"single_operation_interface.idl",
"static_properties_interface.idl",
"stringifier_anonymous_operation_interface.idl",
@@ -185,6 +186,7 @@
"promise_test.cc",
"put_forwards_test.cc",
"sequence_bindings_test.cc",
+ "serialize_script_value_test.cc",
"stack_trace_test.cc",
"static_properties_bindings_test.cc",
"stringifier_bindings_test.cc",
diff --git a/cobalt/bindings/testing/serialize_script_value_interface.h b/cobalt/bindings/testing/serialize_script_value_interface.h
new file mode 100644
index 0000000..782edb2
--- /dev/null
+++ b/cobalt/bindings/testing/serialize_script_value_interface.h
@@ -0,0 +1,63 @@
+// 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.
+
+#ifndef COBALT_BINDINGS_TESTING_SERIALIZE_SCRIPT_VALUE_INTERFACE_H_
+#define COBALT_BINDINGS_TESTING_SERIALIZE_SCRIPT_VALUE_INTERFACE_H_
+
+#include <memory>
+#include <utility>
+
+#include "cobalt/base/polymorphic_downcast.h"
+#include "cobalt/script/environment_settings.h"
+#include "cobalt/script/typed_arrays.h"
+#include "cobalt/script/value_handle.h"
+#include "cobalt/script/wrappable.h"
+#include "cobalt/web/context.h"
+#include "cobalt/web/environment_settings.h"
+#include "v8/include/v8.h"
+
+namespace cobalt {
+namespace bindings {
+namespace testing {
+
+class SerializeScriptValueInterface : public script::Wrappable {
+ public:
+ SerializeScriptValueInterface() = default;
+
+ size_t serialized_size() { return data_buffer_->size; }
+
+ void SerializeTest(const script::ValueHandleHolder& value) {
+ data_buffer_ = std::move(script::SerializeScriptValue(value));
+ isolate_ = script::GetIsolate(value);
+ }
+
+ const script::ValueHandleHolder* DeserializeTest() {
+ deserialized_.reset(
+ script::DeserializeScriptValue(isolate_, *data_buffer_));
+ return deserialized_.get();
+ }
+
+ DEFINE_WRAPPABLE_TYPE(SerializeScriptValueInterface);
+
+ private:
+ std::unique_ptr<script::DataBuffer> data_buffer_;
+ std::unique_ptr<script::ValueHandleHolder> deserialized_;
+ v8::Isolate* isolate_;
+};
+
+} // namespace testing
+} // namespace bindings
+} // namespace cobalt
+
+#endif // COBALT_BINDINGS_TESTING_SERIALIZE_SCRIPT_VALUE_INTERFACE_H_
diff --git a/starboard/shared/test_webapi_extension/my_new_interface.idl b/cobalt/bindings/testing/serialize_script_value_interface.idl
similarity index 75%
rename from starboard/shared/test_webapi_extension/my_new_interface.idl
rename to cobalt/bindings/testing/serialize_script_value_interface.idl
index 8f49995..9fd6a06 100644
--- a/starboard/shared/test_webapi_extension/my_new_interface.idl
+++ b/cobalt/bindings/testing/serialize_script_value_interface.idl
@@ -1,4 +1,4 @@
-// Copyright 2017 The Cobalt Authors. All Rights Reserved.
+// 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.
@@ -12,9 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-interface MyNewInterface {
- attribute DOMString foo;
-
- void SetMyNewEnum(MyNewEnum value);
- MyNewEnum GetMyNewEnum();
+[ Constructor ]
+interface SerializeScriptValueInterface {
+ void serializeTest(any value);
+ any deserializeTest();
};
diff --git a/cobalt/bindings/testing/serialize_script_value_test.cc b/cobalt/bindings/testing/serialize_script_value_test.cc
new file mode 100644
index 0000000..96e0dc6
--- /dev/null
+++ b/cobalt/bindings/testing/serialize_script_value_test.cc
@@ -0,0 +1,55 @@
+// 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.
+
+#include "base/strings/string_number_conversions.h"
+#include "cobalt/bindings/testing/bindings_test_base.h"
+#include "cobalt/bindings/testing/serialize_script_value_interface.h"
+
+using ::testing::ContainsRegex;
+
+namespace cobalt {
+namespace bindings {
+namespace testing {
+
+class SerializeScriptValueTest
+ : public InterfaceBindingsTest<SerializeScriptValueInterface> {
+ public:
+ void ExpectTrue(const std::string& script) {
+ std::string result;
+ EvaluateScript("`${" + script + "}`", &result);
+ EXPECT_EQ("true", result)
+ << "Expect \"" + script + "\" to evaluate to true.";
+ }
+};
+
+TEST_F(SerializeScriptValueTest, Serialize) {
+ // Stores serialized result that is then used by |deserializeTest()|.
+ EvaluateScript(R"(
+ test.serializeTest({a: ['something'], b: new Uint8Array([42])});
+ )");
+ // Sanity check the serialized size.
+ EXPECT_EQ(32, test_mock().serialized_size());
+ ExpectTrue("!(test.deserializeTest() instanceof Array)");
+ ExpectTrue("test.deserializeTest() instanceof Object");
+ ExpectTrue("test.deserializeTest().a instanceof Array");
+ ExpectTrue("1 === test.deserializeTest().a.length");
+ ExpectTrue("'something' === test.deserializeTest().a[0]");
+ ExpectTrue("test.deserializeTest().b instanceof Uint8Array");
+ ExpectTrue("!(test.deserializeTest().b instanceof Uint16Array)");
+ ExpectTrue("42 === test.deserializeTest().b[0]");
+}
+
+} // namespace testing
+} // namespace bindings
+} // namespace cobalt
diff --git a/cobalt/browser/browser_module.cc b/cobalt/browser/browser_module.cc
index d95d150..b80da96 100644
--- a/cobalt/browser/browser_module.cc
+++ b/cobalt/browser/browser_module.cc
@@ -21,6 +21,7 @@
#include "base/bind.h"
#include "base/command_line.h"
+#include "base/compiler_specific.h"
#include "base/files/file_path.h"
#include "base/lazy_instance.h"
#include "base/logging.h"
@@ -28,7 +29,6 @@
#include "base/path_service.h"
#include "base/stl_util.h"
#include "base/strings/string_number_conversions.h"
-#include "base/strings/string_split.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
#include "cobalt/base/cobalt_paths.h"
@@ -144,15 +144,6 @@
"activated or not. While activated, input will constantly and randomly be "
"generated and passed directly into the main web module.";
-const char kSetMediaConfigCommand[] = "set_media_config";
-const char kSetMediaConfigCommandShortHelp[] =
- "Sets media module configuration.";
-const char kSetMediaConfigCommandLongHelp[] =
- "This can be called in the form of set_media_config('name=value'), where "
- "name is a string and value is an int. Refer to the implementation of "
- "MediaModule::SetConfiguration() on individual platform for settings "
- "supported on the particular platform.";
-
const char kScreenshotCommand[] = "screenshot";
const char kScreenshotCommandShortHelp[] = "Takes a screenshot.";
const char kScreenshotCommandLongHelp[] =
@@ -268,10 +259,6 @@
kFuzzerToggleCommand,
base::Bind(&BrowserModule::OnFuzzerToggle, base::Unretained(this)),
kFuzzerToggleCommandShortHelp, kFuzzerToggleCommandLongHelp)),
- ALLOW_THIS_IN_INITIALIZER_LIST(set_media_config_command_handler_(
- kSetMediaConfigCommand,
- base::Bind(&BrowserModule::OnSetMediaConfig, base::Unretained(this)),
- kSetMediaConfigCommandShortHelp, kSetMediaConfigCommandLongHelp)),
ALLOW_THIS_IN_INITIALIZER_LIST(screenshot_command_handler_(
kScreenshotCommand,
base::Bind(&OnScreenshotMessage, base::Unretained(this)),
@@ -450,9 +437,10 @@
switch (application_state_) {
case base::kApplicationStateStarted:
Blur(0);
- // Intentional fall-through.
+ FALLTHROUGH;
case base::kApplicationStateBlurred:
Conceal(0);
+ FALLTHROUGH;
case base::kApplicationStateConcealed:
Freeze(0);
break;
@@ -1011,30 +999,6 @@
}
}
-void BrowserModule::OnSetMediaConfig(const std::string& config) {
- if (base::MessageLoop::current() != self_message_loop_) {
- self_message_loop_->task_runner()->PostTask(
- FROM_HERE,
- base::Bind(&BrowserModule::OnSetMediaConfig, weak_this_, config));
- return;
- }
-
- std::vector<std::string> tokens = base::SplitString(
- config, "=", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
-
- int value;
- if (tokens.size() != 2 || !base::StringToInt(tokens[1], &value)) {
- LOG(WARNING) << "Media configuration '" << config << "' is not in the"
- << " form of '<string name>=<int value>'.";
- return;
- }
- if (media_module_->SetConfiguration(tokens[0], value)) {
- LOG(INFO) << "Successfully setting " << tokens[0] << " to " << value;
- } else {
- LOG(WARNING) << "Failed to set " << tokens[0] << " to " << value;
- }
-}
-
void BrowserModule::OnDisableMediaCodecs(const std::string& codecs) {
disabled_media_codecs_ = codecs;
can_play_type_handler_->SetDisabledMediaCodecs(codecs);
@@ -2059,8 +2023,11 @@
scoped_refptr<script::Wrappable> BrowserModule::CreateH5vcc(
script::EnvironmentSettings* settings) {
+ DCHECK(web_module_);
+
h5vcc::H5vcc::Settings h5vcc_settings;
- h5vcc_settings.media_module = media_module_.get();
+ h5vcc_settings.set_media_source_setting_func = base::Bind(
+ &WebModule::SetMediaSourceSetting, base::Unretained(web_module_.get()));
h5vcc_settings.network_module = network_module_;
#if SB_IS(EVERGREEN)
h5vcc_settings.updater_module = updater_module_;
diff --git a/cobalt/browser/browser_module.h b/cobalt/browser/browser_module.h
index b618caa..6730fa2 100644
--- a/cobalt/browser/browser_module.h
+++ b/cobalt/browser/browser_module.h
@@ -355,10 +355,6 @@
// Toggles the input fuzzer on/off. Ignores the parameter.
void OnFuzzerToggle(const std::string&);
- // Use the config in the form of '<string name>=<int value>' to call
- // MediaModule::SetConfiguration().
- void OnSetMediaConfig(const std::string& config);
-
// Sets the disabled media codecs in the debug console and in
// the CanPlayTypeHandler instance.
// Future requests to play videos with these codecs will report that these
@@ -615,10 +611,6 @@
debug::console::ConsoleCommandManager::CommandHandler
fuzzer_toggle_command_handler_;
- // Command handler object for setting media module config.
- debug::console::ConsoleCommandManager::CommandHandler
- set_media_config_command_handler_;
-
// Command handler object for screenshot command from the debug console.
debug::console::ConsoleCommandManager::CommandHandler
screenshot_command_handler_;
diff --git a/cobalt/browser/web_module.cc b/cobalt/browser/web_module.cc
index 8311b31..ecc0f56 100644
--- a/cobalt/browser/web_module.cc
+++ b/cobalt/browser/web_module.cc
@@ -48,6 +48,7 @@
#include "cobalt/dom/keyboard_event.h"
#include "cobalt/dom/keyboard_event_init.h"
#include "cobalt/dom/local_storage_database.h"
+#include "cobalt/dom/media_source_settings.h"
#include "cobalt/dom/mutation_observer_task_manager.h"
#include "cobalt/dom/navigation_type.h"
#include "cobalt/dom/navigator.h"
@@ -215,6 +216,8 @@
void SetSize(cssom::ViewportSize viewport_size);
void UpdateCamera3D(const scoped_refptr<input::Camera3D>& camera_3d);
void SetMediaModule(media::MediaModule* media_module);
+ void SetMediaSourceSetting(const std::string& name, int value,
+ bool* succeeded);
void SetImageCacheCapacity(int64_t bytes);
void SetRemoteTypefaceCacheCapacity(int64_t bytes);
@@ -396,6 +399,9 @@
// Object to register and retrieve MediaSource object with a string key.
std::unique_ptr<dom::MediaSource::Registry> media_source_registry_;
+ // Object to hold WebModule wide settings for MediaSource related objects.
+ dom::MediaSourceSettingsImpl media_source_settings_;
+
// The Window object wraps all DOM-related components.
scoped_refptr<dom::Window> window_;
@@ -580,8 +586,8 @@
web_context_->setup_environment_settings(new dom::DOMSettings(
debugger_hooks_, kDOMMaxElementDepth, media_source_registry_.get(),
- data.can_play_type_handler, memory_info, &mutation_observer_task_manager_,
- data.options.dom_settings_options));
+ &media_source_settings_, data.can_play_type_handler, memory_info,
+ &mutation_observer_task_manager_, data.options.dom_settings_options));
DCHECK(web_context_->environment_settings());
// From algorithm to setup up a window environment settings object:
// https://html.spec.whatwg.org/commit-snapshots/465a6b672c703054de278b0f8133eb3ad33d93f4/#set-up-a-window-environment-settings-object
@@ -706,7 +712,7 @@
web_context_->global_environment()->SetReportEvalCallback(
base::Bind(&web::CspDelegate::ReportEval,
- base::Unretained(window_->document()->csp_delegate())));
+ base::Unretained(window_->csp_delegate())));
web_context_->global_environment()->SetReportErrorCallback(
base::Bind(&WebModule::Impl::ReportScriptError, base::Unretained(this)));
@@ -1013,12 +1019,10 @@
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(is_running_);
DCHECK(window_);
- DCHECK(window_->document());
- DCHECK(window_->document()->csp_delegate());
+ DCHECK(window_->csp_delegate());
std::string eval_disabled_message;
- bool allow_eval =
- window_->document()->csp_delegate()->AllowEval(&eval_disabled_message);
+ bool allow_eval = window_->csp_delegate()->AllowEval(&eval_disabled_message);
if (allow_eval) {
web_context_->global_environment()->EnableEval();
} else {
@@ -1096,6 +1100,12 @@
window_->set_web_media_player_factory(media_module);
}
+void WebModule::Impl::SetMediaSourceSetting(const std::string& name, int value,
+ bool* succeeded) {
+ DCHECK(succeeded);
+ *succeeded = media_source_settings_.Set(name, value);
+}
+
void WebModule::Impl::SetApplicationState(base::ApplicationState state,
SbTimeMonotonic timestamp) {
window_->SetApplicationState(state, timestamp);
@@ -1576,6 +1586,12 @@
impl_->SetMediaModule(media_module);
}
+bool WebModule::SetMediaSourceSetting(const std::string& name, int value) {
+ bool succeeded = false;
+ SetMediaSourceSettingInternal(name, value, &succeeded);
+ return succeeded;
+}
+
void WebModule::SetImageCacheCapacity(int64_t bytes) {
POST_TO_ENSURE_IMPL_ON_THREAD(SetImageCacheCapacity, bytes);
impl_->SetImageCacheCapacity(bytes);
@@ -1709,5 +1725,12 @@
impl_->SetUnloadEventTimingInfo(start_time, end_time);
}
+void WebModule::SetMediaSourceSettingInternal(const std::string& name,
+ int value, bool* succeeded) {
+ POST_AND_BLOCK_TO_ENSURE_IMPL_ON_THREAD(SetMediaSourceSettingInternal, name,
+ value, succeeded);
+ impl_->SetMediaSourceSetting(name, value, succeeded);
+}
+
} // namespace browser
} // namespace cobalt
diff --git a/cobalt/browser/web_module.h b/cobalt/browser/web_module.h
index b7c21e5..3e442c8 100644
--- a/cobalt/browser/web_module.h
+++ b/cobalt/browser/web_module.h
@@ -338,6 +338,7 @@
void UpdateCamera3D(const scoped_refptr<input::Camera3D>& camera_3d);
void SetMediaModule(media::MediaModule* media_module);
+ bool SetMediaSourceSetting(const std::string& name, int value);
void SetImageCacheCapacity(int64_t bytes);
void SetRemoteTypefaceCacheCapacity(int64_t bytes);
@@ -458,10 +459,11 @@
void ClearAllIntervalsAndTimeouts();
- void CancelSynchronousLoads();
-
void GetIsReadyToFreeze(volatile bool* is_ready_to_freeze);
+ void SetMediaSourceSettingInternal(const std::string& name, int value,
+ bool* succeeded);
+
// The message loop this object is running on.
base::MessageLoop* message_loop() const {
DCHECK(web_agent_);
diff --git a/cobalt/build/build_number.py b/cobalt/build/build_number.py
index b0307e3..7ec534e 100644
--- a/cobalt/build/build_number.py
+++ b/cobalt/build/build_number.py
@@ -44,28 +44,15 @@
def GetRevinfo():
"""Get absolute state of all git repos."""
- try:
- repo_root = subprocess.check_output(['git', 'rev-parse', '--show-toplevel'
- ]).strip().decode('utf-8')
- except subprocess.CalledProcessError:
- logging.info('Could not get repo root. Trying again in src/')
- try:
- repo_root = subprocess.check_output(
- ['git', '-C', 'src', 'rev-parse',
- '--show-toplevel']).strip().decode('utf-8')
- except subprocess.CalledProcessError as e:
- logging.warning('Failed to get revision information: %s', e)
- return {}
-
# First make sure we can add the cobalt_src repo.
try:
- repos = CheckRevInfo('.', cwd=repo_root)
+ repos = CheckRevInfo('.', cwd=paths.REPOSITORY_ROOT)
except subprocess.CalledProcessError as e:
logging.warning('Failed to get revision information: %s', e)
return {}
for rel_path in _SUBREPO_PATHS:
- path = os.path.join(repo_root, rel_path)
+ path = os.path.join(paths.REPOSITORY_ROOT, rel_path)
try:
repos.update(CheckRevInfo(rel_path, cwd=path))
except subprocess.CalledProcessError as e:
diff --git a/cobalt/debug/backend/debug_module.cc b/cobalt/debug/backend/debug_module.cc
index 982f8f3..56e8b26 100644
--- a/cobalt/debug/backend/debug_module.cc
+++ b/cobalt/debug/backend/debug_module.cc
@@ -123,7 +123,7 @@
script::ScriptDebugger::CreateDebugger(data.global_environment, this);
script_runner_.reset(new DebugScriptRunner(
data.global_environment, script_debugger_.get(),
- data.window ? data.window->document()->csp_delegate() : nullptr));
+ data.window ? data.window->csp_delegate() : nullptr));
debug_dispatcher_.reset(
new DebugDispatcher(script_debugger_.get(), script_runner_.get()));
debug_backend_ = WrapRefCounted(new DebugBackend(
diff --git a/cobalt/demos/content/BUILD.gn b/cobalt/demos/content/BUILD.gn
index e87713e..c23edf1 100644
--- a/cobalt/demos/content/BUILD.gn
+++ b/cobalt/demos/content/BUILD.gn
@@ -133,7 +133,6 @@
"performance-spike/assets/banner720.jpg",
"performance-spike/assets/banner720baked.jpg",
"performance-spike/assets/icons.ttf",
- "performance-spike/assets/profile-alecmce.jpg",
"performance-spike/css/default.css",
"performance-spike/css/icons-content.css",
"performance-spike/css/icons.css",
diff --git a/cobalt/demos/content/watchdog-demo/index.html b/cobalt/demos/content/watchdog-demo/index.html
index 0213470..c5f17f8 100644
--- a/cobalt/demos/content/watchdog-demo/index.html
+++ b/cobalt/demos/content/watchdog-demo/index.html
@@ -59,7 +59,7 @@
let ret = 'void';
if (watchdogFunction == 'register') {
- ret = h5vcc.crashLog.register('test-name', 'test-description', 'started', 5000000, 0, 'none');
+ ret = h5vcc.crashLog.register('test-name', 'test-description', 'started', 3000, 0, 'none');
} else if (watchdogFunction == 'unregister') {
ret = h5vcc.crashLog.unregister('test-name');
} else if (watchdogFunction == 'ping') {
diff --git a/cobalt/dom/BUILD.gn b/cobalt/dom/BUILD.gn
index 74caf14..e16397b 100644
--- a/cobalt/dom/BUILD.gn
+++ b/cobalt/dom/BUILD.gn
@@ -187,6 +187,8 @@
"media_query_list.h",
"media_source.cc",
"media_source.h",
+ "media_source_settings.cc",
+ "media_source_settings.h",
"memory_info.cc",
"memory_info.h",
"mime_type_array.cc",
@@ -259,10 +261,14 @@
"screenshot.h",
"screenshot_manager.cc",
"screenshot_manager.h",
+ "serialized_algorithm_runner.cc",
+ "serialized_algorithm_runner.h",
"serializer.cc",
"serializer.h",
"source_buffer.cc",
"source_buffer.h",
+ "source_buffer_algorithm.cc",
+ "source_buffer_algorithm.h",
"source_buffer_list.cc",
"source_buffer_list.h",
"source_buffer_metrics.cc",
@@ -382,6 +388,7 @@
"local_storage_database_test.cc",
"location_test.cc",
"media_query_list_test.cc",
+ "media_source_settings_test.cc",
"mutation_observer_test.cc",
"named_node_map_test.cc",
"navigator_licenses_test.cc",
diff --git a/cobalt/dom/document.cc b/cobalt/dom/document.cc
index 22323c1..4e665a5 100644
--- a/cobalt/dom/document.cc
+++ b/cobalt/dom/document.cc
@@ -60,8 +60,6 @@
#include "cobalt/dom/wheel_event.h"
#include "cobalt/dom/window.h"
#include "cobalt/script/global_environment.h"
-#include "cobalt/web/csp_delegate.h"
-#include "cobalt/web/csp_delegate_factory.h"
#include "cobalt/web/custom_event.h"
#include "cobalt/web/dom_exception.h"
#include "cobalt/web/message_event.h"
@@ -71,6 +69,17 @@
namespace cobalt {
namespace dom {
+namespace {
+csp::SecurityCallback CreateSecurityCallback(
+ web::CspDelegate* csp_delegate, web::CspDelegate::ResourceType type) {
+ csp::SecurityCallback callback;
+ if (csp_delegate) {
+ callback = base::Bind(&web::CspDelegate::CanLoad,
+ base::Unretained(csp_delegate), type);
+ }
+ return callback;
+}
+} // namespace
Document::Document(HTMLElementContext* html_element_context,
const Options& options)
@@ -113,20 +122,11 @@
SetViewport(*options.viewport_size);
}
- std::unique_ptr<web::CspViolationReporter> violation_reporter(
- new web::CspViolationReporter(this, options.post_sender));
- csp_delegate_ = web::CspDelegateFactory::GetInstance()->Create(
- options.csp_enforcement_mode, std::move(violation_reporter), options.url,
- options.require_csp, options.csp_policy_changed_callback,
- options.csp_insecure_allowed_token);
-
cookie_jar_ = options.cookie_jar;
location_ = new Location(
options.url, options.hashchange_callback, options.navigation_callback,
- base::Bind(&web::CspDelegate::CanLoad,
- base::Unretained(csp_delegate_.get()),
- web::CspDelegate::kLocation),
+ CreateSecurityCallback(csp_delegate(), web::CspDelegate::kLocation),
base::Bind(&Document::SetNavigationType, base::Unretained(this)));
font_cache_.reset(new FontCache(
@@ -138,15 +138,11 @@
if (HasBrowsingContext()) {
if (html_element_context_->remote_typeface_cache()) {
html_element_context_->remote_typeface_cache()->set_security_callback(
- base::Bind(&web::CspDelegate::CanLoad,
- base::Unretained(csp_delegate_.get()),
- web::CspDelegate::kFont));
+ CreateSecurityCallback(csp_delegate(), web::CspDelegate::kFont));
}
-
if (html_element_context_->image_cache()) {
- html_element_context_->image_cache()->set_security_callback(base::Bind(
- &web::CspDelegate::CanLoad, base::Unretained(csp_delegate_.get()),
- web::CspDelegate::kImage));
+ html_element_context_->image_cache()->set_security_callback(
+ CreateSecurityCallback(csp_delegate(), web::CspDelegate::kImage));
}
ready_state_ = kDocumentReadyStateLoading;
@@ -640,7 +636,7 @@
void Document::NotifyUrlChanged(const GURL& url) {
location_->set_url(url);
- csp_delegate_->NotifyUrlChanged(url);
+ csp_delegate()->NotifyUrlChanged(url);
}
void Document::OnFocusChange() {
diff --git a/cobalt/dom/document.h b/cobalt/dom/document.h
index b50a8d9..2fc0246 100644
--- a/cobalt/dom/document.h
+++ b/cobalt/dom/document.h
@@ -55,8 +55,6 @@
#include "cobalt/network_bridge/net_poster.h"
#include "cobalt/script/exception_state.h"
#include "cobalt/script/wrappable.h"
-#include "cobalt/web/csp_delegate.h"
-#include "cobalt/web/csp_delegate_type.h"
#include "cobalt/web/event.h"
#include "starboard/time.h"
#include "url/gurl.h"
@@ -105,15 +103,9 @@
public ApplicationLifecycleState::Observer {
public:
struct Options {
- Options()
- : window(NULL),
- cookie_jar(NULL),
- csp_enforcement_mode(web::kCspEnforcementEnable) {}
+ Options() : window(NULL), cookie_jar(NULL) {}
explicit Options(const GURL& url_value)
- : url(url_value),
- window(NULL),
- cookie_jar(NULL),
- csp_enforcement_mode(web::kCspEnforcementEnable) {}
+ : url(url_value), window(NULL), cookie_jar(NULL) {}
Options(const GURL& url_value, Window* window,
const base::Closure& hashchange_callback,
const scoped_refptr<base::BasicClock>& navigation_start_clock_value,
@@ -121,11 +113,7 @@
const scoped_refptr<cssom::CSSStyleSheet> user_agent_style_sheet,
const base::Optional<cssom::ViewportSize>& viewport_size,
network_bridge::CookieJar* cookie_jar,
- const network_bridge::PostSender& post_sender,
- csp::CSPHeaderPolicy require_csp,
- web::CspEnforcementType csp_enforcement_mode,
- const base::Closure& csp_policy_changed_callback,
- int csp_insecure_allowed_token = 0, int dom_max_element_depth = 0)
+ int dom_max_element_depth = 0)
: url(url_value),
window(window),
hashchange_callback(hashchange_callback),
@@ -134,11 +122,6 @@
user_agent_style_sheet(user_agent_style_sheet),
viewport_size(viewport_size),
cookie_jar(cookie_jar),
- post_sender(post_sender),
- require_csp(require_csp),
- csp_enforcement_mode(csp_enforcement_mode),
- csp_policy_changed_callback(csp_policy_changed_callback),
- csp_insecure_allowed_token(csp_insecure_allowed_token),
dom_max_element_depth(dom_max_element_depth) {}
GURL url;
@@ -149,11 +132,6 @@
scoped_refptr<cssom::CSSStyleSheet> user_agent_style_sheet;
base::Optional<cssom::ViewportSize> viewport_size;
network_bridge::CookieJar* cookie_jar;
- network_bridge::PostSender post_sender;
- csp::CSPHeaderPolicy require_csp;
- web::CspEnforcementType csp_enforcement_mode;
- base::Closure csp_policy_changed_callback;
- int csp_insecure_allowed_token;
int dom_max_element_depth;
};
@@ -386,7 +364,13 @@
return navigation_start_clock_;
}
- web::CspDelegate* csp_delegate() const { return csp_delegate_.get(); }
+ // Virtual for testing.
+ virtual web::CspDelegate* csp_delegate() const {
+ if (window_) {
+ return window_->csp_delegate();
+ }
+ return nullptr;
+ }
// Triggers a synchronous layout.
scoped_refptr<render_tree::Node> DoSynchronousLayoutAndGetRenderTree();
@@ -594,8 +578,6 @@
// Viewport size.
base::Optional<cssom::ViewportSize> viewport_size_;
- // Content Security Policy enforcement for this document.
- std::unique_ptr<web::CspDelegate> csp_delegate_;
network_bridge::CookieJar* cookie_jar_;
// Associated location object.
scoped_refptr<Location> location_;
diff --git a/cobalt/dom/document_test.cc b/cobalt/dom/document_test.cc
index 434fc9b..8909802 100644
--- a/cobalt/dom/document_test.cc
+++ b/cobalt/dom/document_test.cc
@@ -34,6 +34,7 @@
#include "cobalt/dom/location.h"
#include "cobalt/dom/mouse_event.h"
#include "cobalt/dom/node_list.h"
+#include "cobalt/dom/testing/fake_document.h"
#include "cobalt/dom/testing/html_collection_testing.h"
#include "cobalt/dom/testing/stub_environment_settings.h"
#include "cobalt/dom/text.h"
@@ -90,26 +91,30 @@
//////////////////////////////////////////////////////////////////////////
TEST_F(DocumentTest, Create) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
ASSERT_TRUE(document);
EXPECT_EQ(Node::kDocumentNode, document->node_type());
EXPECT_EQ("#document", document->node_name());
GURL url("http://a valid url");
- document = new Document(&html_element_context_, Document::Options(url));
+ document =
+ new testing::FakeDocument(&html_element_context_, Document::Options(url));
EXPECT_EQ(url.spec(), document->url());
EXPECT_EQ(url.spec(), document->document_uri());
EXPECT_EQ(url, document->url_as_gurl());
}
TEST_F(DocumentTest, IsNotXMLDocument) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
EXPECT_FALSE(document->IsXMLDocument());
}
TEST_F(DocumentTest, DocumentElement) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
EXPECT_EQ(NULL, document->document_element().get());
scoped_refptr<Text> text = new Text(document, "test_text");
@@ -121,7 +126,8 @@
}
TEST_F(DocumentTest, CreateElement) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
scoped_refptr<Element> element = document->CreateElement("element");
EXPECT_EQ(Node::kElementNode, element->node_type());
@@ -137,7 +143,8 @@
}
TEST_F(DocumentTest, CreateTextNode) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
scoped_refptr<Text> text = document->CreateTextNode("test_text");
EXPECT_EQ(Node::kTextNode, text->node_type());
@@ -147,7 +154,8 @@
}
TEST_F(DocumentTest, CreateComment) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
scoped_refptr<Comment> comment = document->CreateComment("test_comment");
EXPECT_EQ(Node::kCommentNode, comment->node_type());
@@ -159,7 +167,8 @@
TEST_F(DocumentTest, CreateEventEvent) {
StrictMock<MockExceptionState> exception_state;
scoped_refptr<script::ScriptException> exception;
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
// Create an Event, the name is case insensitive.
scoped_refptr<web::Event> event =
@@ -183,7 +192,8 @@
TEST_F(DocumentTest, CreateEventCustomEvent) {
StrictMock<MockExceptionState> exception_state;
scoped_refptr<script::ScriptException> exception;
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
// Create an Event, the name is case insensitive.
scoped_refptr<web::Event> event =
@@ -196,7 +206,8 @@
TEST_F(DocumentTest, CreateEventUIEvent) {
StrictMock<MockExceptionState> exception_state;
scoped_refptr<script::ScriptException> exception;
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
// Create an Event, the name is case insensitive.
scoped_refptr<web::Event> event =
@@ -214,7 +225,8 @@
TEST_F(DocumentTest, CreateEventKeyboardEvent) {
StrictMock<MockExceptionState> exception_state;
scoped_refptr<script::ScriptException> exception;
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
// Create an Event, the name is case insensitive.
scoped_refptr<web::Event> event =
@@ -232,7 +244,8 @@
TEST_F(DocumentTest, CreateEventMessageEvent) {
StrictMock<MockExceptionState> exception_state;
scoped_refptr<script::ScriptException> exception;
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
// Create an Event, the name is case insensitive.
scoped_refptr<web::Event> event =
@@ -245,7 +258,8 @@
TEST_F(DocumentTest, CreateEventMouseEvent) {
StrictMock<MockExceptionState> exception_state;
scoped_refptr<script::ScriptException> exception;
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
// Create an Event, the name is case insensitive.
scoped_refptr<web::Event> event =
@@ -263,7 +277,8 @@
TEST_F(DocumentTest, CreateEventEventNotSupported) {
StrictMock<MockExceptionState> exception_state;
scoped_refptr<script::ScriptException> exception;
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
EXPECT_CALL(exception_state, SetException(_))
.WillOnce(SaveArg<0>(&exception));
@@ -278,17 +293,20 @@
}
TEST_F(DocumentTest, GetElementsByClassName) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
testing::TestGetElementsByClassName(document);
}
TEST_F(DocumentTest, GetElementsByTagName) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
testing::TestGetElementsByTagName(document);
}
TEST_F(DocumentTest, GetElementById) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
// Construct a tree:
// document
@@ -321,17 +339,20 @@
}
TEST_F(DocumentTest, Implementation) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
EXPECT_TRUE(document->implementation());
}
TEST_F(DocumentTest, Location) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
EXPECT_TRUE(document->location());
}
TEST_F(DocumentTest, StyleSheets) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
scoped_refptr<HTMLElement> element1 =
html_element_context_.html_element_factory()->CreateHTMLElement(
@@ -376,7 +397,8 @@
}
TEST_F(DocumentTest, StyleSheetsAddedToFront) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
scoped_refptr<HTMLElement> element1 =
html_element_context_.html_element_factory()->CreateHTMLElement(
@@ -421,7 +443,8 @@
}
TEST_F(DocumentTest, HtmlElement) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
EXPECT_FALSE(document->html());
scoped_refptr<Node> div =
@@ -435,7 +458,8 @@
}
TEST_F(DocumentTest, HeadElement) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
EXPECT_FALSE(document->head());
scoped_refptr<Node> html =
@@ -453,7 +477,8 @@
}
TEST_F(DocumentTest, BodyElement) {
- scoped_refptr<Document> document = new Document(&html_element_context_);
+ scoped_refptr<Document> document =
+ new testing::FakeDocument(&html_element_context_);
EXPECT_FALSE(document->body());
scoped_refptr<Node> html =
diff --git a/cobalt/dom/dom_settings.cc b/cobalt/dom/dom_settings.cc
index 6c9e66d..d07474b 100644
--- a/cobalt/dom/dom_settings.cc
+++ b/cobalt/dom/dom_settings.cc
@@ -28,6 +28,7 @@
DOMSettings::DOMSettings(
const base::DebuggerHooks& debugger_hooks, const int max_dom_element_depth,
MediaSourceRegistry* media_source_registry,
+ const MediaSourceSettings* media_source_settings,
media::CanPlayTypeHandler* can_play_type_handler,
const media::DecoderBufferMemoryInfo* decoder_buffer_memory_info,
MutationObserverTaskManager* mutation_observer_task_manager,
@@ -36,6 +37,7 @@
max_dom_element_depth_(max_dom_element_depth),
microphone_options_(options.microphone_options),
media_source_registry_(media_source_registry),
+ media_source_settings_(media_source_settings),
can_play_type_handler_(can_play_type_handler),
decoder_buffer_memory_info_(decoder_buffer_memory_info),
mutation_observer_task_manager_(mutation_observer_task_manager) {}
diff --git a/cobalt/dom/dom_settings.h b/cobalt/dom/dom_settings.h
index 8eb437a..33a5c0a 100644
--- a/cobalt/dom/dom_settings.h
+++ b/cobalt/dom/dom_settings.h
@@ -15,8 +15,10 @@
#ifndef COBALT_DOM_DOM_SETTINGS_H_
#define COBALT_DOM_DOM_SETTINGS_H_
+#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "cobalt/base/debugger_hooks.h"
+#include "cobalt/dom/media_source_settings.h"
#include "cobalt/dom/mutation_observer_task_manager.h"
#include "cobalt/media/can_play_type_handler.h"
#include "cobalt/media/decoder_buffer_memory_info.h"
@@ -55,6 +57,7 @@
DOMSettings(const base::DebuggerHooks& debugger_hooks,
const int max_dom_element_depth,
MediaSourceRegistry* media_source_registry,
+ const MediaSourceSettings* media_source_settings,
media::CanPlayTypeHandler* can_play_type_handler,
const media::DecoderBufferMemoryInfo* decoder_buffer_memory_info,
MutationObserverTaskManager* mutation_observer_task_manager,
@@ -71,6 +74,9 @@
MediaSourceRegistry* media_source_registry() const {
return media_source_registry_;
}
+ const MediaSourceSettings* media_source_settings() const {
+ return media_source_settings_;
+ }
void set_decoder_buffer_memory_info(
const media::DecoderBufferMemoryInfo* decoder_buffer_memory_info) {
decoder_buffer_memory_info_ = decoder_buffer_memory_info;
@@ -96,6 +102,7 @@
const int max_dom_element_depth_;
const speech::Microphone::Options microphone_options_;
MediaSourceRegistry* media_source_registry_;
+ const MediaSourceSettings* media_source_settings_;
media::CanPlayTypeHandler* can_play_type_handler_;
const media::DecoderBufferMemoryInfo* decoder_buffer_memory_info_;
MutationObserverTaskManager* mutation_observer_task_manager_;
diff --git a/cobalt/dom/element_test.cc b/cobalt/dom/element_test.cc
index 0128e48..bfdd04d 100644
--- a/cobalt/dom/element_test.cc
+++ b/cobalt/dom/element_test.cc
@@ -31,6 +31,7 @@
#include "cobalt/dom/html_element_context.h"
#include "cobalt/dom/named_node_map.h"
#include "cobalt/dom/node_list.h"
+#include "cobalt/dom/testing/fake_document.h"
#include "cobalt/dom/testing/html_collection_testing.h"
#include "cobalt/dom/testing/stub_environment_settings.h"
#include "cobalt/dom/text.h"
@@ -70,7 +71,7 @@
NULL, dom_stat_tracker_.get(), "",
base::kApplicationStateStarted, NULL, NULL) {
EXPECT_TRUE(GlobalStats::GetInstance()->CheckNoLeaks());
- document_ = new Document(&html_element_context_);
+ document_ = new testing::FakeDocument(&html_element_context_);
xml_document_ = new XMLDocument(&html_element_context_);
}
diff --git a/cobalt/dom/event_queue.cc b/cobalt/dom/event_queue.cc
index 1bd5282..ca851e8 100644
--- a/cobalt/dom/event_queue.cc
+++ b/cobalt/dom/event_queue.cc
@@ -44,6 +44,23 @@
events_.push_back(event);
}
+void EventQueue::EnqueueAndMaybeDispatchImmediately(
+ const scoped_refptr<web::Event>& event) {
+ DCHECK(message_loop_->BelongsToCurrentThread());
+
+ bool was_empty = events_.empty();
+
+ Enqueue(event);
+
+ if (was_empty) {
+ // We can only dispatch the event immediately if there aren't any existing
+ // events in the queue, because dom activities (including events) have to
+ // happen in order, and any existing events in the queue may mean that these
+ // events have to be dispatched after other activities not tracked here.
+ DispatchEvents();
+ }
+}
+
void EventQueue::CancelAllEvents() {
DCHECK(message_loop_->BelongsToCurrentThread());
diff --git a/cobalt/dom/event_queue.h b/cobalt/dom/event_queue.h
index 624bd8e..6aad863 100644
--- a/cobalt/dom/event_queue.h
+++ b/cobalt/dom/event_queue.h
@@ -42,7 +42,13 @@
// The EventTarget is guaranteed to be valid during the life time and should
// usually be the owner.
explicit EventQueue(web::EventTarget* event_target);
+
void Enqueue(const scoped_refptr<web::Event>& event);
+ // Try to dispatch the event immediately if there are no existing events in
+ // the queue, otherwise it has the same behavior as Enqueue(), which enqueues
+ // the event and the event will be dispatched after the existing events.
+ void EnqueueAndMaybeDispatchImmediately(
+ const scoped_refptr<web::Event>& event);
void CancelAllEvents();
void TraceMembers(script::Tracer* tracer) override;
diff --git a/cobalt/dom/event_queue_test.cc b/cobalt/dom/event_queue_test.cc
index e8fc35f..be4a970 100644
--- a/cobalt/dom/event_queue_test.cc
+++ b/cobalt/dom/event_queue_test.cc
@@ -90,6 +90,42 @@
base::RunLoop().RunUntilIdle();
}
+TEST_F(EventQueueTest, EnqueueAndMaybeDispatchImmediatelyTest) {
+ scoped_refptr<web::EventTarget> event_target =
+ new web::EventTarget(&environment_settings_);
+ scoped_refptr<web::Event> event = new web::Event(base::Token("event"));
+ std::unique_ptr<MockEventListener> event_listener =
+ MockEventListener::Create();
+ EventQueue event_queue(event_target.get());
+
+ event->set_target(event_target);
+ event_target->AddEventListener(
+ "event", FakeScriptValue<web::EventListener>(event_listener.get()),
+ false);
+
+ {
+ ::testing::InSequence s;
+ ExpectHandleEventCallWithEventAndTarget(event_listener.get(), event,
+ event_target);
+ // The event should be dispatched immediately as the queue is empty, so the
+ // expectation should be set before being enqueued.
+ event_queue.EnqueueAndMaybeDispatchImmediately(event);
+ }
+
+ {
+ ::testing::InSequence s;
+ event_queue.Enqueue(event);
+ // The event won't be dispatched immediately as the queue isn't empty, so
+ // the expectations can be set after being enqueued.
+ event_queue.EnqueueAndMaybeDispatchImmediately(event);
+ ExpectHandleEventCallWithEventAndTarget(event_listener.get(), event,
+ event_target);
+ ExpectHandleEventCallWithEventAndTarget(event_listener.get(), event,
+ event_target);
+ base::RunLoop().RunUntilIdle();
+ }
+}
+
TEST_F(EventQueueTest, CancelAllEventsTest) {
scoped_refptr<web::EventTarget> event_target =
new web::EventTarget(&environment_settings_);
diff --git a/cobalt/dom/html_element_test.cc b/cobalt/dom/html_element_test.cc
index e8936f9..9426a09 100644
--- a/cobalt/dom/html_element_test.cc
+++ b/cobalt/dom/html_element_test.cc
@@ -31,6 +31,7 @@
#include "cobalt/dom/html_div_element.h"
#include "cobalt/dom/html_element_context.h"
#include "cobalt/dom/named_node_map.h"
+#include "cobalt/dom/testing/fake_document.h"
#include "cobalt/dom/testing/mock_layout_boxes.h"
#include "cobalt/dom/testing/stub_environment_settings.h"
#include "cobalt/dom/testing/stub_window.h"
@@ -86,7 +87,7 @@
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, NULL, NULL, NULL, dom_stat_tracker_.get(),
"", base::kApplicationStateStarted, NULL, NULL),
- document_(new Document(&html_element_context_)) {}
+ document_(new testing::FakeDocument(&html_element_context_)) {}
~HTMLElementTest() override {}
// This creates simple DOM tree with mock layout boxes for all elements except
diff --git a/cobalt/dom/media_source.cc b/cobalt/dom/media_source.cc
index 290996f..f9f2c05 100644
--- a/cobalt/dom/media_source.cc
+++ b/cobalt/dom/media_source.cc
@@ -52,7 +52,9 @@
#include "base/compiler_specific.h"
#include "base/guid.h"
#include "base/logging.h"
+#include "base/single_thread_task_runner.h"
#include "base/trace_event/trace_event.h"
+#include "cobalt/base/polymorphic_downcast.h"
#include "cobalt/base/tokens.h"
#include "cobalt/dom/dom_settings.h"
#include "cobalt/web/dom_exception.h"
@@ -63,19 +65,80 @@
namespace cobalt {
namespace dom {
+namespace {
+
using ::media::CHUNK_DEMUXER_ERROR_EOS_STATUS_DECODE_ERROR;
using ::media::CHUNK_DEMUXER_ERROR_EOS_STATUS_NETWORK_ERROR;
using ::media::PIPELINE_OK;
using ::media::PipelineStatus;
+auto GetMediaSettings(script::EnvironmentSettings* settings) {
+ DOMSettings* dom_settings =
+ base::polymorphic_downcast<DOMSettings*>(settings);
+ DCHECK(dom_settings);
+ DCHECK(dom_settings->media_source_settings());
+ return dom_settings->media_source_settings();
+}
+
+// If the system has more processors than the specified value, SourceBuffer
+// append and remove algorithm will be offloaded to a non-web thread to reduce
+// the load on the web thread.
+// The default value is 2. Set to a reasonably high value (say 1024) will
+// disable algorithm offloading completely.
+bool IsAlgorithmOffloadEnabled(script::EnvironmentSettings* settings) {
+ int min_process_count_to_offload =
+ GetMediaSettings(settings)
+ ->GetMinimumProcessorCountToOffloadAlgorithm()
+ .value_or(2);
+ DCHECK_GE(min_process_count_to_offload, 0);
+ return SbSystemGetNumberOfProcessors() >= min_process_count_to_offload;
+}
+
+// If this function returns true, SourceBuffer will reduce asynchronous
+// behaviors. For example, queued events will be dispatached immediately when
+// possible.
+// The default value is true.
+bool IsAsynchronousReductionEnabled(script::EnvironmentSettings* settings) {
+ return GetMediaSettings(settings)->IsAsynchronousReductionEnabled().value_or(
+ true);
+}
+
+// If the size of a job that is part of an algorithm is less than or equal to
+// the return value of this function, the implementation will run the job
+// immediately instead of scheduling it to run later to reduce latency.
+// NOTE: This only works when IsAsynchronousReductionEnabled() returns true,
+// and it is currently only enabled for buffer append.
+// The default value is 16 KB. Set to 0 will disable immediate job completely.
+int GetMinSizeForImmediateJob(script::EnvironmentSettings* settings) {
+ const int kDefaultMinSize = 16 * 1024;
+ auto min_size =
+ GetMediaSettings(settings)->GetMinSizeForImmediateJob().value_or(
+ kDefaultMinSize);
+ DCHECK_GE(min_size, 0);
+ return min_size;
+}
+
+} // namespace
+
MediaSource::MediaSource(script::EnvironmentSettings* settings)
: web::EventTarget(settings),
+ algorithm_offload_enabled_(IsAlgorithmOffloadEnabled(settings)),
+ asynchronous_reduction_enabled_(IsAsynchronousReductionEnabled(settings)),
+ min_size_for_immediate_job_(GetMinSizeForImmediateJob(settings)),
+ default_algorithm_runner_(asynchronous_reduction_enabled_),
chunk_demuxer_(NULL),
ready_state_(kMediaSourceReadyStateClosed),
ALLOW_THIS_IN_INITIALIZER_LIST(event_queue_(this)),
source_buffers_(new SourceBufferList(settings, &event_queue_)),
active_source_buffers_(new SourceBufferList(settings, &event_queue_)),
- live_seekable_range_(new TimeRanges) {}
+ live_seekable_range_(new TimeRanges) {
+ LOG(INFO) << "Algorithm offloading is "
+ << (algorithm_offload_enabled_ ? "enabled" : "disabled");
+ LOG(INFO) << "Asynchronous reduction is "
+ << (asynchronous_reduction_enabled_ ? "enabled" : "disabled");
+ LOG(INFO) << "Min size of immediate job is set to "
+ << min_size_for_immediate_job_;
+}
MediaSource::~MediaSource() { SetReadyState(kMediaSourceReadyStateClosed); }
@@ -179,8 +242,9 @@
ChunkDemuxer::Status status = chunk_demuxer_->AddId(guid, type);
switch (status) {
case ChunkDemuxer::kOk:
- source_buffer =
- new SourceBuffer(settings, guid, this, chunk_demuxer_, &event_queue_);
+ source_buffer = new SourceBuffer(settings, guid, this,
+ asynchronous_reduction_enabled_,
+ chunk_demuxer_, &event_queue_);
break;
case ChunkDemuxer::kNotSupported:
web::DOMException::Raise(web::DOMException::kNotSupportedErr,
@@ -310,8 +374,28 @@
}
DCHECK(IsClosed());
+ DCHECK(!algorithm_process_thread_);
+
attached_element_ = base::AsWeakPtr(media_element);
has_max_video_capabilities_ = media_element->HasMaxVideoCapabilities();
+
+ if (algorithm_offload_enabled_) {
+ algorithm_process_thread_.reset(new base::Thread("MSEAlgorithm"));
+ if (!algorithm_process_thread_->Start()) {
+ LOG(WARNING) << "Starting algorithm process thread failed, disable"
+ " algorithm offloading";
+ algorithm_process_thread_.reset();
+ }
+ }
+
+ if (algorithm_process_thread_) {
+ LOG(INFO) << "Algorithm offloading enabled.";
+ offload_algorithm_runner_.reset(new OffloadAlgorithmRunner(
+ algorithm_process_thread_->message_loop()->task_runner(),
+ base::MessageLoop::current()->task_runner()));
+ } else {
+ LOG(INFO) << "Algorithm offloading disabled.";
+ }
return true;
}
@@ -490,6 +574,18 @@
return has_max_video_capabilities_;
}
+SerializedAlgorithmRunner* MediaSource::GetAlgorithmRunner(int job_size) {
+ if (!offload_algorithm_runner_) {
+ return &default_algorithm_runner_;
+ }
+ if (asynchronous_reduction_enabled_ &&
+ job_size <= min_size_for_immediate_job_) {
+ // Append without posting new tasks is only supported on the default runner.
+ return &default_algorithm_runner_;
+ }
+ return offload_algorithm_runner_.get();
+}
+
void MediaSource::TraceMembers(script::Tracer* tracer) {
web::EventTarget::TraceMembers(tracer);
@@ -536,6 +632,12 @@
attached_element_.reset();
ScheduleEvent(base::Tokens::sourceclose());
+
+ if (algorithm_process_thread_) {
+ algorithm_process_thread_->Stop();
+ algorithm_process_thread_.reset();
+ }
+ offload_algorithm_runner_.reset();
}
bool MediaSource::IsUpdating() const {
diff --git a/cobalt/dom/media_source.h b/cobalt/dom/media_source.h
index de7bccb..bfe0774 100644
--- a/cobalt/dom/media_source.h
+++ b/cobalt/dom/media_source.h
@@ -45,16 +45,19 @@
#ifndef COBALT_DOM_MEDIA_SOURCE_H_
#define COBALT_DOM_MEDIA_SOURCE_H_
+#include <memory>
#include <string>
#include "base/memory/ref_counted.h"
#include "base/memory/weak_ptr.h"
+#include "base/threading/thread.h"
#include "cobalt/base/token.h"
#include "cobalt/dom/audio_track.h"
#include "cobalt/dom/event_queue.h"
#include "cobalt/dom/html_media_element.h"
#include "cobalt/dom/media_source_end_of_stream_error.h"
#include "cobalt/dom/media_source_ready_state.h"
+#include "cobalt/dom/serialized_algorithm_runner.h"
#include "cobalt/dom/source_buffer.h"
#include "cobalt/dom/source_buffer_list.h"
#include "cobalt/dom/time_ranges.h"
@@ -123,6 +126,7 @@
void SetSourceBufferActive(SourceBuffer* source_buffer, bool is_active);
HTMLMediaElement* GetMediaElement() const;
bool MediaElementHasMaxVideoCapabilities() const;
+ SerializedAlgorithmRunner* GetAlgorithmRunner(int job_size);
DEFINE_WRAPPABLE_TYPE(MediaSource);
void TraceMembers(script::Tracer* tracer) override;
@@ -132,6 +136,23 @@
bool IsUpdating() const;
void ScheduleEvent(base::Token event_name);
+ // Set to true to offload SourceBuffer buffer append and removal algorithms to
+ // a non-web thread.
+ const bool algorithm_offload_enabled_;
+ // Set to true to reduce asynchronous behaviors. For example, queued events
+ // will be dispatached immediately when possible.
+ const bool asynchronous_reduction_enabled_;
+ // Only used when |asynchronous_reduction_enabled_| is set true, where any
+ // buffer append job smaller than its value will happen immediately instead of
+ // being scheduled asynchronously.
+ const int min_size_for_immediate_job_;
+
+ // The default algorithm runner runs all steps on the web thread.
+ DefaultAlgorithmRunner default_algorithm_runner_;
+ // The offload algorithm runner offloads some steps to a non-web thread.
+ std::unique_ptr<OffloadAlgorithmRunner> offload_algorithm_runner_;
+ std::unique_ptr<base::Thread> algorithm_process_thread_;
+
ChunkDemuxer* chunk_demuxer_;
MediaSourceReadyState ready_state_;
EventQueue event_queue_;
diff --git a/cobalt/dom/media_source_settings.cc b/cobalt/dom/media_source_settings.cc
new file mode 100644
index 0000000..a330f83
--- /dev/null
+++ b/cobalt/dom/media_source_settings.cc
@@ -0,0 +1,64 @@
+// 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.
+
+#include "cobalt/dom/media_source_settings.h"
+
+#include <cstring>
+
+#include "base/logging.h"
+
+namespace cobalt {
+namespace dom {
+
+bool MediaSourceSettingsImpl::Set(const std::string& name, int value) {
+ const char kPrefix[] = "MediaSource.";
+ if (name.compare(0, strlen(kPrefix), kPrefix) != 0) {
+ return false;
+ }
+
+ base::AutoLock auto_lock(lock_);
+ if (name == "MediaSource.SourceBufferEvictExtraInBytes") {
+ if (value >= 0) {
+ source_buffer_evict_extra_in_bytes_ = value;
+ LOG(INFO) << name << ": set to " << value;
+ return true;
+ }
+ } else if (name == "MediaSource.MinimumProcessorCountToOffloadAlgorithm") {
+ if (value >= 0) {
+ minimum_processor_count_to_offload_algorithm_ = value;
+ LOG(INFO) << name << ": set to " << value;
+ return true;
+ }
+ } else if (name == "MediaSource.EnableAsynchronousReduction") {
+ if (value == 0 || value == 1) {
+ is_asynchronous_reduction_enabled_ = value != 0;
+ LOG(INFO) << name << ": set to " << value;
+ return true;
+ }
+ } else if (name == "MediaSource.MinSizeForImmediateJob") {
+ if (value >= 0) {
+ min_size_for_immediate_job_ = value;
+ LOG(INFO) << name << ": set to " << value;
+ return true;
+ }
+ } else {
+ LOG(WARNING) << "Ignore unknown setting with name \"" << name << "\"";
+ return false;
+ }
+ LOG(WARNING) << name << ": ignore invalid value " << value;
+ return false;
+}
+
+} // namespace dom
+} // namespace cobalt
diff --git a/cobalt/dom/media_source_settings.h b/cobalt/dom/media_source_settings.h
new file mode 100644
index 0000000..8d1b0be
--- /dev/null
+++ b/cobalt/dom/media_source_settings.h
@@ -0,0 +1,87 @@
+// 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.
+
+#ifndef COBALT_DOM_MEDIA_SOURCE_SETTINGS_H_
+#define COBALT_DOM_MEDIA_SOURCE_SETTINGS_H_
+
+#include <string>
+
+#include "base/optional.h"
+#include "base/synchronization/lock.h"
+
+namespace cobalt {
+namespace dom {
+
+// Holds WebModule wide settings for MediaSource related objects. Their default
+// values are set in MediaSource related implementations, and the default values
+// will be overridden if the return values of the member functions are
+// non-empty.
+// Please refer to where these functions are called for the particular
+// MediaSource behaviors being controlled by them.
+class MediaSourceSettings {
+ public:
+ virtual base::Optional<int> GetSourceBufferEvictExtraInBytes() const = 0;
+ virtual base::Optional<int> GetMinimumProcessorCountToOffloadAlgorithm()
+ const = 0;
+ virtual base::Optional<bool> IsAsynchronousReductionEnabled() const = 0;
+ virtual base::Optional<int> GetMinSizeForImmediateJob() const = 0;
+
+ protected:
+ MediaSourceSettings() = default;
+ ~MediaSourceSettings() = default;
+
+ MediaSourceSettings(const MediaSourceSettings&) = delete;
+ MediaSourceSettings& operator=(const MediaSourceSettings&) = delete;
+};
+
+// Allows setting the values of MediaSource settings via a name and an int
+// value.
+// This class is thread safe.
+class MediaSourceSettingsImpl : public MediaSourceSettings {
+ public:
+ base::Optional<int> GetSourceBufferEvictExtraInBytes() const override {
+ base::AutoLock auto_lock(lock_);
+ return source_buffer_evict_extra_in_bytes_;
+ }
+ base::Optional<int> GetMinimumProcessorCountToOffloadAlgorithm()
+ const override {
+ base::AutoLock auto_lock(lock_);
+ return minimum_processor_count_to_offload_algorithm_;
+ }
+ base::Optional<bool> IsAsynchronousReductionEnabled() const override {
+ base::AutoLock auto_lock(lock_);
+ return is_asynchronous_reduction_enabled_;
+ }
+ base::Optional<int> GetMinSizeForImmediateJob() const override {
+ base::AutoLock auto_lock(lock_);
+ return min_size_for_immediate_job_;
+ }
+
+ // Returns true when the setting associated with `name` is set to `value`.
+ // Returns false when `name` is not associated with any settings, or if
+ // `value` contains an invalid value.
+ bool Set(const std::string& name, int value);
+
+ private:
+ mutable base::Lock lock_;
+ base::Optional<int> source_buffer_evict_extra_in_bytes_;
+ base::Optional<int> minimum_processor_count_to_offload_algorithm_;
+ base::Optional<bool> is_asynchronous_reduction_enabled_;
+ base::Optional<int> min_size_for_immediate_job_;
+};
+
+} // namespace dom
+} // namespace cobalt
+
+#endif // COBALT_DOM_MEDIA_SOURCE_SETTINGS_H_
diff --git a/cobalt/dom/media_source_settings_test.cc b/cobalt/dom/media_source_settings_test.cc
new file mode 100644
index 0000000..27d9e9e
--- /dev/null
+++ b/cobalt/dom/media_source_settings_test.cc
@@ -0,0 +1,107 @@
+// 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.
+
+#include "cobalt/dom/media_source_settings.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cobalt {
+namespace dom {
+namespace {
+
+TEST(MediaSourceSettingsImplTest, Empty) {
+ MediaSourceSettingsImpl impl;
+
+ EXPECT_FALSE(impl.GetSourceBufferEvictExtraInBytes());
+ EXPECT_FALSE(impl.GetMinimumProcessorCountToOffloadAlgorithm());
+ EXPECT_FALSE(impl.IsAsynchronousReductionEnabled());
+ EXPECT_FALSE(impl.GetMinSizeForImmediateJob());
+}
+
+TEST(MediaSourceSettingsImplTest, SunnyDay) {
+ MediaSourceSettingsImpl impl;
+
+ ASSERT_TRUE(impl.Set("MediaSource.SourceBufferEvictExtraInBytes", 100));
+ ASSERT_TRUE(
+ impl.Set("MediaSource.MinimumProcessorCountToOffloadAlgorithm", 101));
+ ASSERT_TRUE(impl.Set("MediaSource.EnableAsynchronousReduction", 1));
+ ASSERT_TRUE(impl.Set("MediaSource.MinSizeForImmediateJob", 103));
+
+ EXPECT_EQ(impl.GetSourceBufferEvictExtraInBytes().value(), 100);
+ EXPECT_EQ(impl.GetMinimumProcessorCountToOffloadAlgorithm().value(), 101);
+ EXPECT_TRUE(impl.IsAsynchronousReductionEnabled().value());
+ EXPECT_EQ(impl.GetMinSizeForImmediateJob().value(), 103);
+}
+
+TEST(MediaSourceSettingsImplTest, RainyDay) {
+ MediaSourceSettingsImpl impl;
+
+ ASSERT_FALSE(impl.Set("MediaSource.SourceBufferEvictExtraInBytes", -100));
+ ASSERT_FALSE(
+ impl.Set("MediaSource.MinimumProcessorCountToOffloadAlgorithm", -101));
+ ASSERT_FALSE(impl.Set("MediaSource.EnableAsynchronousReduction", 2));
+ ASSERT_FALSE(impl.Set("MediaSource.MinSizeForImmediateJob", -103));
+
+ EXPECT_FALSE(impl.GetSourceBufferEvictExtraInBytes());
+ EXPECT_FALSE(impl.GetMinimumProcessorCountToOffloadAlgorithm());
+ EXPECT_FALSE(impl.IsAsynchronousReductionEnabled());
+ EXPECT_FALSE(impl.GetMinSizeForImmediateJob());
+}
+
+TEST(MediaSourceSettingsImplTest, ZeroValuesWork) {
+ MediaSourceSettingsImpl impl;
+
+ ASSERT_TRUE(impl.Set("MediaSource.SourceBufferEvictExtraInBytes", 0));
+ ASSERT_TRUE(
+ impl.Set("MediaSource.MinimumProcessorCountToOffloadAlgorithm", 0));
+ ASSERT_TRUE(impl.Set("MediaSource.EnableAsynchronousReduction", 0));
+ ASSERT_TRUE(impl.Set("MediaSource.MinSizeForImmediateJob", 0));
+
+ EXPECT_EQ(impl.GetSourceBufferEvictExtraInBytes().value(), 0);
+ EXPECT_EQ(impl.GetMinimumProcessorCountToOffloadAlgorithm().value(), 0);
+ EXPECT_FALSE(impl.IsAsynchronousReductionEnabled().value());
+ EXPECT_EQ(impl.GetMinSizeForImmediateJob().value(), 0);
+}
+
+TEST(MediaSourceSettingsImplTest, Updatable) {
+ MediaSourceSettingsImpl impl;
+
+ ASSERT_TRUE(impl.Set("MediaSource.SourceBufferEvictExtraInBytes", 0));
+ ASSERT_TRUE(
+ impl.Set("MediaSource.MinimumProcessorCountToOffloadAlgorithm", 0));
+ ASSERT_TRUE(impl.Set("MediaSource.EnableAsynchronousReduction", 0));
+ ASSERT_TRUE(impl.Set("MediaSource.MinSizeForImmediateJob", 0));
+
+ ASSERT_TRUE(impl.Set("MediaSource.SourceBufferEvictExtraInBytes", 1));
+ ASSERT_TRUE(
+ impl.Set("MediaSource.MinimumProcessorCountToOffloadAlgorithm", 1));
+ ASSERT_TRUE(impl.Set("MediaSource.EnableAsynchronousReduction", 1));
+ ASSERT_TRUE(impl.Set("MediaSource.MinSizeForImmediateJob", 1));
+
+ EXPECT_EQ(impl.GetSourceBufferEvictExtraInBytes().value(), 1);
+ EXPECT_EQ(impl.GetMinimumProcessorCountToOffloadAlgorithm().value(), 1);
+ EXPECT_TRUE(impl.IsAsynchronousReductionEnabled().value());
+ EXPECT_EQ(impl.GetMinSizeForImmediateJob().value(), 1);
+}
+
+TEST(MediaSourceSettingsImplTest, InvalidSettingNames) {
+ MediaSourceSettingsImpl impl;
+
+ ASSERT_FALSE(impl.Set("MediaSource.Invalid", 0));
+ ASSERT_FALSE(impl.Set("Invalid.SourceBufferEvictExtraInBytes", 0));
+}
+
+} // namespace
+} // namespace dom
+} // namespace cobalt
diff --git a/cobalt/dom/rule_matching_test.cc b/cobalt/dom/rule_matching_test.cc
index e9573e0..e11362e 100644
--- a/cobalt/dom/rule_matching_test.cc
+++ b/cobalt/dom/rule_matching_test.cc
@@ -32,6 +32,7 @@
#include "cobalt/dom/node.h"
#include "cobalt/dom/node_descendants_iterator.h"
#include "cobalt/dom/node_list.h"
+#include "cobalt/dom/testing/fake_document.h"
#include "cobalt/dom/testing/stub_environment_settings.h"
#include "cobalt/dom/testing/stub_window.h"
#include "cobalt/dom_parser/parser.h"
@@ -58,7 +59,7 @@
NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
NULL, dom_stat_tracker_.get(), "",
base::kApplicationStateStarted, NULL, NULL),
- document_(new Document(&html_element_context_)),
+ document_(new testing::FakeDocument(&html_element_context_)),
root_(document_->CreateElement("html")->AsHTMLElement()),
head_(document_->CreateElement("head")->AsHTMLElement()),
body_(document_->CreateElement("body")->AsHTMLElement()) {
diff --git a/cobalt/dom/serialized_algorithm_runner.cc b/cobalt/dom/serialized_algorithm_runner.cc
new file mode 100644
index 0000000..07dece0
--- /dev/null
+++ b/cobalt/dom/serialized_algorithm_runner.cc
@@ -0,0 +1,95 @@
+// 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.
+
+#include "cobalt/dom/serialized_algorithm_runner.h"
+
+#include "base/message_loop/message_loop.h"
+
+namespace cobalt {
+namespace dom {
+
+void DefaultAlgorithmRunner::Start(const scoped_refptr<HandleBase>& handle) {
+ DCHECK(handle);
+ TRACE_EVENT0("cobalt::dom", "DefaultAlgorithmRunner::Start()");
+
+ if (asynchronous_reduction_enabled_) {
+ Process(handle);
+ return;
+ }
+
+ auto task_runner = base::MessageLoop::current()->task_runner();
+ task_runner->PostTask(FROM_HERE,
+ base::BindOnce(&DefaultAlgorithmRunner::Process,
+ base::Unretained(this), handle));
+}
+
+void DefaultAlgorithmRunner::Process(const scoped_refptr<HandleBase>& handle) {
+ DCHECK(handle);
+ TRACE_EVENT0("cobalt::dom", "DefaultAlgorithmRunner::Process()");
+
+ auto task_runner = base::MessageLoop::current()->task_runner();
+
+ bool finished = false;
+ handle->Process(&finished);
+
+ if (finished) {
+ handle->Finalize();
+ return;
+ }
+ task_runner->PostTask(FROM_HERE,
+ base::BindOnce(&DefaultAlgorithmRunner::Process,
+ base::Unretained(this), handle));
+}
+
+OffloadAlgorithmRunner::OffloadAlgorithmRunner(
+ const scoped_refptr<TaskRunner>& process_task_runner,
+ const scoped_refptr<TaskRunner>& finalize_task_runner)
+ : process_task_runner_(process_task_runner),
+ finalize_task_runner_(finalize_task_runner) {
+ DCHECK(process_task_runner_);
+ DCHECK(finalize_task_runner_);
+ DCHECK_NE(process_task_runner_, finalize_task_runner_);
+}
+
+void OffloadAlgorithmRunner::Start(const scoped_refptr<HandleBase>& handle) {
+ DCHECK(handle);
+
+ TRACE_EVENT0("cobalt::dom", "OffloadAlgorithmRunner::Start()");
+
+ process_task_runner_->PostTask(
+ FROM_HERE, base::BindOnce(&OffloadAlgorithmRunner::Process,
+ base::Unretained(this), handle));
+}
+
+void OffloadAlgorithmRunner::Process(const scoped_refptr<HandleBase>& handle) {
+ DCHECK(handle);
+ DCHECK(process_task_runner_->BelongsToCurrentThread());
+
+ TRACE_EVENT0("cobalt::dom", "OffloadAlgorithmRunner::Process()");
+
+ bool finished = false;
+ handle->Process(&finished);
+
+ if (finished) {
+ finalize_task_runner_->PostTask(
+ FROM_HERE, base::BindOnce(&HandleBase::Finalize, handle));
+ return;
+ }
+ process_task_runner_->PostTask(
+ FROM_HERE, base::BindOnce(&OffloadAlgorithmRunner::Process,
+ base::Unretained(this), handle));
+}
+
+} // namespace dom
+} // namespace cobalt
diff --git a/cobalt/dom/serialized_algorithm_runner.h b/cobalt/dom/serialized_algorithm_runner.h
new file mode 100644
index 0000000..d4c2b39
--- /dev/null
+++ b/cobalt/dom/serialized_algorithm_runner.h
@@ -0,0 +1,206 @@
+// 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.
+
+#ifndef COBALT_DOM_SERIALIZED_ALGORITHM_RUNNER_H_
+#define COBALT_DOM_SERIALIZED_ALGORITHM_RUNNER_H_
+
+#include <memory>
+#include <utility>
+
+#include "base/bind.h"
+#include "base/callback.h"
+#include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/single_thread_task_runner.h"
+#include "base/trace_event/trace_event.h"
+#include "starboard/common/mutex.h"
+
+namespace cobalt {
+namespace dom {
+
+// This class defines a common interface to run algorithms, and an algorithm is
+// any class with the following methods:
+// void Process(bool* finished);
+// void Abort();
+// void Finalize();
+//
+// For example, with a class:
+// class Download {
+// void Process(bool* finished) {
+// // Download some data
+// // *finished = whether download is finished.
+// }
+// void Abort() {
+// // Cancel the download, and neither Process() nor Finalize() will be
+// // called again.
+// }
+// void Finalize() {
+// // Queue an event to notify that the download has finished.
+// }
+// };
+//
+// This class will keep calling Process() until |finished| becomes false, and
+// then call Finalize(). It guarantees that all calls won't be overlapped and
+// the member functions of the algorithm don't have to synchronize between them.
+class SerializedAlgorithmRunner {
+ public:
+ // Abstract the non-template part of the Handle class, and shouldn't be used
+ // directly.
+ class HandleBase : public base::RefCountedThreadSafe<HandleBase> {
+ public:
+ virtual ~HandleBase() {}
+
+ virtual void Process(bool* finished) = 0;
+ virtual void Finalize() = 0;
+ };
+
+ // A handle object for a running algorithm instance, to allow for aborting and
+ // access the algorithm.
+ template <typename SerializedAlgorithm>
+ class Handle : public HandleBase {
+ public:
+ explicit Handle(std::unique_ptr<SerializedAlgorithm> algorithm);
+
+ // Abort the algorithm and no more processing will happen on return. It is
+ // possible that Process() has already finished asynchronously, in which
+ // case this function will call Finalize() instead (if it hasn't been called
+ // yet).
+ void Abort();
+ SerializedAlgorithm* algorithm() const { return algorithm_.get(); }
+
+ private:
+ void Process(bool* finished) override;
+ void Finalize() override;
+
+ // The |mutex_| is necessary as `Abort()` can be called from any thread.
+ starboard::Mutex mutex_;
+ std::unique_ptr<SerializedAlgorithm> algorithm_;
+ bool aborted_ = false;
+ bool finished_ = false;
+ bool finalized_ = false;
+ };
+
+ virtual ~SerializedAlgorithmRunner() {}
+
+ virtual void Start(const scoped_refptr<HandleBase>& handle) = 0;
+};
+
+template <typename SerializedAlgorithm>
+SerializedAlgorithmRunner::Handle<SerializedAlgorithm>::Handle(
+ std::unique_ptr<SerializedAlgorithm> algorithm)
+ : algorithm_(std::move(algorithm)) {
+ DCHECK(algorithm_);
+}
+
+template <typename SerializedAlgorithm>
+void SerializedAlgorithmRunner::Handle<SerializedAlgorithm>::Abort() {
+ TRACE_EVENT0("cobalt::dom", "SerializedAlgorithmRunner::Handle::Abort()");
+
+ starboard::ScopedLock scoped_lock(mutex_);
+
+ DCHECK(!aborted_); // Abort() cannot be called twice.
+
+ if (finished_) {
+ // If the algorithm has finished, just call Finalize() to treat it as
+ // finished instead of aborted.
+ if (!finalized_) {
+ algorithm_->Finalize();
+ }
+ } else {
+ algorithm_->Abort();
+ }
+
+ algorithm_.reset();
+ aborted_ = true;
+}
+
+template <typename SerializedAlgorithm>
+void SerializedAlgorithmRunner::Handle<SerializedAlgorithm>::Process(
+ bool* finished) {
+ TRACE_EVENT0("cobalt::dom", "SerializedAlgorithmRunner::Handle::Process()");
+
+ DCHECK(finished);
+
+ starboard::ScopedLock scoped_lock(mutex_);
+
+ DCHECK(!finished_);
+ DCHECK(!finalized_);
+
+ if (aborted_) {
+ return;
+ }
+
+ DCHECK(algorithm_);
+ algorithm_->Process(&finished_);
+ *finished = finished_;
+}
+
+template <typename SerializedAlgorithm>
+void SerializedAlgorithmRunner::Handle<SerializedAlgorithm>::Finalize() {
+ TRACE_EVENT0("cobalt::dom", "SerializedAlgorithmRunner::Handle::Finalize()");
+ starboard::ScopedLock scoped_lock(mutex_);
+
+ DCHECK(finished_);
+ DCHECK(!finalized_);
+
+ if (aborted_) {
+ return;
+ }
+
+ DCHECK(algorithm_);
+
+ algorithm_->Finalize();
+ algorithm_.reset();
+ finalized_ = true;
+}
+
+// This class runs algorithm on the task runner associated with the thread where
+// Start() is called.
+class DefaultAlgorithmRunner : public SerializedAlgorithmRunner {
+ public:
+ explicit DefaultAlgorithmRunner(bool asynchronous_reduction_enabled)
+ : asynchronous_reduction_enabled_(asynchronous_reduction_enabled) {}
+
+ private:
+ void Start(const scoped_refptr<HandleBase>& handle) override;
+ void Process(const scoped_refptr<HandleBase>& handle);
+
+ const bool asynchronous_reduction_enabled_;
+};
+
+// This class runs algorithms on two task runners, it can be used to offload
+// processing to another task runner.
+//
+// This class will keep calling the Process() member function of the algorithm
+// on the process task runner, and then call Finalize() on the finalize task
+// runner when |finished| becomes true.
+class OffloadAlgorithmRunner : public SerializedAlgorithmRunner {
+ public:
+ typedef base::SingleThreadTaskRunner TaskRunner;
+
+ OffloadAlgorithmRunner(const scoped_refptr<TaskRunner>& process_task_runner,
+ const scoped_refptr<TaskRunner>& finalize_task_runner);
+
+ private:
+ void Start(const scoped_refptr<HandleBase>& handle) override;
+ void Process(const scoped_refptr<HandleBase>& handle);
+
+ scoped_refptr<TaskRunner> process_task_runner_;
+ scoped_refptr<TaskRunner> finalize_task_runner_;
+};
+
+} // namespace dom
+} // namespace cobalt
+
+#endif // COBALT_DOM_SERIALIZED_ALGORITHM_RUNNER_H_
diff --git a/cobalt/dom/source_buffer.cc b/cobalt/dom/source_buffer.cc
index a8b78e9..f49d151 100644
--- a/cobalt/dom/source_buffer.cc
+++ b/cobalt/dom/source_buffer.cc
@@ -45,9 +45,12 @@
#include "cobalt/dom/source_buffer.h"
#include <algorithm>
+#include <limits>
+#include <utility>
#include "base/compiler_specific.h"
#include "base/logging.h"
+#include "base/message_loop/message_loop.h"
#include "base/time/time.h"
#include "base/trace_event/trace_event.h"
#include "cobalt/base/polymorphic_downcast.h"
@@ -84,26 +87,34 @@
return base::TimeDelta::FromSecondsD(time);
}
+// The return value will be used in `SourceBuffer::EvictCodedFrames()` to allow
+// it to evict extra data from the SourceBuffer, so it can reduce the overall
+// memory used by the underlying Demuxer implementation.
+// The default value is 0, i.e. do not evict extra bytes.
size_t GetEvictExtraInBytes(script::EnvironmentSettings* settings) {
DOMSettings* dom_settings =
base::polymorphic_downcast<DOMSettings*>(settings);
- if (dom_settings && dom_settings->decoder_buffer_memory_info()) {
- return dom_settings->decoder_buffer_memory_info()
- ->GetSourceBufferEvictExtraInBytes();
- }
- return 0;
+ DCHECK(dom_settings);
+ DCHECK(dom_settings->media_source_settings());
+ int bytes = dom_settings->media_source_settings()
+ ->GetSourceBufferEvictExtraInBytes()
+ .value_or(0);
+ DCHECK_GE(bytes, 0);
+ return std::max<int>(bytes, 0);
}
} // namespace
SourceBuffer::SourceBuffer(script::EnvironmentSettings* settings,
const std::string& id, MediaSource* media_source,
+ bool asynchronous_reduction_enabled,
ChunkDemuxer* chunk_demuxer, EventQueue* event_queue)
: web::EventTarget(settings),
id_(id),
+ asynchronous_reduction_enabled_(asynchronous_reduction_enabled),
evict_extra_in_bytes_(GetEvictExtraInBytes(settings)),
- chunk_demuxer_(chunk_demuxer),
media_source_(media_source),
+ chunk_demuxer_(chunk_demuxer),
event_queue_(event_queue),
audio_tracks_(
new AudioTrackList(settings, media_source->GetMediaElement())),
@@ -115,9 +126,11 @@
DCHECK(chunk_demuxer);
DCHECK(event_queue);
+ LOG(INFO) << "Evict extra in bytes is set to " << evict_extra_in_bytes_;
+
chunk_demuxer_->SetTracksWatcher(
id_,
- base::Bind(&SourceBuffer::InitSegmentReceived, base::Unretained(this)));
+ base::Bind(&SourceBuffer::OnInitSegmentReceived, base::Unretained(this)));
chunk_demuxer_->SetParseWarningCallback(
id, base::BindRepeating([](::media::SourceBufferParseWarning warning) {
LOG(WARNING) << "Encountered SourceBufferParseWarning "
@@ -132,7 +145,7 @@
exception_state);
return;
}
- if (updating_) {
+ if (updating()) {
web::DOMException::Raise(web::DOMException::kInvalidStateErr,
exception_state);
return;
@@ -168,6 +181,12 @@
return time_ranges;
}
+double SourceBuffer::timestamp_offset(
+ script::ExceptionState* exception_state) const {
+ starboard::ScopedLock scoped_lock(timestamp_offset_mutex_);
+ return timestamp_offset_;
+}
+
void SourceBuffer::set_timestamp_offset(
double offset, script::ExceptionState* exception_state) {
if (media_source_ == NULL) {
@@ -175,7 +194,7 @@
exception_state);
return;
}
- if (updating_) {
+ if (updating()) {
web::DOMException::Raise(web::DOMException::kInvalidStateErr,
exception_state);
return;
@@ -189,6 +208,9 @@
return;
}
+ // We don't have to acquire |timestamp_offset_mutex_|, as no algorithms are
+ // running asynchronously at this moment, which is guaranteed by the check of
+ // updating() above.
timestamp_offset_ = offset;
chunk_demuxer_->SetGroupStartTimestampIfInSequenceMode(
@@ -202,7 +224,7 @@
exception_state);
return;
}
- if (updating_) {
+ if (updating()) {
web::DOMException::Raise(web::DOMException::kInvalidStateErr,
exception_state);
return;
@@ -223,7 +245,7 @@
exception_state);
return;
}
- if (updating_) {
+ if (updating()) {
web::DOMException::Raise(web::DOMException::kInvalidStateErr,
exception_state);
return;
@@ -274,20 +296,21 @@
return;
}
- if (pending_remove_start_ != -1) {
- DCHECK(updating_);
- web::DOMException::Raise(web::DOMException::kInvalidStateErr,
- exception_state);
- return;
+ if (active_algorithm_handle_) {
+ if (!active_algorithm_handle_->algorithm()->SupportExplicitAbort()) {
+ web::DOMException::Raise(web::DOMException::kInvalidStateErr,
+ exception_state);
+ return;
+ }
+ active_algorithm_handle_->Abort();
+ active_algorithm_handle_ = nullptr;
}
- AbortIfUpdating();
-
base::TimeDelta timestamp_offset = DoubleToTimeDelta(timestamp_offset_);
chunk_demuxer_->ResetParserState(id_, DoubleToTimeDelta(append_window_start_),
DoubleToTimeDelta(append_window_end_),
×tamp_offset);
- timestamp_offset_ = timestamp_offset.InSecondsF();
+ UpdateTimestampOffset(timestamp_offset);
set_append_window_start(0, exception_state);
set_append_window_end(std::numeric_limits<double>::infinity(),
@@ -303,7 +326,7 @@
exception_state);
return;
}
- if (updating_) {
+ if (updating()) {
web::DOMException::Raise(web::DOMException::kInvalidStateErr,
exception_state);
return;
@@ -322,14 +345,25 @@
media_source_->OpenIfInEndedState();
- updating_ = true;
-
ScheduleEvent(base::Tokens::updatestart());
- pending_remove_start_ = start;
- pending_remove_end_ = end;
- remove_timer_.Start(FROM_HERE, base::TimeDelta(), this,
- &SourceBuffer::OnRemoveTimer);
+ DCHECK_GE(start, 0);
+ DCHECK_LT(start, end);
+
+ std::unique_ptr<SourceBufferAlgorithm> algorithm(
+ new SourceBufferRemoveAlgorithm(
+ chunk_demuxer_, id_, DoubleToTimeDelta(start), DoubleToTimeDelta(end),
+ base::Bind(asynchronous_reduction_enabled_
+ ? &SourceBuffer::ScheduleAndMaybeDispatchImmediately
+ : &SourceBuffer::ScheduleEvent,
+ base::Unretained(this)),
+ base::Bind(&SourceBuffer::OnAlgorithmFinalized,
+ base::Unretained(this))));
+ active_algorithm_handle_ =
+ new SerializedAlgorithmRunner::Handle<SourceBufferAlgorithm>(
+ std::move(algorithm));
+ media_source_->GetAlgorithmRunner(std::numeric_limits<int>::max())
+ ->Start(active_algorithm_handle_);
}
void SourceBuffer::set_track_defaults(
@@ -340,7 +374,7 @@
exception_state);
return;
}
- if (updating_) {
+ if (updating()) {
web::DOMException::Raise(web::DOMException::kInvalidStateErr,
exception_state);
return;
@@ -354,10 +388,9 @@
return;
}
- if (pending_remove_start_ != -1) {
- CancelRemove();
- } else {
- AbortIfUpdating();
+ if (active_algorithm_handle_) {
+ active_algorithm_handle_->Abort();
+ active_algorithm_handle_ = nullptr;
}
DCHECK(media_source_);
@@ -402,8 +435,15 @@
tracer->Trace(video_tracks_);
}
-void SourceBuffer::InitSegmentReceived(std::unique_ptr<MediaTracks> tracks) {
+void SourceBuffer::OnInitSegmentReceived(std::unique_ptr<MediaTracks> tracks) {
if (!first_initialization_segment_received_) {
+ // This can be called from non-web thread when the append is async.
+ if (!web_task_runner_->BelongsToCurrentThread()) {
+ web_task_runner_->PostTask(
+ FROM_HERE, base::Bind(&SourceBuffer::OnInitSegmentReceived, this,
+ base::Passed(&tracks)));
+ return;
+ }
media_source_->SetSourceBufferActive(this, true);
first_initialization_segment_received_ = true;
}
@@ -417,6 +457,12 @@
event_queue_->Enqueue(event);
}
+void SourceBuffer::ScheduleAndMaybeDispatchImmediately(base::Token event_name) {
+ scoped_refptr<web::Event> event = new web::Event(event_name);
+ event->set_target(this);
+ event_queue_->EnqueueAndMaybeDispatchImmediately(event);
+}
+
bool SourceBuffer::PrepareAppend(size_t new_data_size,
script::ExceptionState* exception_state) {
TRACE_EVENT1("cobalt::dom", "SourceBuffer::PrepareAppend()", "new_data_size",
@@ -426,7 +472,7 @@
exception_state);
return false;
}
- if (updating_) {
+ if (updating()) {
web::DOMException::Raise(web::DOMException::kInvalidStateErr,
exception_state);
return false;
@@ -441,7 +487,10 @@
media_source_->OpenIfInEndedState();
- if (!EvictCodedFrames(new_data_size)) {
+ double current_time = media_source_->GetMediaElement()->current_time(NULL);
+ if (!chunk_demuxer_->EvictCodedFrames(
+ id_, base::TimeDelta::FromSecondsD(current_time),
+ new_data_size + evict_extra_in_bytes_)) {
web::DOMException::Raise(web::DOMException::kQuotaExceededErr,
exception_state);
return false;
@@ -450,15 +499,6 @@
return true;
}
-bool SourceBuffer::EvictCodedFrames(size_t new_data_size) {
- DCHECK(media_source_);
- DCHECK(media_source_->GetMediaElement());
- double current_time = media_source_->GetMediaElement()->current_time(NULL);
- return chunk_demuxer_->EvictCodedFrames(
- id_, base::TimeDelta::FromSecondsD(current_time),
- new_data_size + evict_extra_in_bytes_);
-}
-
void SourceBuffer::AppendBufferInternal(
const unsigned char* data, size_t size,
script::ExceptionState* exception_state) {
@@ -471,8 +511,8 @@
metrics_.EndTracking(0);
DCHECK(data || size == 0);
+
if (data) {
- DCHECK_EQ(pending_append_data_offset_, 0u);
if (pending_append_data_capacity_ < size) {
pending_append_data_.reset();
pending_append_data_.reset(new uint8_t[size]);
@@ -480,124 +520,43 @@
}
memcpy(pending_append_data_.get(), data, size);
}
- pending_append_data_size_ = size;
- pending_append_data_offset_ = 0;
-
- updating_ = true;
ScheduleEvent(base::Tokens::updatestart());
- append_timer_.Start(FROM_HERE, base::TimeDelta(), this,
- &SourceBuffer::OnAppendTimer);
+ std::unique_ptr<SourceBufferAlgorithm> algorithm(
+ new SourceBufferAppendAlgorithm(
+ media_source_, chunk_demuxer_, id_, pending_append_data_.get(), size,
+ DoubleToTimeDelta(append_window_start_),
+ DoubleToTimeDelta(append_window_end_),
+ DoubleToTimeDelta(timestamp_offset_),
+ base::Bind(&SourceBuffer::UpdateTimestampOffset,
+ base::Unretained(this)),
+ base::Bind(asynchronous_reduction_enabled_
+ ? &SourceBuffer::ScheduleAndMaybeDispatchImmediately
+ : &SourceBuffer::ScheduleEvent,
+ base::Unretained(this)),
+ base::Bind(&SourceBuffer::OnAlgorithmFinalized,
+ base::Unretained(this)),
+ &metrics_));
+ active_algorithm_handle_ =
+ new SerializedAlgorithmRunner::Handle<SourceBufferAlgorithm>(
+ std::move(algorithm));
+ media_source_->GetAlgorithmRunner(size)->Start(active_algorithm_handle_);
}
-void SourceBuffer::OnAppendTimer() {
- TRACE_EVENT0("cobalt::dom", "SourceBuffer::OnAppendTimer()");
- const size_t kMaxAppendSize = 128 * 1024;
+void SourceBuffer::OnAlgorithmFinalized() {
+ DCHECK(active_algorithm_handle_);
+ active_algorithm_handle_ = nullptr;
+}
- DCHECK(updating_);
-
- DCHECK_GE(pending_append_data_size_, pending_append_data_offset_);
- size_t append_size = pending_append_data_size_ - pending_append_data_offset_;
- append_size = std::min(append_size, kMaxAppendSize);
-
- uint8_t dummy;
- const uint8* data_to_append =
- append_size > 0 ? pending_append_data_.get() + pending_append_data_offset_
- : &dummy;
-
- base::TimeDelta timestamp_offset = DoubleToTimeDelta(timestamp_offset_);
- metrics_.StartTracking();
- bool success = chunk_demuxer_->AppendData(
- id_, data_to_append, append_size, DoubleToTimeDelta(append_window_start_),
- DoubleToTimeDelta(append_window_end_), ×tamp_offset);
-
- if (timestamp_offset != DoubleToTimeDelta(timestamp_offset_)) {
+void SourceBuffer::UpdateTimestampOffset(base::TimeDelta timestamp_offset) {
+ starboard::ScopedLock scoped_lock(timestamp_offset_mutex_);
+ // The check avoids overwriting |timestamp_offset_| when there is a small
+ // difference between its float and its int64_t representation .
+ if (DoubleToTimeDelta(timestamp_offset_) != timestamp_offset) {
timestamp_offset_ = timestamp_offset.InSecondsF();
}
-
- if (!success) {
- metrics_.EndTracking(0);
- pending_append_data_size_ = 0;
- pending_append_data_offset_ = 0;
- AppendError();
- } else {
- metrics_.EndTracking(append_size);
- pending_append_data_offset_ += append_size;
-
- if (pending_append_data_offset_ < pending_append_data_size_) {
- append_timer_.Start(FROM_HERE, base::TimeDelta(), this,
- &SourceBuffer::OnAppendTimer);
- return;
- }
-
- updating_ = false;
- pending_append_data_size_ = 0;
- pending_append_data_offset_ = 0;
-
- ScheduleEvent(base::Tokens::update());
- ScheduleEvent(base::Tokens::updateend());
- }
}
-void SourceBuffer::AppendError() {
- base::TimeDelta timestamp_offset = DoubleToTimeDelta(timestamp_offset_);
- chunk_demuxer_->ResetParserState(id_, DoubleToTimeDelta(append_window_start_),
- DoubleToTimeDelta(append_window_end_),
- ×tamp_offset);
- timestamp_offset_ = timestamp_offset.InSecondsF();
-
- updating_ = false;
-
- ScheduleEvent(base::Tokens::error());
- ScheduleEvent(base::Tokens::updateend());
- media_source_->EndOfStreamAlgorithm(kMediaSourceEndOfStreamErrorDecode);
-}
-
-void SourceBuffer::OnRemoveTimer() {
- TRACE_EVENT0("cobalt::dom", "SourceBuffer::OnRemoveTimer()");
- DCHECK(updating_);
- DCHECK_GE(pending_remove_start_, 0);
- DCHECK_LT(pending_remove_start_, pending_remove_end_);
-
- chunk_demuxer_->Remove(id_, DoubleToTimeDelta(pending_remove_start_),
- DoubleToTimeDelta(pending_remove_end_));
-
- updating_ = false;
- pending_remove_start_ = -1;
- pending_remove_end_ = -1;
-
- ScheduleEvent(base::Tokens::update());
- ScheduleEvent(base::Tokens::updateend());
-}
-
-void SourceBuffer::CancelRemove() {
- DCHECK(updating_);
- DCHECK_NE(pending_remove_start_, -1);
- remove_timer_.Stop();
- pending_remove_start_ = -1;
- pending_remove_end_ = -1;
- updating_ = false;
-}
-
-void SourceBuffer::AbortIfUpdating() {
- if (!updating_) {
- return;
- }
-
- DCHECK_EQ(pending_remove_start_, -1);
-
- append_timer_.Stop();
- pending_append_data_size_ = 0;
- pending_append_data_offset_ = 0;
-
- updating_ = false;
-
- ScheduleEvent(base::Tokens::abort());
- ScheduleEvent(base::Tokens::updateend());
-}
-
-void SourceBuffer::RemoveMediaTracks() { NOTREACHED(); }
-
} // namespace dom
} // namespace cobalt
diff --git a/cobalt/dom/source_buffer.h b/cobalt/dom/source_buffer.h
index 9f68856..65bbe48 100644
--- a/cobalt/dom/source_buffer.h
+++ b/cobalt/dom/source_buffer.h
@@ -53,10 +53,13 @@
#include "base/compiler_specific.h"
#include "base/memory/ref_counted.h"
#include "base/optional.h"
+#include "base/single_thread_task_runner.h"
#include "base/timer/timer.h"
#include "cobalt/base/token.h"
#include "cobalt/dom/audio_track_list.h"
#include "cobalt/dom/event_queue.h"
+#include "cobalt/dom/serialized_algorithm_runner.h"
+#include "cobalt/dom/source_buffer_algorithm.h"
#include "cobalt/dom/source_buffer_append_mode.h"
#include "cobalt/dom/source_buffer_metrics.h"
#include "cobalt/dom/time_ranges.h"
@@ -67,6 +70,7 @@
#include "cobalt/script/environment_settings.h"
#include "cobalt/script/exception_state.h"
#include "cobalt/web/event_target.h"
+#include "starboard/common/mutex.h"
#include "third_party/chromium/media/base/media_tracks.h"
#include "third_party/chromium/media/filters/chunk_demuxer.h"
@@ -85,8 +89,8 @@
// Custom, not in any spec.
//
SourceBuffer(script::EnvironmentSettings* settings, const std::string& id,
- MediaSource* media_source, ChunkDemuxer* chunk_demuxer,
- EventQueue* event_queue);
+ MediaSource* media_source, bool asynchronous_reduction_enabled,
+ ChunkDemuxer* chunk_demuxer, EventQueue* event_queue);
// Web API: SourceBuffer
//
@@ -95,12 +99,10 @@
}
void set_mode(SourceBufferAppendMode mode,
script::ExceptionState* exception_state);
- bool updating() const { return updating_; }
+ bool updating() const { return active_algorithm_handle_ != nullptr; }
scoped_refptr<TimeRanges> buffered(
script::ExceptionState* exception_state) const;
- double timestamp_offset(script::ExceptionState* exception_state) const {
- return timestamp_offset_;
- }
+ double timestamp_offset(script::ExceptionState* exception_state) const;
void set_timestamp_offset(double offset,
script::ExceptionState* exception_state);
scoped_refptr<AudioTrackList> audio_tracks() const { return audio_tracks_; }
@@ -140,22 +142,16 @@
private:
typedef ::media::MediaTracks MediaTracks;
- void InitSegmentReceived(std::unique_ptr<MediaTracks> tracks);
+ void OnInitSegmentReceived(std::unique_ptr<MediaTracks> tracks);
void ScheduleEvent(base::Token event_name);
+ void ScheduleAndMaybeDispatchImmediately(base::Token event_name);
bool PrepareAppend(size_t new_data_size,
script::ExceptionState* exception_state);
- bool EvictCodedFrames(size_t new_data_size);
void AppendBufferInternal(const unsigned char* data, size_t size,
script::ExceptionState* exception_state);
- void OnAppendTimer();
- void AppendError();
- void OnRemoveTimer();
-
- void CancelRemove();
- void AbortIfUpdating();
-
- void RemoveMediaTracks();
+ void OnAlgorithmFinalized();
+ void UpdateTimestampOffset(base::TimeDelta timestamp_offset_);
const TrackDefault* GetTrackDefault(
const std::string& track_type,
@@ -167,30 +163,32 @@
const std::string& byte_stream_track_id) const;
const std::string id_;
+ const bool asynchronous_reduction_enabled_;
const size_t evict_extra_in_bytes_;
- ChunkDemuxer* chunk_demuxer_;
+
MediaSource* media_source_;
+ ChunkDemuxer* chunk_demuxer_;
+ scoped_refptr<base::SingleThreadTaskRunner> web_task_runner_ =
+ base::MessageLoop::current()->task_runner();
scoped_refptr<TrackDefaultList> track_defaults_ = new TrackDefaultList(NULL);
EventQueue* event_queue_;
- SourceBufferAppendMode mode_ = kSourceBufferAppendModeSegments;
- bool updating_ = false;
- double timestamp_offset_ = 0;
+ bool first_initialization_segment_received_ = false;
scoped_refptr<AudioTrackList> audio_tracks_;
scoped_refptr<VideoTrackList> video_tracks_;
+
+ SourceBufferAppendMode mode_ = kSourceBufferAppendModeSegments;
+
+ starboard::Mutex timestamp_offset_mutex_;
+ double timestamp_offset_ = 0;
+
+ scoped_refptr<SerializedAlgorithmRunner::Handle<SourceBufferAlgorithm>>
+ active_algorithm_handle_;
double append_window_start_ = 0;
double append_window_end_ = std::numeric_limits<double>::infinity();
- base::OneShotTimer append_timer_;
- bool first_initialization_segment_received_ = false;
std::unique_ptr<uint8_t[]> pending_append_data_;
size_t pending_append_data_capacity_ = 0;
- size_t pending_append_data_size_ = 0;
- size_t pending_append_data_offset_ = 0;
-
- base::OneShotTimer remove_timer_;
- double pending_remove_start_ = -1;
- double pending_remove_end_ = -1;
SourceBufferMetrics metrics_;
};
diff --git a/cobalt/dom/source_buffer_algorithm.cc b/cobalt/dom/source_buffer_algorithm.cc
new file mode 100644
index 0000000..50eec01
--- /dev/null
+++ b/cobalt/dom/source_buffer_algorithm.cc
@@ -0,0 +1,152 @@
+// 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.
+
+#include "cobalt/dom/source_buffer_algorithm.h"
+
+#include <algorithm>
+#include <utility>
+
+#include "base/logging.h"
+#include "base/trace_event/trace_event.h"
+#include "cobalt/dom/media_source.h"
+
+namespace cobalt {
+namespace dom {
+
+SourceBufferAppendAlgorithm::SourceBufferAppendAlgorithm(
+ MediaSource* media_source, ::media::ChunkDemuxer* chunk_demuxer,
+ const std::string& id, const uint8_t* buffer, size_t size_in_bytes,
+ base::TimeDelta append_window_start, base::TimeDelta append_window_end,
+ base::TimeDelta timestamp_offset,
+ UpdateTimestampOffsetCB&& update_timestamp_offset_cb,
+ ScheduleEventCB&& schedule_event_cb, base::OnceClosure&& finalized_cb,
+ SourceBufferMetrics* metrics)
+ : media_source_(media_source),
+ chunk_demuxer_(chunk_demuxer),
+ id_(id),
+ buffer_(buffer),
+ bytes_remaining_(size_in_bytes),
+ append_window_start_(append_window_start),
+ append_window_end_(append_window_end),
+ timestamp_offset_(timestamp_offset),
+ update_timestamp_offset_cb_(std::move(update_timestamp_offset_cb)),
+ schedule_event_cb_(std::move(schedule_event_cb)),
+ finalized_cb_(std::move(finalized_cb)),
+ metrics_(metrics) {
+ DCHECK(media_source_);
+ DCHECK(chunk_demuxer_);
+ if (bytes_remaining_ > 0) {
+ DCHECK(buffer);
+ }
+ DCHECK(update_timestamp_offset_cb_);
+ DCHECK(schedule_event_cb_);
+ DCHECK(metrics_);
+ TRACE_EVENT1("cobalt::dom", "SourceBufferAppendAlgorithm ctor",
+ "bytes_remaining", bytes_remaining_);
+}
+
+void SourceBufferAppendAlgorithm::Process(bool* finished) {
+ DCHECK(finished);
+ DCHECK(!*finished);
+
+ const size_t kMaxAppendSize = 128 * 1024;
+
+ size_t append_size = std::min(bytes_remaining_, kMaxAppendSize);
+
+ TRACE_EVENT1("cobalt::dom", "SourceBufferAppendAlgorithm::Process()",
+ "append_size", append_size);
+
+ metrics_->StartTracking();
+ succeeded_ = chunk_demuxer_->AppendData(
+ id_, buffer_, append_size, append_window_start_, append_window_end_,
+ ×tamp_offset_);
+ update_timestamp_offset_cb_.Run(timestamp_offset_);
+ metrics_->EndTracking(succeeded_ ? append_size : 0);
+
+ if (succeeded_) {
+ buffer_ += append_size;
+ bytes_remaining_ -= append_size;
+
+ if (bytes_remaining_ == 0) {
+ *finished = true;
+ return;
+ }
+
+ return;
+ }
+
+ chunk_demuxer_->ResetParserState(id_, append_window_start_,
+ append_window_end_, ×tamp_offset_);
+ update_timestamp_offset_cb_.Run(timestamp_offset_);
+ *finished = true;
+}
+
+void SourceBufferAppendAlgorithm::Abort() {
+ TRACE_EVENT0("cobalt::dom", "SourceBufferAppendAlgorithm::Abort()");
+ schedule_event_cb_.Run(base::Tokens::abort());
+ schedule_event_cb_.Run(base::Tokens::updateend());
+}
+
+void SourceBufferAppendAlgorithm::Finalize() {
+ TRACE_EVENT1("cobalt::dom", "SourceBufferAppendAlgorithm::Finalize()",
+ "succeeded", succeeded_);
+ if (succeeded_) {
+ schedule_event_cb_.Run(base::Tokens::update());
+ schedule_event_cb_.Run(base::Tokens::updateend());
+ } else {
+ schedule_event_cb_.Run(base::Tokens::error());
+ schedule_event_cb_.Run(base::Tokens::updateend());
+ media_source_->EndOfStreamAlgorithm(kMediaSourceEndOfStreamErrorDecode);
+ }
+
+ std::move(finalized_cb_).Run();
+}
+
+SourceBufferRemoveAlgorithm::SourceBufferRemoveAlgorithm(
+ ::media::ChunkDemuxer* chunk_demuxer, const std::string& id,
+ base::TimeDelta pending_remove_start, base::TimeDelta pending_remove_end,
+ ScheduleEventCB&& schedule_event_cb, base::OnceClosure&& finalized_cb)
+ : chunk_demuxer_(chunk_demuxer),
+ id_(id),
+ pending_remove_start_(pending_remove_start),
+ pending_remove_end_(pending_remove_end),
+ schedule_event_cb_(std::move(schedule_event_cb)),
+ finalized_cb_(std::move(finalized_cb)) {
+ TRACE_EVENT0("cobalt::dom", "SourceBufferRemoveAlgorithm ctor");
+ DCHECK(chunk_demuxer_);
+ DCHECK(schedule_event_cb_);
+}
+
+void SourceBufferRemoveAlgorithm::Process(bool* finished) {
+ TRACE_EVENT0("cobalt::dom", "SourceBufferRemoveAlgorithm::Process()");
+ chunk_demuxer_->Remove(id_, pending_remove_start_, pending_remove_end_);
+ *finished = true;
+}
+
+void SourceBufferRemoveAlgorithm::Abort() {
+ TRACE_EVENT0("cobalt::dom", "SourceBufferRemoveAlgorithm::Abort()");
+ // SourceBufferRemoveAlgorithm cannot be cancelled explicitly by the web app.
+ // This function will only be called when the SourceBuffer is being removed
+ // from the MediaSource and no events should be fired.
+}
+
+void SourceBufferRemoveAlgorithm::Finalize() {
+ TRACE_EVENT0("cobalt::dom", "SourceBufferRemoveAlgorithm::Finalize()");
+ schedule_event_cb_.Run(base::Tokens::update());
+ schedule_event_cb_.Run(base::Tokens::updateend());
+ std::move(finalized_cb_).Run();
+}
+
+} // namespace dom
+} // namespace cobalt
diff --git a/cobalt/dom/source_buffer_algorithm.h b/cobalt/dom/source_buffer_algorithm.h
new file mode 100644
index 0000000..d9e0f16
--- /dev/null
+++ b/cobalt/dom/source_buffer_algorithm.h
@@ -0,0 +1,119 @@
+// 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.
+
+#ifndef COBALT_DOM_SOURCE_BUFFER_ALGORITHM_H_
+#define COBALT_DOM_SOURCE_BUFFER_ALGORITHM_H_
+
+#include <string>
+
+#include "base/callback.h"
+#include "base/time/time.h"
+#include "cobalt/base/tokens.h"
+#include "cobalt/dom/source_buffer_metrics.h"
+#include "third_party/chromium/media/filters/chunk_demuxer.h"
+
+namespace cobalt {
+namespace dom {
+
+class MediaSource; // Necessary to avoid circular inclusion.
+
+// Base class of all SourceBuffer algorithms. Its user should call `Process()`
+// multiple times until |finished| is set to true on return, and then call
+// `Finalize()` exactly once. `Abort()` can be called at any time to abort any
+// processing.
+class SourceBufferAlgorithm {
+ public:
+ typedef base::RepeatingCallback<void(base::TimeDelta)>
+ UpdateTimestampOffsetCB;
+ typedef base::RepeatingCallback<void(base::Token)> ScheduleEventCB;
+
+ virtual ~SourceBufferAlgorithm() {}
+
+ // Returns false to indicate that the algorithm cannot be explicitly aborted
+ // by calling `Abort()` on the Handle. The algorithm may still be aborted
+ // when the SourceBuffer is being removed from the MediaSource.
+ virtual bool SupportExplicitAbort() = 0;
+
+ virtual void Process(bool* finished) = 0;
+ virtual void Abort() = 0;
+ virtual void Finalize() = 0;
+};
+
+// Implements the steps 12 to 18 of SourceBuffer stream append loop algorithm as
+// specified at
+// https://www.w3.org/TR/2016/CR-media-source-20160705/#sourcebuffer-stream-append-loop.
+class SourceBufferAppendAlgorithm : public SourceBufferAlgorithm {
+ public:
+ SourceBufferAppendAlgorithm(
+ MediaSource* media_source, ::media::ChunkDemuxer* chunk_demuxer,
+ const std::string& id, const uint8_t* buffer, size_t size_in_bytes,
+ base::TimeDelta append_window_start, base::TimeDelta append_window_end,
+ base::TimeDelta timestamp_offset,
+ UpdateTimestampOffsetCB&& update_timestamp_offset_cb,
+ ScheduleEventCB&& schedule_event_cb, base::OnceClosure&& finalized_cb,
+ SourceBufferMetrics* metrics);
+
+ private:
+ bool SupportExplicitAbort() override { return true; }
+ void Process(bool* finished) override;
+ void Abort() override;
+ void Finalize() override;
+
+ MediaSource* const media_source_;
+ ::media::ChunkDemuxer* const chunk_demuxer_;
+ const std::string id_;
+ const uint8_t* buffer_;
+ size_t bytes_remaining_;
+ const base::TimeDelta append_window_start_;
+ const base::TimeDelta append_window_end_;
+
+ base::TimeDelta timestamp_offset_;
+ const UpdateTimestampOffsetCB update_timestamp_offset_cb_;
+ const ScheduleEventCB schedule_event_cb_;
+ base::OnceClosure finalized_cb_;
+ SourceBufferMetrics* const metrics_;
+
+ bool succeeded_ = false;
+};
+
+// Implements the steps 6 to 9 of SourceBuffer range removal algorithm as
+// specified at
+// https://www.w3.org/TR/2016/CR-media-source-20160705/#sourcebuffer-range-removal.
+class SourceBufferRemoveAlgorithm : public SourceBufferAlgorithm {
+ public:
+ SourceBufferRemoveAlgorithm(::media::ChunkDemuxer* chunk_demuxer,
+ const std::string& id,
+ base::TimeDelta pending_remove_start,
+ base::TimeDelta pending_remove_end,
+ ScheduleEventCB&& schedule_event_cb,
+ base::OnceClosure&& finalized_cb);
+
+ private:
+ bool SupportExplicitAbort() override { return false; }
+ void Process(bool* finished) override;
+ void Abort() override;
+ void Finalize() override;
+
+ ::media::ChunkDemuxer* const chunk_demuxer_;
+ const std::string id_;
+ const base::TimeDelta pending_remove_start_;
+ const base::TimeDelta pending_remove_end_;
+ const ScheduleEventCB schedule_event_cb_;
+ base::OnceClosure finalized_cb_;
+};
+
+} // namespace dom
+} // namespace cobalt
+
+#endif // COBALT_DOM_SOURCE_BUFFER_ALGORITHM_H_
diff --git a/cobalt/dom/testing/BUILD.gn b/cobalt/dom/testing/BUILD.gn
index 49453ae..846388b 100644
--- a/cobalt/dom/testing/BUILD.gn
+++ b/cobalt/dom/testing/BUILD.gn
@@ -17,6 +17,7 @@
has_pedantic_warnings = true
sources = [
+ "fake_document.h",
"html_collection_testing.h",
"mock_layout_boxes.h",
"stub_css_parser.cc",
diff --git a/cobalt/dom/testing/fake_document.h b/cobalt/dom/testing/fake_document.h
new file mode 100644
index 0000000..3ab3d94
--- /dev/null
+++ b/cobalt/dom/testing/fake_document.h
@@ -0,0 +1,70 @@
+// 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.
+
+#ifndef COBALT_DOM_TESTING_FAKE_DOCUMENT_H_
+#define COBALT_DOM_TESTING_FAKE_DOCUMENT_H_
+
+#include <memory>
+#include <utility>
+
+#include "cobalt/dom/document.h"
+
+#include "cobalt/web/csp_delegate_factory.h"
+
+namespace cobalt {
+namespace dom {
+namespace testing {
+
+class FakeDocument : public dom::Document {
+ public:
+ explicit FakeDocument(dom::HTMLElementContext* html_element_context)
+ : dom::Document(html_element_context) {
+ web::WindowOrWorkerGlobalScope::Options options(
+ base::ApplicationState::kApplicationStateStarted);
+ std::unique_ptr<web::CspViolationReporter> violation_reporter(
+ new web::CspViolationReporter(nullptr, options.post_sender));
+ csp_delegate_ = web::CspDelegateFactory::GetInstance()->Create(
+ options.csp_enforcement_mode, std::move(violation_reporter),
+ environment_settings()->creation_url(), options.require_csp,
+ options.csp_policy_changed_callback,
+ options.csp_insecure_allowed_token);
+ }
+
+ FakeDocument(dom::HTMLElementContext* html_element_context,
+ dom::Document::Options doc_options)
+ : dom::Document(html_element_context, doc_options) {
+ web::WindowOrWorkerGlobalScope::Options options(
+ base::ApplicationState::kApplicationStateStarted);
+ std::unique_ptr<web::CspViolationReporter> violation_reporter(
+ new web::CspViolationReporter(nullptr, options.post_sender));
+ csp_delegate_ = web::CspDelegateFactory::GetInstance()->Create(
+ options.csp_enforcement_mode, std::move(violation_reporter),
+ environment_settings()->creation_url(), options.require_csp,
+ options.csp_policy_changed_callback,
+ options.csp_insecure_allowed_token);
+ }
+
+ web::CspDelegate* csp_delegate() const override {
+ return csp_delegate_.get();
+ }
+
+ private:
+ std::unique_ptr<web::CspDelegate> csp_delegate_;
+};
+
+} // namespace testing
+} // namespace dom
+} // namespace cobalt
+
+#endif // COBALT_DOM_TESTING_FAKE_DOCUMENT_H_
diff --git a/cobalt/dom/testing/stub_environment_settings.h b/cobalt/dom/testing/stub_environment_settings.h
index 01d01f3..a70eef3 100644
--- a/cobalt/dom/testing/stub_environment_settings.h
+++ b/cobalt/dom/testing/stub_environment_settings.h
@@ -26,7 +26,7 @@
public:
explicit StubEnvironmentSettings(const Options& options = Options())
: DOMSettings(null_debugger_hooks_, 0, nullptr, nullptr, nullptr, nullptr,
- options) {}
+ nullptr, options) {}
~StubEnvironmentSettings() override {}
private:
diff --git a/cobalt/dom/testing/test_with_javascript.h b/cobalt/dom/testing/test_with_javascript.h
index 58df232..30204af 100644
--- a/cobalt/dom/testing/test_with_javascript.h
+++ b/cobalt/dom/testing/test_with_javascript.h
@@ -50,15 +50,16 @@
Window* window() { return stub_window_->window().get(); }
bool EvaluateScript(const std::string& js_code, std::string* result) {
- DCHECK(global_environment());
- scoped_refptr<script::SourceCode> source_code =
- script::SourceCode::CreateSourceCode(
- js_code, base::SourceLocation(__FILE__, __LINE__, 1));
+ return global_environment()->EvaluateScript(
+ CreateSourceCodeAndPrepareEval(js_code), result);
+ }
- global_environment()->EnableEval();
- global_environment()->SetReportEvalCallback(base::Closure());
- bool succeeded = global_environment()->EvaluateScript(source_code, result);
- return succeeded;
+ bool EvaluateScript(
+ const std::string& js_code,
+ const scoped_refptr<script::Wrappable>& owning_object,
+ base::Optional<script::ValueHandleHolder::Reference>* result = NULL) {
+ return global_environment()->EvaluateScript(
+ CreateSourceCodeAndPrepareEval(js_code), owning_object, result);
}
::testing::StrictMock<script::testing::MockExceptionState>*
@@ -73,6 +74,15 @@
base::EventDispatcher* event_dispatcher() { return &event_dispatcher_; }
private:
+ scoped_refptr<script::SourceCode> CreateSourceCodeAndPrepareEval(
+ const std::string& js_code) {
+ DCHECK(global_environment());
+ global_environment()->EnableEval();
+ global_environment()->SetReportEvalCallback(base::Closure());
+ return script::SourceCode::CreateSourceCode(
+ js_code, base::SourceLocation(__FILE__, __LINE__, 1));
+ }
+
std::unique_ptr<StubWindow> stub_window_;
::testing::StrictMock<script::testing::MockExceptionState> exception_state_;
base::EventDispatcher event_dispatcher_;
diff --git a/cobalt/dom/user_agent_data_test.cc b/cobalt/dom/user_agent_data_test.cc
index dc3c350..376fcda 100644
--- a/cobalt/dom/user_agent_data_test.cc
+++ b/cobalt/dom/user_agent_data_test.cc
@@ -40,7 +40,6 @@
// Inject H5vcc interface to make it also accessible via Window
h5vcc::H5vcc::Settings h5vcc_settings;
- h5vcc_settings.media_module = NULL;
h5vcc_settings.network_module = NULL;
#if SB_IS(EVERGREEN)
h5vcc_settings.updater_module = NULL;
diff --git a/cobalt/dom/window.cc b/cobalt/dom/window.cc
index 89178fe..aca75dc 100644
--- a/cobalt/dom/window.cc
+++ b/cobalt/dom/window.cc
@@ -129,8 +129,12 @@
bool log_tts)
// 'window' object EventTargets require special handling for onerror events,
// see EventTarget constructor for more details.
- : web::WindowOrWorkerGlobalScope(settings, dom_stat_tracker,
- initial_application_state),
+ : web::WindowOrWorkerGlobalScope(
+ settings, dom_stat_tracker,
+ web::WindowOrWorkerGlobalScope::Options(
+ initial_application_state, post_sender, require_csp,
+ csp_enforcement_mode, csp_policy_changed_callback,
+ csp_insecure_allowed_token)),
viewport_size_(view_size),
is_resize_event_pending_(false),
is_reporting_script_error_(false),
@@ -155,9 +159,7 @@
base::Bind(&Window::FireHashChangeEvent, base::Unretained(this)),
performance_->timing()->GetNavigationStartClock(),
navigation_callback, ParseUserAgentStyleSheet(css_parser),
- view_size, cookie_jar, post_sender, require_csp,
- csp_enforcement_mode, csp_policy_changed_callback,
- csp_insecure_allowed_token, dom_max_element_depth)))),
+ view_size, cookie_jar, dom_max_element_depth)))),
document_loader_(nullptr),
history_(new History()),
navigator_(new Navigator(environment_settings(), captions)),
@@ -172,7 +174,6 @@
ALLOW_THIS_IN_INITIALIZER_LIST(
session_storage_(new Storage(this, Storage::kSessionStorage, NULL))),
screen_(new Screen(view_size)),
- preflight_cache_(new loader::CORSPreflightCache()),
ran_animation_frame_callbacks_callback_(
ran_animation_frame_callbacks_callback),
window_close_callback_(window_close_callback),
diff --git a/cobalt/dom/window.h b/cobalt/dom/window.h
index 6485969..033ac82 100644
--- a/cobalt/dom/window.h
+++ b/cobalt/dom/window.h
@@ -45,7 +45,6 @@
#include "cobalt/dom/test_runner.h"
#endif // ENABLE_TEST_RUNNER
#include "cobalt/input/camera_3d.h"
-#include "cobalt/loader/cors_preflight_cache.h"
#include "cobalt/loader/decoder.h"
#include "cobalt/loader/fetcher_factory.h"
#include "cobalt/loader/font/remote_typeface_cache.h"
@@ -361,10 +360,6 @@
void CacheSplashScreen(const std::string& content,
const base::Optional<std::string>& topic);
- const scoped_refptr<loader::CORSPreflightCache> get_preflight_cache() {
- return preflight_cache_;
- }
-
// Custom on screen keyboard.
const scoped_refptr<OnScreenKeyboard>& on_screen_keyboard() const;
void ReleaseOnScreenKeyboard();
@@ -443,9 +438,6 @@
scoped_refptr<Screen> screen_;
- // Global preflight cache.
- scoped_refptr<loader::CORSPreflightCache> preflight_cache_;
-
const base::Closure ran_animation_frame_callbacks_callback_;
const CloseCallback window_close_callback_;
const base::Closure window_minimize_callback_;
diff --git a/cobalt/h5vcc/BUILD.gn b/cobalt/h5vcc/BUILD.gn
index 9c5a145..fd7216f 100644
--- a/cobalt/h5vcc/BUILD.gn
+++ b/cobalt/h5vcc/BUILD.gn
@@ -79,7 +79,6 @@
"//cobalt/cache",
"//cobalt/configuration",
"//cobalt/dom",
- "//cobalt/media",
"//cobalt/network",
"//cobalt/persistent_storage:persistent_settings",
"//cobalt/script",
diff --git a/cobalt/h5vcc/h5vcc.cc b/cobalt/h5vcc/h5vcc.cc
index d3b8198..806f7a1 100644
--- a/cobalt/h5vcc/h5vcc.cc
+++ b/cobalt/h5vcc/h5vcc.cc
@@ -27,12 +27,12 @@
c_val_ = new dom::CValView();
crash_log_ = new H5vccCrashLog();
runtime_ = new H5vccRuntime(settings.event_dispatcher);
- settings_ =
- new H5vccSettings(settings.media_module, settings.network_module,
+ settings_ = new H5vccSettings(
+ settings.set_media_source_setting_func, settings.network_module,
#if SB_IS(EVERGREEN)
- settings.updater_module,
+ settings.updater_module,
#endif
- settings.user_agent_data, settings.global_environment);
+ settings.user_agent_data, settings.global_environment);
#if defined(COBALT_ENABLE_SSO)
sso_ = new H5vccSso();
#endif
diff --git a/cobalt/h5vcc/h5vcc.h b/cobalt/h5vcc/h5vcc.h
index c74b9e6..0dce20d 100644
--- a/cobalt/h5vcc/h5vcc.h
+++ b/cobalt/h5vcc/h5vcc.h
@@ -17,6 +17,7 @@
#include <string>
+#include "base/callback.h"
#include "cobalt/base/event_dispatcher.h"
#include "cobalt/dom/c_val_view.h"
#include "cobalt/dom/mutation_observer_task_manager.h"
@@ -45,8 +46,7 @@
public:
struct Settings {
Settings()
- : media_module(NULL),
- network_module(NULL),
+ : network_module(NULL),
#if SB_IS(EVERGREEN)
updater_module(NULL),
#endif
@@ -55,7 +55,7 @@
user_agent_data(NULL),
global_environment(NULL) {
}
- media::MediaModule* media_module;
+ H5vccSettings::SetMediaSourceSettingFunc set_media_source_setting_func;
network::NetworkModule* network_module;
#if SB_IS(EVERGREEN)
updater::UpdaterModule* updater_module;
diff --git a/cobalt/h5vcc/h5vcc_crash_log.cc b/cobalt/h5vcc/h5vcc_crash_log.cc
index 7a502b4..564feda 100644
--- a/cobalt/h5vcc/h5vcc_crash_log.cc
+++ b/cobalt/h5vcc/h5vcc_crash_log.cc
@@ -161,8 +161,8 @@
default:
replace = watchdog::NONE;
}
- return watchdog->Register(name, description, monitor_state, time_interval,
- time_wait, replace);
+ return watchdog->Register(name, description, monitor_state,
+ time_interval * 1000, time_wait * 1000, replace);
}
return false;
}
diff --git a/cobalt/h5vcc/h5vcc_crash_log.idl b/cobalt/h5vcc/h5vcc_crash_log.idl
index 45f6df3..2bbf4df 100644
--- a/cobalt/h5vcc/h5vcc_crash_log.idl
+++ b/cobalt/h5vcc/h5vcc_crash_log.idl
@@ -34,9 +34,9 @@
// description, information on the Watchdog client.
// watchdog_state, application state to continue monitoring client up to.
// Inclusive.
- // time_interval, maximum number of microseconds allowed between pings
- // before triggering a Watchdog violation. Min value of 1000000.
- // time_wait, number of microseconds to initially wait before Watchdog
+ // time_interval, maximum number of milliseconds allowed between pings
+ // before triggering a Watchdog violation. Min value of 1000.
+ // time_wait, number of milliseconds to initially wait before Watchdog
// violations can be triggered. Reapplies after client resumes from idle
// state due to application state changes.
// watchdog_replace, behavior with previously registered Watchdog clients
@@ -51,12 +51,13 @@
// Returns true if Watchdog client was pinged. Name determines the Watchdog
// client to ping with ping_info which can either be empty or contain relevant
- // metadata. ping_info has a max length of 1024.
+ // metadata. ping_info has a max length of 128.
boolean ping(DOMString name, DOMString ping_info);
// Returns a json string containing the Watchdog violations since the last
- // call. Clears internal cache of Watchdog violations to prevent duplicates.
- // Timestamps are stored as strings due to int size constraints.
+ // call, up to the 200 most recent. Clears internal cache of Watchdog
+ // violations to prevent duplicates. Timestamps are stored as strings due to
+ // int size constraints.
// Example json:
// {
// "test-name":{
@@ -67,18 +68,18 @@
// "pingInfos":[
// {
// "info":"test-ping",
- // "timestampMicroseconds":"1658972623547006"
+ // "timestampMilliseconds":"1658972623547"
// }
// ],
// "registeredClients":[
// "test-name"
// ],
- // "timeIntervalMicroseconds":"5000000",
- // "timeWaitMicroseconds":"0",
- // "timestampLastPingedMicroseconds":"1658972623547006",
- // "timestampRegisteredMicroseconds":"1658972621890834",
- // "timestampViolationMicroseconds":"1658972629489771",
- // "violationDurationMicroseconds":"942764"
+ // "timeIntervalMilliseconds":"5000",
+ // "timeWaitMilliseconds":"0",
+ // "timestampLastPingedMilliseconds":"1658972623547",
+ // "timestampRegisteredMilliseconds":"1658972621890",
+ // "timestampViolationMilliseconds":"1658972629489",
+ // "violationDurationMilliseconds":"942"
// }
// ]
// }
diff --git a/cobalt/h5vcc/h5vcc_settings.cc b/cobalt/h5vcc/h5vcc_settings.cc
index 3417192..1735270 100644
--- a/cobalt/h5vcc/h5vcc_settings.cc
+++ b/cobalt/h5vcc/h5vcc_settings.cc
@@ -19,14 +19,15 @@
namespace cobalt {
namespace h5vcc {
-H5vccSettings::H5vccSettings(media::MediaModule* media_module,
- cobalt::network::NetworkModule* network_module,
+H5vccSettings::H5vccSettings(
+ const SetMediaSourceSettingFunc& set_media_source_setting_func,
+ cobalt::network::NetworkModule* network_module,
#if SB_IS(EVERGREEN)
- cobalt::updater::UpdaterModule* updater_module,
+ cobalt::updater::UpdaterModule* updater_module,
#endif
- web::NavigatorUAData* user_agent_data,
- script::GlobalEnvironment* global_environment)
- : media_module_(media_module),
+ web::NavigatorUAData* user_agent_data,
+ script::GlobalEnvironment* global_environment)
+ : set_media_source_setting_func_(set_media_source_setting_func),
network_module_(network_module),
#if SB_IS(EVERGREEN)
updater_module_(updater_module),
@@ -36,7 +37,6 @@
}
bool H5vccSettings::Set(const std::string& name, int32 value) const {
- const char kMediaPrefix[] = "Media.";
const char kNavigatorUAData[] = "NavigatorUAData";
const char kQUIC[] = "QUIC";
@@ -44,8 +44,9 @@
const char kUpdaterMinFreeSpaceBytes[] = "Updater.MinFreeSpaceBytes";
#endif
- if (name.compare(kMediaPrefix) == 0) {
- return media_module_ ? media_module_->SetConfiguration(name, value) : false;
+ if (set_media_source_setting_func_ &&
+ set_media_source_setting_func_.Run(name, value)) {
+ return true;
}
if (name.compare(kNavigatorUAData) == 0 && value == 1) {
diff --git a/cobalt/h5vcc/h5vcc_settings.h b/cobalt/h5vcc/h5vcc_settings.h
index 2257d6b..a73e59f 100644
--- a/cobalt/h5vcc/h5vcc_settings.h
+++ b/cobalt/h5vcc/h5vcc_settings.h
@@ -17,7 +17,6 @@
#include <string>
-#include "cobalt/media/media_module.h"
#include "cobalt/network/network_module.h"
#include "cobalt/script/global_environment.h"
#include "cobalt/script/wrappable.h"
@@ -35,13 +34,16 @@
// version to avoid being abused.
class H5vccSettings : public script::Wrappable {
public:
- explicit H5vccSettings(media::MediaModule* media_module,
- cobalt::network::NetworkModule* network_module,
+ typedef base::Callback<bool(const std::string& name, int value)>
+ SetMediaSourceSettingFunc;
+
+ H5vccSettings(const SetMediaSourceSettingFunc& set_media_source_setting_func,
+ cobalt::network::NetworkModule* network_module,
#if SB_IS(EVERGREEN)
- cobalt::updater::UpdaterModule* updater_module,
+ cobalt::updater::UpdaterModule* updater_module,
#endif
- web::NavigatorUAData* user_agent_data,
- script::GlobalEnvironment* global_environment);
+ web::NavigatorUAData* user_agent_data,
+ script::GlobalEnvironment* global_environment);
// Returns true when the setting is set successfully or if the setting has
// already been set to the expected value. Returns false when the setting is
@@ -51,7 +53,7 @@
DEFINE_WRAPPABLE_TYPE(H5vccSettings);
private:
- media::MediaModule* media_module_;
+ const SetMediaSourceSettingFunc set_media_source_setting_func_;
cobalt::network::NetworkModule* network_module_ = nullptr;
#if SB_IS(EVERGREEN)
cobalt::updater::UpdaterModule* updater_module_ = nullptr;
diff --git a/cobalt/h5vcc/h5vcc_storage.cc b/cobalt/h5vcc/h5vcc_storage.cc
index b5c3af0..d734a0e 100644
--- a/cobalt/h5vcc/h5vcc_storage.cc
+++ b/cobalt/h5vcc/h5vcc_storage.cc
@@ -248,12 +248,14 @@
quota.image() + quota.font() + quota.splash() +
quota.uncompiled_js() + quota.compiled_js();
- // TODO(b/235529738): Calculate correct max_quota_size that subtracts
- // non-cache memory used in the kSbSystemPathCacheDirectory.
uint32_t max_quota_size = 24 * 1024 * 1024;
#if SB_API_VERSION >= 14
max_quota_size = kSbMaxSystemPathCacheDirectorySize;
#endif
+ // Assume the non-http-cache memory in kSbSystemPathCacheDirectory
+ // is less than 1 mb and subtract this from the max_quota_size.
+ max_quota_size -= (1 << 20);
+
if (quota_total != max_quota_size) {
return SetQuotaResponse(starboard::FormatString(
"H5vccStorageResourceTypeQuotaDictionary input parameter field values "
@@ -311,12 +313,13 @@
->GetMaxCacheStorageInBytes(disk_cache::kCompiledScript)
.value());
- // TODO(b/235529738): Calculate correct max_quota_size that subtracts
- // non-cache memory used in the kSbSystemPathCacheDirectory.
uint32_t max_quota_size = 24 * 1024 * 1024;
#if SB_API_VERSION >= 14
max_quota_size = kSbMaxSystemPathCacheDirectorySize;
#endif
+ // Assume the non-http-cache memory in kSbSystemPathCacheDirectory
+ // is less than 1 mb and subtract this from the max_quota_size.
+ max_quota_size -= (1 << 20);
quota.set_total(max_quota_size);
diff --git a/cobalt/h5vcc/h5vcc_system.h b/cobalt/h5vcc/h5vcc_system.h
index 6af4279..5b5d086 100644
--- a/cobalt/h5vcc/h5vcc_system.h
+++ b/cobalt/h5vcc/h5vcc_system.h
@@ -21,7 +21,6 @@
#if SB_IS(EVERGREEN)
#include "cobalt/h5vcc/h5vcc_updater.h"
#endif
-#include "cobalt/media/media_module.h"
#include "cobalt/script/wrappable.h"
namespace cobalt {
diff --git a/cobalt/layout_tests/testdata/web-platform-tests/WebCryptoAPI/web_platform_tests.txt b/cobalt/layout_tests/testdata/web-platform-tests/WebCryptoAPI/web_platform_tests.txt
index 3e1afd6..287a65d 100644
--- a/cobalt/layout_tests/testdata/web-platform-tests/WebCryptoAPI/web_platform_tests.txt
+++ b/cobalt/layout_tests/testdata/web-platform-tests/WebCryptoAPI/web_platform_tests.txt
@@ -1,6 +1,7 @@
# WebCrypto API tests.
#
# Only HMAC signing is supported
+sign_verify/hmac.https.worker.html,PASS
sign_verify/test_rsa_pkcs.https.html,DISABLE
sign_verify/test_hmac.https.html,PASS
sign_verify/test_rsa_pss.https.html,DISABLE
diff --git a/cobalt/media/base/sbplayer_pipeline.cc b/cobalt/media/base/sbplayer_pipeline.cc
index 79e9a6a..dc3a212 100644
--- a/cobalt/media/base/sbplayer_pipeline.cc
+++ b/cobalt/media/base/sbplayer_pipeline.cc
@@ -1255,11 +1255,9 @@
SbTime time_ahead_of_playback =
timestamp_of_last_written_audio_ - last_media_time_;
if (time_ahead_of_playback > (kAudioLimit + kMediaTimeCheckInterval)) {
- SbTime delay_time = (time_ahead_of_playback - kAudioLimit) /
- std::max(playback_rate_.value(), 1.0f);
task_runner_->PostDelayedTask(
FROM_HERE, base::Bind(&SbPlayerPipeline::DelayedNeedData, this),
- base::TimeDelta::FromMicroseconds(delay_time));
+ base::TimeDelta::FromMicroseconds(kMediaTimeCheckInterval));
audio_read_delayed_ = true;
return;
}
diff --git a/cobalt/media/base/starboard_player.cc b/cobalt/media/base/starboard_player.cc
index 7c5eb1d..ae7defd 100644
--- a/cobalt/media/base/starboard_player.cc
+++ b/cobalt/media/base/starboard_player.cc
@@ -37,7 +37,7 @@
namespace {
-base::Statistics<SbTime, int, 1024> s_player_presenting_delays_;
+base::Statistics<SbTime, int, 1024> s_startup_latency;
} // namespace
@@ -983,7 +983,6 @@
if (set_drm_system_ready_cb_time_ == -1) {
first_events_str =
starboard::FormatString("%-40s0 us", "SbPlayerCreate() called");
-
} else if (set_drm_system_ready_cb_time_ < player_creation_time_) {
first_events_str = starboard::FormatString(
"%-40s0 us\n%-40s%" PRId64 " us", "set_drm_system_ready_cb called",
@@ -996,9 +995,10 @@
set_drm_system_ready_cb_time_ - player_creation_time_);
}
- SbTime player_initialization_time_delta =
- sb_player_state_initialized_time_ -
+ SbTime first_event_time =
std::max(player_creation_time_, set_drm_system_ready_cb_time_);
+ SbTime player_initialization_time_delta =
+ sb_player_state_initialized_time_ - first_event_time;
SbTime player_preroll_time_delta =
sb_player_state_prerolling_time_ - sb_player_state_initialized_time_;
SbTime first_audio_sample_time_delta = std::max(
@@ -1008,27 +1008,29 @@
SbTime player_presenting_time_delta =
sb_player_state_presenting_time_ -
std::max(first_audio_sample_time_, first_video_sample_time_);
+ SbTime startup_latency = sb_player_state_presenting_time_ - first_event_time;
- s_player_presenting_delays_.AddSample(player_presenting_time_delta, 1);
+ s_startup_latency.AddSample(startup_latency, 1);
// clang-format off
LOG(INFO) << starboard::FormatString(
- "\nSbPlayer startup latencies\n"
+ "\nSbPlayer startup latencies: %" PRId64 " us\n"
" Event name time since last event\n"
" %s\n" // |first_events_str| populated above
" kSbPlayerStateInitialized received %" PRId64 " us\n"
" kSbPlayerStatePrerolling received %" PRId64 " us\n"
" First media sample(s) written [a/v] %" PRId64 "/%" PRId64 " us\n"
" kSbPlayerStatePresenting received %" PRId64 " us\n"
- " kSbPlayerStatePresenting delay statistics (us):\n"
+ " Startup latency statistics (us):\n"
" min: %" PRId64 ", median: %" PRId64 ", average: %" PRId64
", max: %" PRId64,
+ startup_latency,
first_events_str.c_str(), player_initialization_time_delta,
player_preroll_time_delta, first_audio_sample_time_delta,
first_video_sample_time_delta, player_presenting_time_delta,
- s_player_presenting_delays_.min(),
- s_player_presenting_delays_.GetMedian(),
- s_player_presenting_delays_.average(), s_player_presenting_delays_.max());
+ s_startup_latency.min(),
+ s_startup_latency.GetMedian(),
+ s_startup_latency.average(), s_startup_latency.max());
// clang-format on
}
diff --git a/cobalt/media/decoder_buffer_allocator.cc b/cobalt/media/decoder_buffer_allocator.cc
index 6f3a1a1..57b9974 100644
--- a/cobalt/media/decoder_buffer_allocator.cc
+++ b/cobalt/media/decoder_buffer_allocator.cc
@@ -188,10 +188,6 @@
return max_buffer_capacity_;
}
-size_t DecoderBufferAllocator::GetSourceBufferEvictExtraInBytes() const {
- return source_buffer_evict_extra_in_bytes_;
-}
-
void DecoderBufferAllocator::EnsureReuseAllocatorIsCreated() {
mutex_.DCheckAcquired();
diff --git a/cobalt/media/decoder_buffer_allocator.h b/cobalt/media/decoder_buffer_allocator.h
index 2e08a9f..31c3df4 100644
--- a/cobalt/media/decoder_buffer_allocator.h
+++ b/cobalt/media/decoder_buffer_allocator.h
@@ -47,11 +47,6 @@
size_t GetAllocatedMemory() const override;
size_t GetCurrentMemoryCapacity() const override;
size_t GetMaximumMemoryCapacity() const override;
- size_t GetSourceBufferEvictExtraInBytes() const override;
-
- void SetSourceBufferEvictExtraInBytes(size_t evict_extra_in_bytes) {
- source_buffer_evict_extra_in_bytes_ = evict_extra_in_bytes;
- }
private:
void EnsureReuseAllocatorIsCreated();
@@ -66,7 +61,6 @@
std::unique_ptr<nb::BidirectionalFitReuseAllocator> reuse_allocator_;
int max_buffer_capacity_ = 0;
- size_t source_buffer_evict_extra_in_bytes_ = 0;
// Monitor memory allocation and use when |using_memory_pool_| is false
starboard::atomic_int32_t sbmemory_bytes_used_;
diff --git a/cobalt/media/decoder_buffer_memory_info.h b/cobalt/media/decoder_buffer_memory_info.h
index 2e4813b..730b303 100644
--- a/cobalt/media/decoder_buffer_memory_info.h
+++ b/cobalt/media/decoder_buffer_memory_info.h
@@ -28,14 +28,6 @@
virtual size_t GetAllocatedMemory() const = 0;
virtual size_t GetCurrentMemoryCapacity() const = 0;
virtual size_t GetMaximumMemoryCapacity() const = 0;
- // The return value will be used in `SourceBuffer::EvictCodedFrames()` so
- // it will evict extra data from the SourceBuffer, to reduce the overall
- // memory the underlying Demuxer implementation may use.
- // NOTE: This is not the best place to pass such information. Since it is a
- // tentative workaround that will be reverted once we confirm the new
- // DecoderBufferAllocator implementation works in production, adding this
- // here allows us to reduce interfaces passed from media to dom.
- virtual size_t GetSourceBufferEvictExtraInBytes() const = 0;
};
class StubDecoderBufferMemoryInfo : public DecoderBufferMemoryInfo {
@@ -45,7 +37,6 @@
size_t GetAllocatedMemory() const override { return 0; }
size_t GetCurrentMemoryCapacity() const override { return 0; }
size_t GetMaximumMemoryCapacity() const override { return 0; }
- size_t GetSourceBufferEvictExtraInBytes() const override { return 0; }
};
} // namespace media
diff --git a/cobalt/media/media_module.cc b/cobalt/media/media_module.cc
index 7a63e4b..11bcbd7 100644
--- a/cobalt/media/media_module.cc
+++ b/cobalt/media/media_module.cc
@@ -183,14 +183,6 @@
} // namespace
-bool MediaModule::SetConfiguration(const std::string& name, int32 value) {
- if (name == "source_buffer_evict_extra_in_bytes" && value >= 0) {
- decoder_buffer_allocator_.SetSourceBufferEvictExtraInBytes(value);
- return true;
- }
- return false;
-}
-
std::unique_ptr<WebMediaPlayer> MediaModule::CreateWebMediaPlayer(
WebMediaPlayerClient* client) {
TRACK_MEMORY_SCOPE("Media");
diff --git a/cobalt/media/media_module.h b/cobalt/media/media_module.h
index 0a90162..e79db38 100644
--- a/cobalt/media/media_module.h
+++ b/cobalt/media/media_module.h
@@ -61,11 +61,6 @@
system_window_(system_window),
resource_provider_(resource_provider) {}
- // Returns true when the setting is set successfully or if the setting has
- // already been set to the expected value. Returns false when the setting is
- // invalid or not set to the expected value.
- bool SetConfiguration(const std::string& name, int32 value);
-
const DecoderBufferAllocator* GetDecoderBufferAllocator() const {
return &decoder_buffer_allocator_;
}
diff --git a/cobalt/network/url_request_context.cc b/cobalt/network/url_request_context.cc
index 34cc482..eb46dcf 100644
--- a/cobalt/network/url_request_context.cc
+++ b/cobalt/network/url_request_context.cc
@@ -181,14 +181,20 @@
} else {
using_http_cache_ = true;
- // TODO: Set max size of cache in Starboard.
- const int cache_size_mb = 24;
+ int max_cache_bytes = 24 * 1024 * 1024;
+#if SB_API_VERSION >= 14
+ max_cache_bytes = kSbMaxSystemPathCacheDirectorySize;
+#endif
+ // Assume the non-http-cache memory in kSbSystemPathCacheDirectory
+ // is less than 1 mb and subtract this from the max_cache_bytes.
+ max_cache_bytes -= (1 << 20);
+
auto http_cache = std::make_unique<net::HttpCache>(
storage_.http_network_session(),
std::make_unique<net::HttpCache::DefaultBackend>(
net::DISK_CACHE, net::CACHE_BACKEND_COBALT,
base::FilePath(std::string(path.data())),
- /* max_bytes */ 1024 * 1024 * cache_size_mb),
+ /* max_bytes */ max_cache_bytes),
true);
if (persistent_settings != nullptr) {
auto cache_enabled = persistent_settings->GetPersistentSettingAsBool(
diff --git a/cobalt/script/BUILD.gn b/cobalt/script/BUILD.gn
index df196e6..fb5b577 100644
--- a/cobalt/script/BUILD.gn
+++ b/cobalt/script/BUILD.gn
@@ -60,6 +60,8 @@
"//cobalt/base",
"//nb",
"//starboard:starboard_headers_only",
+ "//third_party/v8",
+ "//third_party/v8:v8_libplatform",
"//url",
]
}
@@ -74,6 +76,8 @@
":script",
"//base",
"//cobalt/base",
+ "//third_party/v8",
+ "//third_party/v8:v8_libplatform",
]
}
diff --git a/cobalt/script/fake_global_environment.h b/cobalt/script/fake_global_environment.h
index d1d1cfb..51760fa 100644
--- a/cobalt/script/fake_global_environment.h
+++ b/cobalt/script/fake_global_environment.h
@@ -60,6 +60,10 @@
const scoped_refptr<Wrappable>& impl,
const std::string& local_object_name) override {}
ScriptValueFactory* script_value_factory() { return NULL; }
+ v8::Isolate* isolate() const override { return nullptr; }
+ v8::Local<v8::Context> context() const override {
+ return v8::Local<v8::Context>();
+ }
};
} // namespace script
diff --git a/cobalt/script/global_environment.h b/cobalt/script/global_environment.h
index 8681b94..4e569f3 100644
--- a/cobalt/script/global_environment.h
+++ b/cobalt/script/global_environment.h
@@ -27,6 +27,7 @@
#include "cobalt/script/stack_frame.h"
#include "cobalt/script/value_handle.h"
#include "cobalt/script/wrappable.h"
+#include "v8/include/v8.h"
namespace cobalt {
namespace script {
@@ -138,6 +139,9 @@
// should live longer than any ScriptValueFactory pointer.
virtual ScriptValueFactory* script_value_factory() = 0;
+ virtual v8::Isolate* isolate() const = 0;
+ virtual v8::Local<v8::Context> context() const = 0;
+
class ScopedPreventGarbageCollection {
public:
ScopedPreventGarbageCollection(GlobalEnvironment* global_environment,
diff --git a/cobalt/script/v8c/cobalt_platform.h b/cobalt/script/v8c/cobalt_platform.h
index 7c58d8e..c6d4399 100644
--- a/cobalt/script/v8c/cobalt_platform.h
+++ b/cobalt/script/v8c/cobalt_platform.h
@@ -17,6 +17,8 @@
#include <map>
#include <memory>
+#include <utility>
+#include <vector>
#include "base/memory/ref_counted.h"
#include "base/message_loop/message_loop.h"
@@ -60,7 +62,7 @@
return default_platform_->OnCriticalMemoryPressure(length);
}
- int NumberOfWorkerThreads() {
+ int NumberOfWorkerThreads() override {
return default_platform_->NumberOfWorkerThreads();
}
@@ -68,16 +70,17 @@
v8::Isolate* isolate) override;
std::unique_ptr<v8::JobHandle> PostJob(
- v8::TaskPriority priority, std::unique_ptr<v8::JobTask> job_task) override {
- return v8::platform::NewDefaultJobHandle(
- this, priority, std::move(job_task), NumberOfWorkerThreads());
+ v8::TaskPriority priority,
+ std::unique_ptr<v8::JobTask> job_task) override {
+ return v8::platform::NewDefaultJobHandle(
+ this, priority, std::move(job_task), NumberOfWorkerThreads());
}
void CallOnWorkerThread(std::unique_ptr<v8::Task> task) override {
default_platform_->CallOnWorkerThread(std::move(task));
}
- virtual void CallDelayedOnWorkerThread(std::unique_ptr<v8::Task> task,
- double delay_in_seconds) {
+ void CallDelayedOnWorkerThread(std::unique_ptr<v8::Task> task,
+ double delay_in_seconds) override {
default_platform_->CallDelayedOnWorkerThread(std::move(task),
delay_in_seconds);
}
diff --git a/cobalt/script/v8c/v8c_global_environment.h b/cobalt/script/v8c/v8c_global_environment.h
index fd4b772..a422397 100644
--- a/cobalt/script/v8c/v8c_global_environment.h
+++ b/cobalt/script/v8c/v8c_global_environment.h
@@ -102,8 +102,8 @@
ScriptValueFactory* script_value_factory() override;
- v8::Isolate* isolate() const { return isolate_; }
- v8::Local<v8::Context> context() const {
+ v8::Isolate* isolate() const override { return isolate_; }
+ v8::Local<v8::Context> context() const override {
return v8::Local<v8::Context>::New(isolate_, context_);
}
diff --git a/cobalt/script/v8c/v8c_value_handle.cc b/cobalt/script/v8c/v8c_value_handle.cc
index 9e33866..d95d653 100644
--- a/cobalt/script/v8c/v8c_value_handle.cc
+++ b/cobalt/script/v8c/v8c_value_handle.cc
@@ -12,10 +12,15 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+#include <memory>
#include <string>
+#include <unordered_map>
+#include <utility>
+#include <vector>
#include "cobalt/script/v8c/v8c_value_handle.h"
+#include "base/memory/ref_counted.h"
#include "cobalt/script/v8c/conversion_helpers.h"
#include "cobalt/script/v8c/entry_scope.h"
@@ -103,5 +108,54 @@
return v8c::ConvertSimpleObjectToMap(value, exception_state);
}
+v8::Isolate* GetIsolate(const ValueHandleHolder& value) {
+ const script::v8c::V8cValueHandleHolder* v8_value_handle_holder =
+ base::polymorphic_downcast<const script::v8c::V8cValueHandleHolder*>(
+ &value);
+ return v8_value_handle_holder->isolate();
+}
+
+v8::Local<v8::Value> GetV8Value(const ValueHandleHolder& value) {
+ const script::v8c::V8cValueHandleHolder* v8_value_handle_holder =
+ base::polymorphic_downcast<const script::v8c::V8cValueHandleHolder*>(
+ &value);
+ return v8_value_handle_holder->v8_value();
+}
+
+ValueHandleHolder* DeserializeScriptValue(v8::Isolate* isolate,
+ const DataBuffer& data_buffer) {
+ v8::EscapableHandleScope scope(isolate);
+ v8::TryCatch try_catch(isolate);
+ v8::Local<v8::Context> context = isolate->GetCurrentContext();
+
+ v8::ValueDeserializer deserializer(isolate, data_buffer.ptr.get(),
+ data_buffer.size);
+ v8::Local<v8::Value> value;
+ if (!deserializer.ReadValue(context).ToLocal(&value)) {
+ return nullptr;
+ }
+ script::v8c::V8cExceptionState exception_state(isolate);
+ auto* holder = new script::v8c::V8cValueHandleHolder();
+ FromJSValue(isolate, scope.Escape(value), script::v8c::kNoConversionFlags,
+ &exception_state, holder);
+ return holder;
+}
+
+std::unique_ptr<DataBuffer> SerializeScriptValue(
+ const ValueHandleHolder& value) {
+ v8::Isolate* isolate = GetIsolate(value);
+ script::v8c::EntryScope entry_scope(isolate);
+ v8::Local<v8::Value> v8_value = GetV8Value(value);
+ v8::ValueSerializer serializer(isolate);
+ bool wrote_value;
+ if (!serializer.WriteValue(isolate->GetCurrentContext(), v8_value)
+ .To(&wrote_value) ||
+ !wrote_value) {
+ return nullptr;
+ }
+ std::pair<uint8_t*, size_t> pair = serializer.Release();
+ return std::make_unique<DataBuffer>(std::move(pair.first), pair.second);
+}
+
} // namespace script
} // namespace cobalt
diff --git a/cobalt/script/value_handle.h b/cobalt/script/value_handle.h
index ef3b444..f0c8cce 100644
--- a/cobalt/script/value_handle.h
+++ b/cobalt/script/value_handle.h
@@ -15,11 +15,14 @@
#ifndef COBALT_SCRIPT_VALUE_HANDLE_H_
#define COBALT_SCRIPT_VALUE_HANDLE_H_
+#include <memory>
#include <string>
#include <unordered_map>
+#include "base/memory/ref_counted.h"
#include "cobalt/script/exception_state.h"
#include "cobalt/script/script_value.h"
+#include "v8/include/v8.h"
namespace cobalt {
namespace script {
@@ -35,6 +38,18 @@
typedef ScriptValue<ValueHandle> ValueHandleHolder;
+struct BufferDeleter {
+ void operator()(uint8_t* buffer) { SbMemoryDeallocate(buffer); }
+};
+using DataBufferPtr = std::unique_ptr<uint8_t[], BufferDeleter>;
+
+struct DataBuffer {
+ DataBufferPtr ptr;
+ size_t size;
+
+ DataBuffer(uint8_t* ptr, size_t size) : ptr(DataBufferPtr(ptr)), size(size) {}
+};
+
// Converts a "simple" object to a map of the object's properties. "Simple"
// means that the object's property names are strings and its property values
// must be a boolean, number or string. Note that this is implemented on a per
@@ -47,6 +62,13 @@
std::unordered_map<std::string, std::string> ConvertSimpleObjectToMap(
const ValueHandleHolder& value, ExceptionState* exception_state);
+v8::Isolate* GetIsolate(const ValueHandleHolder& value);
+v8::Local<v8::Value> GetV8Value(const ValueHandleHolder& value);
+ValueHandleHolder* DeserializeScriptValue(v8::Isolate* isolate,
+ const DataBuffer& data_buffer);
+std::unique_ptr<DataBuffer> SerializeScriptValue(
+ const ValueHandleHolder& value);
+
} // namespace script
} // namespace cobalt
diff --git a/cobalt/site/docs/communication.md b/cobalt/site/docs/communication.md
index e96bb45..d8d4d40 100644
--- a/cobalt/site/docs/communication.md
+++ b/cobalt/site/docs/communication.md
@@ -10,7 +10,7 @@
If you have identified a bug in Cobalt common code - meaning that you don't
expect that it is related to a platform or port implementation quirk, then you
-should file a bug on our public issue tracker.
+should file a bug on our public issue tracker.
Additionally, if you have specific feature requests, you can also file them on
our public tracker, but they should be very concrete and well-specified. If
@@ -26,7 +26,7 @@
address (say, your work email address).*
-## Asking Techincal Questions
+## Asking Technical Questions
For programming related technical questions about Starboard or Cobalt, we
encourage you to search through and post questions on [Stack
diff --git a/cobalt/site/docs/development/setup-android.md b/cobalt/site/docs/development/setup-android.md
index ac393b0..2c8bdb5 100644
--- a/cobalt/site/docs/development/setup-android.md
+++ b/cobalt/site/docs/development/setup-android.md
@@ -106,10 +106,10 @@
## Basic Build, Install, and Run (command-line based)
1. Complete the Preliminary Setup above
-1. Generate the cobalt.apk by building the "cobalt_deploy" target
+1. Generate the cobalt.apk by building the "cobalt_install" target
```
- ninja -C out/android-x86_gold cobalt_deploy
+ ninja -C out/android-x86_gold cobalt_install
```
Output can be found in the corresponding `out/android-x86_gold` directory.
diff --git a/cobalt/site/docs/development/setup-docker.md b/cobalt/site/docs/development/setup-docker.md
index afc7065..d7b2beb 100644
--- a/cobalt/site/docs/development/setup-docker.md
+++ b/cobalt/site/docs/development/setup-docker.md
@@ -65,9 +65,9 @@
base os image and version. Defaults to Debian 10. `ubuntu:bionic` and
`ubuntu:xenial` are other tested examples.
-**PLATFORM**: Cobalt build platform, passed to GYP
+**PLATFORM**: Cobalt build platform, passed to GN
-**CONFIG**: Cobalt build config, passed to GYP. Defaults to `debug`
+**CONFIG**: Cobalt build config, passed to GN. Defaults to `debug`
**TARGET**: Build target, passed to `ninja`
@@ -90,4 +90,4 @@
```
and try to build Cobalt with the <a
-href="https://cobalt.googlesource.com/cobalt/+/refs/heads/22.lts.stable/src/README.md#building-and-running-the-code">usual gyp / ninja flow.</a>
+href="https://cobalt.googlesource.com/cobalt/+/refs/heads/22.lts.stable/src/README.md#building-and-running-the-code">usual GN / ninja flow.</a>
diff --git a/cobalt/site/docs/development/setup-linux.md b/cobalt/site/docs/development/setup-linux.md
index b296507..8f570d6 100644
--- a/cobalt/site/docs/development/setup-linux.md
+++ b/cobalt/site/docs/development/setup-linux.md
@@ -31,7 +31,7 @@
$ export NVM_DIR=~/.nvm
$ export NODE_VERSION=12.17.0
- $ curl --silent -o- https://raw.githubusercontent.com/creationix/nvm/v0.35.3/install.sh | bash
+ $ curl --silent -o- https://raw.githubusercontent.com/nvm-sh/nvm/v0.35.3/install.sh | bash
$ . $NVM_DIR/nvm.sh \
&& nvm install --lts \
diff --git a/cobalt/speech/sandbox/speech_sandbox.cc b/cobalt/speech/sandbox/speech_sandbox.cc
index 56f46bd..78e3353 100644
--- a/cobalt/speech/sandbox/speech_sandbox.cc
+++ b/cobalt/speech/sandbox/speech_sandbox.cc
@@ -77,7 +77,7 @@
const dom::DOMSettings::Options& dom_settings_options) {
std::unique_ptr<script::EnvironmentSettings> environment_settings(
new dom::DOMSettings(null_debugger_hooks_, kDOMMaxElementDepth, NULL,
- NULL, NULL, NULL, dom_settings_options));
+ NULL, NULL, NULL, NULL, dom_settings_options));
DCHECK(environment_settings);
speech_recognition_ = new SpeechRecognition(environment_settings.get());
diff --git a/cobalt/test/document_loader.h b/cobalt/test/document_loader.h
index bb6ac15..6e6b7da 100644
--- a/cobalt/test/document_loader.h
+++ b/cobalt/test/document_loader.h
@@ -29,6 +29,7 @@
#include "cobalt/dom/dom_parser.h"
#include "cobalt/dom/dom_stat_tracker.h"
#include "cobalt/dom/html_element_context.h"
+#include "cobalt/dom/testing/fake_document.h"
#include "cobalt/dom/testing/stub_environment_settings.h"
#include "cobalt/dom_parser/parser.h"
#include "cobalt/loader/fetcher_factory.h"
@@ -78,7 +79,7 @@
dom::Document::Options options(url);
options.navigation_start_clock = new base::SystemMonotonicClock();
options.viewport_size = cssom::ViewportSize(1920, 1080);
- document_ = new dom::Document(&html_element_context_, options);
+ document_ = new dom::testing::FakeDocument(&html_element_context_, options);
document_->AddObserver(this);
document_loader_.reset(new loader::Loader(
base::Bind(&loader::FetcherFactory::CreateFetcher,
diff --git a/cobalt/watchdog/watchdog.cc b/cobalt/watchdog/watchdog.cc
index a8dd794..0a46c90 100644
--- a/cobalt/watchdog/watchdog.cc
+++ b/cobalt/watchdog/watchdog.cc
@@ -38,14 +38,14 @@
const char kWatchdogViolationsJson[] = "watchdog.json";
// The frequency in microseconds of monitor loops.
const int64_t kWatchdogMonitorFrequency = 1000000;
-// The maximum number of most recent repeated Watchdog violations.
-const int64_t kWatchdogMaxViolations = 100;
+// The maximum number of Watchdog violations.
+const int kWatchdogMaxViolations = 200;
// The minimum number of microseconds between writes.
const int64_t kWatchdogWriteWaitTime = 300000000;
// The maximum number of most recent ping infos.
-const int64_t kWatchdogMaxPingInfos = 20;
+const int kWatchdogMaxPingInfos = 20;
// The maximum length of each ping info.
-const int64_t kWatchdogMaxPingInfoLength = 1024;
+const int kWatchdogMaxPingInfoLength = 128;
// Persistent setting name and default setting for the boolean that controls
// whether or not Watchdog is enabled. When disabled, Watchdog behaves like a
@@ -162,14 +162,13 @@
SB_CHECK(SbMutexAcquire(&(static_cast<Watchdog*>(context))->mutex_) ==
kSbMutexAcquired);
+ // Shutdown
if (!((static_cast<Watchdog*>(context))->is_monitoring_)) {
SB_CHECK(SbMutexRelease(&(static_cast<Watchdog*>(context))->mutex_));
break;
}
- int64_t current_time = SbTimeToPosix(SbTimeGetNow());
SbTimeMonotonic current_monotonic_time = SbTimeGetMonotonicNow();
- base::Value registered_clients(base::Value::Type::LIST);
// Iterates through client map to monitor all registered clients.
bool watchdog_violation = false;
@@ -196,94 +195,7 @@
if (time_delta > client->time_interval_microseconds &&
time_wait > client->time_wait_microseconds) {
watchdog_violation = true;
-
- // Gets violation dictionary with key client name from violations_map_.
- if (static_cast<Watchdog*>(context)->violations_map_ == nullptr)
- InitializeViolationsMap(context);
- base::Value* violation_dict =
- (static_cast<Watchdog*>(context)->violations_map_)
- ->FindKey(client->name);
-
- // Checks if new unique violation.
- bool new_violation = false;
- if (violation_dict == nullptr) {
- new_violation = true;
- } else {
- // Compares against last_pinged_timestamp_microsecond of last
- // violation.
- base::Value* violations = violation_dict->FindKey("violations");
- int index = violations->GetList().size() - 1;
- std::string timestamp_last_pinged_microseconds =
- violations->GetList()[index]
- .FindKey("timestampLastPingedMicroseconds")
- ->GetString();
- if (timestamp_last_pinged_microseconds !=
- std::to_string(client->time_last_pinged_microseconds))
- new_violation = true;
- }
-
- // New unique violation.
- if (new_violation) {
- // Creates new violation.
- base::Value violation(base::Value::Type::DICTIONARY);
- violation.SetKey("pingInfos", client->ping_infos.Clone());
- violation.SetKey("monitorState",
- base::Value(std::string(GetApplicationStateString(
- client->monitor_state))));
- violation.SetKey(
- "timeIntervalMicroseconds",
- base::Value(std::to_string(client->time_interval_microseconds)));
- violation.SetKey(
- "timeWaitMicroseconds",
- base::Value(std::to_string(client->time_wait_microseconds)));
- violation.SetKey("timestampRegisteredMicroseconds",
- base::Value(std::to_string(
- client->time_registered_microseconds)));
- violation.SetKey("timestampLastPingedMicroseconds",
- base::Value(std::to_string(
- client->time_last_pinged_microseconds)));
- violation.SetKey("timestampViolationMicroseconds",
- base::Value(std::to_string(current_time)));
- violation.SetKey(
- "violationDurationMicroseconds",
- base::Value(std::to_string(time_delta -
- client->time_interval_microseconds)));
- if (registered_clients.GetList().empty()) {
- for (auto& it : static_cast<Watchdog*>(context)->client_map_) {
- registered_clients.GetList().emplace_back(base::Value(it.first));
- }
- }
- violation.SetKey("registeredClients", registered_clients.Clone());
-
- // Adds new violation to violations_map_.
- if (violation_dict == nullptr) {
- base::Value dict(base::Value::Type::DICTIONARY);
- dict.SetKey("description", base::Value(client->description));
- base::Value list(base::Value::Type::LIST);
- list.GetList().emplace_back(violation.Clone());
- dict.SetKey("violations", list.Clone());
- (static_cast<Watchdog*>(context)->violations_map_)
- ->SetKey(client->name, dict.Clone());
- } else {
- base::Value* violations = violation_dict->FindKey("violations");
- violations->GetList().emplace_back(violation.Clone());
- if (violations->GetList().size() > kWatchdogMaxViolations)
- violations->GetList().erase(violations->GetList().begin());
- }
- // Consecutive non-unique violation.
- } else {
- // Updates consecutive violation in violations_map_.
- base::Value* violations = violation_dict->FindKey("violations");
- int index = violations->GetList().size() - 1;
- int64_t violation_duration =
- std::stoll(violations->GetList()[index]
- .FindKey("violationDurationMicroseconds")
- ->GetString());
- violations->GetList()[index].SetKey(
- "violationDurationMicroseconds",
- base::Value(std::to_string(violation_duration + time_delta)));
- }
- static_cast<Watchdog*>(context)->pending_write_ = true;
+ UpdateViolationsMap(context, client, time_delta);
// Resets time last updated.
client->time_last_updated_monotonic_microseconds =
@@ -300,9 +212,103 @@
return nullptr;
}
+void Watchdog::UpdateViolationsMap(void* context, Client* client,
+ SbTimeMonotonic time_delta) {
+ // Gets violation dictionary with key client name from violations_map_.
+ if (static_cast<Watchdog*>(context)->violations_map_ == nullptr)
+ InitializeViolationsMap(context);
+ base::Value* violation_dict =
+ (static_cast<Watchdog*>(context)->violations_map_)->FindKey(client->name);
+
+ // Checks if new unique violation.
+ bool new_violation = false;
+ if (violation_dict == nullptr) {
+ new_violation = true;
+ } else {
+ // Compares against last_pinged_timestamp_microsecond of last violation.
+ base::Value* violations = violation_dict->FindKey("violations");
+ int last_index = violations->GetList().size() - 1;
+ std::string timestamp_last_pinged_milliseconds =
+ violations->GetList()[last_index]
+ .FindKey("timestampLastPingedMilliseconds")
+ ->GetString();
+ if (timestamp_last_pinged_milliseconds !=
+ std::to_string(client->time_last_pinged_microseconds / 1000))
+ new_violation = true;
+ }
+
+ // New unique violation.
+ if (new_violation) {
+ // Creates new violation.
+ base::Value violation(base::Value::Type::DICTIONARY);
+ violation.SetKey("pingInfos", client->ping_infos.Clone());
+ violation.SetKey("monitorState",
+ base::Value(std::string(
+ GetApplicationStateString(client->monitor_state))));
+ violation.SetKey(
+ "timeIntervalMilliseconds",
+ base::Value(std::to_string(client->time_interval_microseconds / 1000)));
+ violation.SetKey(
+ "timeWaitMilliseconds",
+ base::Value(std::to_string(client->time_wait_microseconds / 1000)));
+ violation.SetKey("timestampRegisteredMilliseconds",
+ base::Value(std::to_string(
+ client->time_registered_microseconds / 1000)));
+ violation.SetKey("timestampLastPingedMilliseconds",
+ base::Value(std::to_string(
+ client->time_last_pinged_microseconds / 1000)));
+ violation.SetKey(
+ "timestampViolationMilliseconds",
+ base::Value(std::to_string(SbTimeToPosix(SbTimeGetNow()) / 1000)));
+ violation.SetKey(
+ "violationDurationMilliseconds",
+ base::Value(std::to_string(
+ (time_delta - client->time_interval_microseconds) / 1000)));
+ base::Value registered_clients(base::Value::Type::LIST);
+ for (auto& it : static_cast<Watchdog*>(context)->client_map_) {
+ registered_clients.GetList().emplace_back(base::Value(it.first));
+ }
+ violation.SetKey("registeredClients", registered_clients.Clone());
+
+ // Adds new violation to violations_map_.
+ if (violation_dict == nullptr) {
+ base::Value dict(base::Value::Type::DICTIONARY);
+ dict.SetKey("description", base::Value(client->description));
+ base::Value list(base::Value::Type::LIST);
+ list.GetList().emplace_back(violation.Clone());
+ dict.SetKey("violations", list.Clone());
+ (static_cast<Watchdog*>(context)->violations_map_)
+ ->SetKey(client->name, dict.Clone());
+ } else {
+ base::Value* violations = violation_dict->FindKey("violations");
+ violations->GetList().emplace_back(violation.Clone());
+ }
+ static_cast<Watchdog*>(context)->violations_count_++;
+ if (static_cast<Watchdog*>(context)->violations_count_ >
+ kWatchdogMaxViolations)
+ EvictWatchdogViolation(context);
+ // Consecutive non-unique violation.
+ } else {
+ // Updates consecutive violation in violations_map_.
+ base::Value* violations = violation_dict->FindKey("violations");
+ int last_index = violations->GetList().size() - 1;
+ int64_t violation_duration =
+ std::stoll(violations->GetList()[last_index]
+ .FindKey("violationDurationMilliseconds")
+ ->GetString());
+ violations->GetList()[last_index].SetKey(
+ "violationDurationMilliseconds",
+ base::Value(std::to_string(violation_duration + (time_delta / 1000))));
+ }
+
+ static_cast<Watchdog*>(context)->pending_write_ = true;
+}
+
void Watchdog::InitializeViolationsMap(void* context) {
// Loads the previous Watchdog violations file containing violations before
// app start, if it exists, to populate violations_map_.
+ static_cast<Watchdog*>(context)->violations_count_ = 0;
+
starboard::ScopedFile read_file(
(static_cast<Watchdog*>(context)->GetWatchdogFilePath()).c_str(),
kSbFileOpenOnly | kSbFileRead);
@@ -314,13 +320,56 @@
static_cast<Watchdog*>(context)->violations_map_ =
base::JSONReader::Read(watchdog_json);
}
+
if (static_cast<Watchdog*>(context)->violations_map_ == nullptr) {
SB_LOG(INFO) << "[Watchdog] No previous violations JSON.";
static_cast<Watchdog*>(context)->violations_map_ =
std::make_unique<base::Value>(base::Value::Type::DICTIONARY);
+ } else {
+ for (const auto& it :
+ (static_cast<Watchdog*>(context)->violations_map_)->DictItems()) {
+ base::Value& violation_dict = it.second;
+ base::Value* violations = violation_dict.FindKey("violations");
+ static_cast<Watchdog*>(context)->violations_count_ +=
+ violations->GetList().size();
+ }
}
}
+void Watchdog::EvictWatchdogViolation(void* context) {
+ // Evicts a violation in violations_map_ prioritizing first the most frequent
+ // violations (largest violations count by client name) and second the oldest
+ // violation.
+ std::string evicted_name = "";
+ int evicted_count = 0;
+ int64_t evicted_timestamp = 0;
+
+ for (const auto& it :
+ (static_cast<Watchdog*>(context)->violations_map_)->DictItems()) {
+ std::string name = it.first;
+ base::Value& violation_dict = it.second;
+ base::Value* violations = violation_dict.FindKey("violations");
+ int count = violations->GetList().size();
+ int64_t timestamp =
+ std::stoll(violations->GetList()[0]
+ .FindKey("timestampViolationMilliseconds")
+ ->GetString());
+
+ if ((evicted_name == "") || (count > evicted_count) ||
+ ((count == evicted_count) && (timestamp < evicted_timestamp))) {
+ evicted_name = name;
+ evicted_count = count;
+ evicted_timestamp = timestamp;
+ }
+ }
+
+ base::Value* violation_dict =
+ (static_cast<Watchdog*>(context)->violations_map_)->FindKey(evicted_name);
+ base::Value* violations = violation_dict->FindKey("violations");
+ violations->GetList().erase(violations->GetList().begin());
+ static_cast<Watchdog*>(context)->violations_count_--;
+}
+
void Watchdog::MaybeWriteWatchdogViolations(void* context) {
if (SbTimeGetMonotonicNow() >
static_cast<Watchdog*>(context)->time_last_written_microseconds_ +
@@ -345,9 +394,9 @@
if (is_disabled_) return true;
// Validates parameters.
- if (time_interval < 1000000 || time_wait < 0) {
+ if (time_interval < kWatchdogMonitorFrequency || time_wait < 0) {
SB_DLOG(ERROR) << "[Watchdog] Unable to Register: " << name;
- if (time_interval < 1000000) {
+ if (time_interval < kWatchdogMonitorFrequency) {
SB_DLOG(ERROR) << "[Watchdog] Time interval less than min: "
<< kWatchdogMonitorFrequency;
} else {
@@ -450,8 +499,8 @@
if (info != "") {
// Creates new ping_info.
base::Value ping_info(base::Value::Type::DICTIONARY);
- ping_info.SetKey("timestampMicroseconds",
- base::Value(std::to_string(current_time)));
+ ping_info.SetKey("timestampMilliseconds",
+ base::Value(std::to_string(current_time / 1000)));
ping_info.SetKey("info", base::Value(info));
client->ping_infos.GetList().emplace_back(ping_info.Clone());
@@ -491,6 +540,7 @@
base::DictionaryValue** dict = nullptr;
violations_map_->GetAsDictionary(dict);
if (dict) (*dict)->Clear();
+ violations_count_ = 0;
}
starboard::SbFileDeleteRecursive(GetWatchdogFilePath().c_str(), true);
SB_LOG(INFO) << "[Watchdog] Reading violations:\n" << watchdog_json;
diff --git a/cobalt/watchdog/watchdog.h b/cobalt/watchdog/watchdog.h
index 7ab5d96..1532f79 100644
--- a/cobalt/watchdog/watchdog.h
+++ b/cobalt/watchdog/watchdog.h
@@ -97,7 +97,10 @@
std::string GetWatchdogFilePath();
void WriteWatchdogViolations();
static void* Monitor(void* context);
+ static void UpdateViolationsMap(void* context, Client* client,
+ SbTimeMonotonic time_delta);
static void InitializeViolationsMap(void* context);
+ static void EvictWatchdogViolation(void* context);
static void MaybeWriteWatchdogViolations(void* context);
static void MaybeTriggerCrash(void* context);
@@ -128,6 +131,8 @@
std::unordered_map<std::string, std::unique_ptr<Client>> client_map_;
// Dictionary of lists of Watchdog violations represented as dictionaries.
std::unique_ptr<base::Value> violations_map_;
+ // Number of violations in violations_map_;
+ int violations_count_;
// Monitor thread.
SbThread watchdog_thread_;
// Flag to stop monitor thread.
diff --git a/cobalt/web/agent.cc b/cobalt/web/agent.cc
index d017e6d..f52e113 100644
--- a/cobalt/web/agent.cc
+++ b/cobalt/web/agent.cc
@@ -18,6 +18,7 @@
#include <memory>
#include <utility>
+#include "base/observer_list.h"
#include "base/trace_event/trace_event.h"
#include "cobalt/loader/fetcher_factory.h"
#include "cobalt/loader/script_loader_factory.h"
@@ -51,6 +52,11 @@
explicit Impl(const Agent::Options& options);
virtual ~Impl();
+ void AddEnvironmentSettingsChangeObserver(
+ EnvironmentSettingsChangeObserver* observer) final;
+ void RemoveEnvironmentSettingsChangeObserver(
+ EnvironmentSettingsChangeObserver* observer) final;
+
// Context
//
void set_message_loop(base::MessageLoop* message_loop) {
@@ -88,6 +94,9 @@
const std::string& name() const final { return name_; };
void setup_environment_settings(
EnvironmentSettings* environment_settings) final {
+ for (auto& observer : environment_settings_change_observers_) {
+ observer.OnEnvironmentSettingsChanged(!!environment_settings);
+ }
environment_settings_.reset(environment_settings);
if (environment_settings_) environment_settings_->set_context(this);
}
@@ -208,6 +217,9 @@
scoped_refptr<worker::ServiceWorkerObject> active_service_worker_;
scoped_refptr<worker::ServiceWorkerRegistrationObject>
containing_service_worker_registration_;
+
+ base::ObserverList<Context::EnvironmentSettingsChangeObserver>::Unchecked
+ environment_settings_change_observers_;
};
Impl::Impl(const Agent::Options& options) : name_(options.name) {
@@ -269,6 +281,7 @@
}
setup_environment_settings(nullptr);
+ environment_settings_change_observers_.Clear();
blob_registry_.reset();
script_runner_.reset();
execution_state_.reset();
@@ -280,6 +293,16 @@
Impl::~Impl() { ShutDownJavaScriptEngine(); }
+void Impl::AddEnvironmentSettingsChangeObserver(
+ Context::EnvironmentSettingsChangeObserver* observer) {
+ environment_settings_change_observers_.AddObserver(observer);
+}
+
+void Impl::RemoveEnvironmentSettingsChangeObserver(
+ Context::EnvironmentSettingsChangeObserver* observer) {
+ environment_settings_change_observers_.RemoveObserver(observer);
+}
+
void Impl::InjectGlobalObjectAttributes(
const Agent::Options::InjectedGlobalObjectAttributes& attributes) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
diff --git a/cobalt/web/context.h b/cobalt/web/context.h
index f48182f..360dbe2 100644
--- a/cobalt/web/context.h
+++ b/cobalt/web/context.h
@@ -44,6 +44,15 @@
class Context {
public:
virtual ~Context() {}
+
+ class EnvironmentSettingsChangeObserver {
+ public:
+ virtual void OnEnvironmentSettingsChanged(bool context_valid) = 0;
+
+ protected:
+ virtual ~EnvironmentSettingsChangeObserver() = default;
+ };
+
virtual base::MessageLoop* message_loop() const = 0;
virtual void ShutDownJavaScriptEngine() = 0;
virtual loader::FetcherFactory* fetcher_factory() const = 0;
@@ -82,6 +91,11 @@
virtual std::string GetUserAgent() const = 0;
virtual std::string GetPreferredLanguage() const = 0;
+ virtual void AddEnvironmentSettingsChangeObserver(
+ EnvironmentSettingsChangeObserver* observer) = 0;
+ virtual void RemoveEnvironmentSettingsChangeObserver(
+ EnvironmentSettingsChangeObserver* observer) = 0;
+
// https://w3c.github.io/ServiceWorker/#dfn-control
virtual bool is_controlled_by(worker::ServiceWorkerObject* worker) const = 0;
diff --git a/cobalt/web/csp_violation_reporter.cc b/cobalt/web/csp_violation_reporter.cc
index 268ac95..2cb1951 100644
--- a/cobalt/web/csp_violation_reporter.cc
+++ b/cobalt/web/csp_violation_reporter.cc
@@ -21,7 +21,6 @@
#include "base/json/json_writer.h"
#include "base/values.h"
#include "cobalt/dom/document.h"
-#include "cobalt/dom/html_element_context.h"
#include "cobalt/network/net_poster.h"
#include "cobalt/script/global_environment.h"
#include "cobalt/web/security_policy_violation_event.h"
@@ -83,12 +82,12 @@
}
void GatherSecurityPolicyViolationEventData(
- const dom::Document* document, const csp::ViolationInfo& violation_info,
+ WindowOrWorkerGlobalScope* global, const csp::ViolationInfo& violation_info,
ViolationEvent* event_data) {
- event_data->document_uri =
- StripUrlForUseInReport(document->url_as_gurl(), document->url_as_gurl());
- event_data->blocked_uri = StripUrlForUseInReport(document->url_as_gurl(),
- violation_info.blocked_url);
+ GURL base_url = global->environment_settings()->base_url();
+ event_data->document_uri = StripUrlForUseInReport(base_url, base_url);
+ event_data->blocked_uri =
+ StripUrlForUseInReport(base_url, violation_info.blocked_url);
// TODO: Implement Document referrer, if needed.
event_data->referrer = "";
event_data->violated_directive = violation_info.directive_text;
@@ -96,14 +95,14 @@
event_data->original_policy = violation_info.header;
script::GlobalEnvironment* global_environment =
- document->html_element_context()->script_runner()->GetGlobalEnvironment();
+ global->environment_settings()->context()->global_environment();
const std::vector<script::StackFrame>& stack_trace =
global_environment->GetStackTrace(1);
if (stack_trace.size() > 0) {
event_data->line_number = stack_trace[0].line_number;
event_data->column_number = stack_trace[0].column_number;
- event_data->source_file = StripUrlForUseInReport(
- document->url_as_gurl(), GURL(stack_trace[0].source_url));
+ event_data->source_file =
+ StripUrlForUseInReport(base_url, GURL(stack_trace[0].source_url));
}
// TODO: Set the status code if the document origin is non-secure.
@@ -113,14 +112,15 @@
} // namespace
CspViolationReporter::CspViolationReporter(
- dom::Document* document, const network_bridge::PostSender& post_sender)
+ web::WindowOrWorkerGlobalScope* global,
+ const network_bridge::PostSender& post_sender)
: post_sender_(post_sender),
message_loop_(base::MessageLoop::current()),
- document_(document) {}
+ global_(global) {}
CspViolationReporter::~CspViolationReporter() {}
-// https://www.w3.org/TR/CSP2/#violation-reports
+// https://www.w3.org/TR/CSP3/#report-violation
void CspViolationReporter::Report(const csp::ViolationInfo& violation_info) {
DCHECK(message_loop_);
if (!message_loop_->task_runner()->BelongsToCurrentThread()) {
@@ -132,14 +132,24 @@
LOG(INFO) << violation_info.console_message;
ViolationEvent violation_data;
- GatherSecurityPolicyViolationEventData(document_, violation_info,
+ GatherSecurityPolicyViolationEventData(global_, violation_info,
&violation_data);
- document_->DispatchEvent(new SecurityPolicyViolationEvent(
- violation_data.document_uri, violation_data.referrer,
- violation_data.blocked_uri, violation_data.violated_directive,
- violation_data.effective_directive, violation_data.original_policy,
- violation_data.source_file, violation_data.status_code,
- violation_data.line_number, violation_data.column_number));
+ if (global_->IsWindow()) {
+ global_->AsWindow()->document()->DispatchEvent(
+ new SecurityPolicyViolationEvent(
+ violation_data.document_uri, violation_data.referrer,
+ violation_data.blocked_uri, violation_data.violated_directive,
+ violation_data.effective_directive, violation_data.original_policy,
+ violation_data.source_file, violation_data.status_code,
+ violation_data.line_number, violation_data.column_number));
+ } else {
+ global_->DispatchEvent(new SecurityPolicyViolationEvent(
+ violation_data.document_uri, violation_data.referrer,
+ violation_data.blocked_uri, violation_data.violated_directive,
+ violation_data.effective_directive, violation_data.original_policy,
+ violation_data.source_file, violation_data.status_code,
+ violation_data.line_number, violation_data.column_number));
+ }
if (violation_info.endpoints.empty() || post_sender_.is_null()) {
return;
@@ -190,7 +200,7 @@
return;
}
violation_reports_sent_.insert(report_hash);
- const GURL& origin_url = document_->url_as_gurl();
+ const GURL& origin_url = global_->environment_settings()->base_url();
for (std::vector<std::string>::const_iterator it = endpoints.begin();
it != endpoints.end(); ++it) {
GURL resolved_endpoint = origin_url.Resolve(*it);
diff --git a/cobalt/web/csp_violation_reporter.h b/cobalt/web/csp_violation_reporter.h
index c7aa1a5..b2b9a98 100644
--- a/cobalt/web/csp_violation_reporter.h
+++ b/cobalt/web/csp_violation_reporter.h
@@ -25,11 +25,8 @@
#include "cobalt/network_bridge/net_poster.h"
namespace cobalt {
-namespace dom {
-class Document;
-} // namespace dom
-
namespace web {
+class WindowOrWorkerGlobalScope;
// Responsible for reporting CSP violations, i.e. posting JSON
// reports to any reporting endpoints described by the policy.
@@ -37,12 +34,12 @@
// and passed in to its constructor. Generally it should not be called directly.
class CspViolationReporter {
public:
- CspViolationReporter(dom::Document* document,
+ CspViolationReporter(WindowOrWorkerGlobalScope* global,
const network_bridge::PostSender& post_sender);
virtual ~CspViolationReporter();
// Used as a callback from ContentSecurityPolicy to dispatch security
- // violation events on the Document and send the reports.
+ // violation events on the Document or Global Object and send the reports.
// Report() can be called from any thread and it will re-post itself
// to the message loop it was created on, which should be the Document's
// message loop.
@@ -63,7 +60,7 @@
// We must send violations on the document's message loop.
base::MessageLoop* message_loop_;
- dom::Document* document_;
+ WindowOrWorkerGlobalScope* global_;
DISALLOW_COPY_AND_ASSIGN(CspViolationReporter);
};
diff --git a/cobalt/web/message_event.cc b/cobalt/web/message_event.cc
index 0f153b6..a6e8888 100644
--- a/cobalt/web/message_event.cc
+++ b/cobalt/web/message_event.cc
@@ -20,15 +20,20 @@
#include "base/basictypes.h"
#include "cobalt/base/polymorphic_downcast.h"
+#include "cobalt/script/v8c/conversion_helpers.h"
+#include "cobalt/script/v8c/entry_scope.h"
+#include "cobalt/script/v8c/v8c_exception_state.h"
#include "cobalt/web/context.h"
#include "cobalt/web/environment_settings.h"
#include "starboard/common/string.h"
+#include "starboard/memory.h"
+#include "v8/include/v8.h"
namespace {
-const char* const kResponseTypes[] = {"text", "blob", "arraybuffer"};
+const char* const kResponseTypes[] = {"text", "blob", "arraybuffer", "any"};
COMPILE_ASSERT(arraysize(kResponseTypes) ==
- cobalt::web::MessageEvent::kResponseTypeCodeMax,
+ cobalt::web::MessageEvent::kResponseTypeMax,
enum_and_array_size_mismatch);
} // namespace
@@ -36,67 +41,73 @@
namespace cobalt {
namespace web {
+// static
std::string MessageEvent::GetResponseTypeAsString(
- const MessageEvent::ResponseTypeCode code) {
- DCHECK_LT(code, kResponseTypeCodeMax);
- if ((code >= kText) && (code < kResponseTypeCodeMax)) {
- return kResponseTypes[code];
- }
- return std::string();
+ const MessageEvent::ResponseType response_type) {
+ DCHECK_GE(response_type, kText);
+ DCHECK_LT(response_type, kResponseTypeMax);
+ return kResponseTypes[response_type];
}
-MessageEvent::ResponseTypeCode MessageEvent::GetResponseTypeCode(
+// static
+MessageEvent::ResponseType MessageEvent::GetResponseType(
base::StringPiece to_match) {
for (std::size_t i = 0; i != arraysize(kResponseTypes); ++i) {
if (strncmp(kResponseTypes[i], to_match.data(), to_match.size()) == 0) {
- return MessageEvent::ResponseTypeCode(i);
+ return MessageEvent::ResponseType(i);
}
}
- return kResponseTypeCodeMax;
+ return kResponseTypeMax;
}
-MessageEvent::ResponseType MessageEvent::data(
+MessageEvent::Response MessageEvent::data(
script::EnvironmentSettings* settings) const {
- const char* data_pointer = NULL;
- int data_length = 0;
- if (data_) {
- data_pointer = data_->data();
- data_length = data_->size();
+ if (!data_ && !data_io_buffer_) {
+ return Response("");
}
- auto* global_environment =
- settings ? base::polymorphic_downcast<web::EnvironmentSettings*>(settings)
- ->context()
- ->global_environment()
- : nullptr;
- script::Handle<script::ArrayBuffer> response_buffer;
- if (response_type_ != kText) {
+ script::GlobalEnvironment* global_environment = nullptr;
+ if (response_type_ == kBlob || response_type_ == kArrayBuffer ||
+ response_type_ == kAny) {
+ DCHECK(settings);
+ global_environment =
+ base::polymorphic_downcast<web::EnvironmentSettings*>(settings)
+ ->context()
+ ->global_environment();
DCHECK(global_environment);
- auto buffer_copy =
- script::ArrayBuffer::New(global_environment, data_pointer, data_length);
- response_buffer = std::move(buffer_copy);
}
switch (response_type_) {
case kText: {
// TODO: Find a way to remove two copies of data here.
- std::string string_response(data_pointer, data_length);
- return ResponseType(string_response);
+ std::string string_response(data_io_buffer_->data(),
+ data_io_buffer_->size());
+ return Response(string_response);
}
- case kBlob: {
- DCHECK(settings);
- scoped_refptr<web::Blob> blob = new web::Blob(settings, response_buffer);
- return ResponseType(blob);
- }
+ case kBlob:
case kArrayBuffer: {
- return ResponseType(response_buffer);
+ auto buffer_copy = script::ArrayBuffer::New(
+ global_environment, data_io_buffer_->data(), data_io_buffer_->size());
+ script::Handle<script::ArrayBuffer> response_buffer =
+ std::move(buffer_copy);
+ if (response_type_ == kBlob) {
+ DCHECK(settings);
+ scoped_refptr<web::Blob> blob =
+ new web::Blob(settings, response_buffer);
+ return Response(blob);
+ }
+ return Response(response_buffer);
}
- case kResponseTypeCodeMax:
+ case kAny: {
+ v8::Isolate* isolate = global_environment->isolate();
+ script::v8c::EntryScope entry_scope(isolate);
+ return Response(script::Handle<script::ValueHandle>(
+ std::move(script::DeserializeScriptValue(isolate, *data_))));
+ }
+ default:
NOTREACHED() << "Invalid response type.";
- return ResponseType();
+ return Response("");
}
-
- return ResponseType();
}
} // namespace web
diff --git a/cobalt/web/message_event.h b/cobalt/web/message_event.h
index 88a838a..b39a198 100644
--- a/cobalt/web/message_event.h
+++ b/cobalt/web/message_event.h
@@ -16,58 +16,63 @@
#ifndef COBALT_WEB_MESSAGE_EVENT_H_
#define COBALT_WEB_MESSAGE_EVENT_H_
+#include <memory>
#include <string>
+#include <utility>
#include "base/memory/ref_counted.h"
#include "base/strings/string_piece.h"
#include "cobalt/base/token.h"
#include "cobalt/script/array_buffer.h"
#include "cobalt/script/union_type.h"
+#include "cobalt/script/v8c/v8c_value_handle.h"
#include "cobalt/script/wrappable.h"
#include "cobalt/web/blob.h"
#include "cobalt/web/event.h"
#include "cobalt/web/message_event_init.h"
#include "net/base/io_buffer.h"
+#include "v8/include/v8.h"
namespace cobalt {
namespace web {
class MessageEvent : public web::Event {
public:
- typedef script::UnionType3<std::string, scoped_refptr<web::Blob>,
- script::Handle<script::ArrayBuffer> >
- ResponseType;
- // These response codes are ordered in the likelihood of being used.
+ typedef script::UnionType4<std::string, scoped_refptr<web::Blob>,
+ script::Handle<script::ArrayBuffer>,
+ script::Handle<script::ValueHandle>>
+ Response;
+ // These response types are ordered in the likelihood of being used.
// Keeping them in expected order will help make code faster.
- enum ResponseTypeCode { kText, kBlob, kArrayBuffer, kResponseTypeCodeMax };
-
- explicit MessageEvent(const std::string& type) : Event(type) {}
- MessageEvent(const std::string& type, const web::MessageEventInit& init_dict)
- : Event(type, init_dict),
- data_(new net::IOBufferWithSize(init_dict.data().size())) {
- init_dict.data().copy(data_->data(), data_->size());
- }
-
- MessageEvent(base::Token type, ResponseTypeCode response_type,
- const scoped_refptr<net::IOBufferWithSize>& data)
- : Event(type), response_type_(response_type), data_(data) {}
+ enum ResponseType { kText, kBlob, kArrayBuffer, kAny, kResponseTypeMax };
// Creates an event with its "initialized flag" unset.
explicit MessageEvent(UninitializedFlag uninitialized_flag)
: Event(uninitialized_flag) {}
- ResponseType data(script::EnvironmentSettings* settings = nullptr) const;
+ explicit MessageEvent(const std::string& type) : Event(type) {}
+ MessageEvent(base::Token type, std::unique_ptr<script::DataBuffer> data)
+ : Event(type), response_type_(kAny), data_(std::move(data)) {}
+ MessageEvent(base::Token type, ResponseType response_type,
+ const scoped_refptr<net::IOBufferWithSize>& data)
+ : Event(type), response_type_(response_type), data_io_buffer_(data) {}
+ MessageEvent(const std::string& type, const web::MessageEventInit& init_dict)
+ : Event(type, init_dict),
+ response_type_(kAny),
+ data_(script::SerializeScriptValue(*(init_dict.data()))) {}
+
+ Response data(script::EnvironmentSettings* settings = nullptr) const;
// These helper functions are custom, and not in any spec.
- static std::string GetResponseTypeAsString(const ResponseTypeCode code);
- // This function returns kResponseTypeCodeMax if no match is found.
- static ResponseTypeCode GetResponseTypeCode(base::StringPiece to_match);
+ static std::string GetResponseTypeAsString(const ResponseType response_type);
+ static MessageEvent::ResponseType GetResponseType(base::StringPiece to_match);
DEFINE_WRAPPABLE_TYPE(MessageEvent)
private:
- ResponseTypeCode response_type_ = kText;
- scoped_refptr<net::IOBufferWithSize> data_;
+ ResponseType response_type_ = kText;
+ scoped_refptr<net::IOBufferWithSize> data_io_buffer_;
+ std::unique_ptr<script::DataBuffer> data_;
};
} // namespace web
diff --git a/cobalt/web/message_event.idl b/cobalt/web/message_event.idl
index 9f722bd..0e15ab7 100644
--- a/cobalt/web/message_event.idl
+++ b/cobalt/web/message_event.idl
@@ -19,5 +19,5 @@
Exposed = (Window,Worker),
Constructor(DOMString type, optional MessageEventInit eventInitDict)
] interface MessageEvent : Event {
- [CallWith = EnvironmentSettings] readonly attribute DOMString data;
+ [CallWith = EnvironmentSettings] readonly attribute any data;
};
diff --git a/cobalt/web/message_event_init.idl b/cobalt/web/message_event_init.idl
index 9de818e..9ccf914 100644
--- a/cobalt/web/message_event_init.idl
+++ b/cobalt/web/message_event_init.idl
@@ -15,5 +15,5 @@
// https://www.w3.org/TR/html50/webappapis.html#erroreventinit
dictionary MessageEventInit : EventInit {
- DOMString data = "";
+ any data = null;
};
diff --git a/cobalt/web/message_event_test.cc b/cobalt/web/message_event_test.cc
index 4feaab2..d8f6d6d 100644
--- a/cobalt/web/message_event_test.cc
+++ b/cobalt/web/message_event_test.cc
@@ -20,6 +20,8 @@
#include "base/bind.h"
#include "base/logging.h"
#include "cobalt/dom/testing/test_with_javascript.h"
+#include "cobalt/script/v8c/entry_scope.h"
+#include "cobalt/script/value_handle.h"
#include "cobalt/web/message_event_init.h"
#include "cobalt/web/testing/gtest_workarounds.h"
#include "testing/gmock/include/gmock/gmock.h"
@@ -46,14 +48,17 @@
EXPECT_FALSE(event->IsBeingDispatched());
EXPECT_FALSE(event->propagation_stopped());
EXPECT_FALSE(event->immediate_propagation_stopped());
- MessageEvent::ResponseType event_data = event->data();
+ MessageEvent::Response event_data = event->data();
EXPECT_TRUE(event_data.IsType<std::string>());
EXPECT_EQ("", event_data.AsType<std::string>());
}
-TEST(MessageEventTest, ConstructorWithEventTypeAndDefaultInitDict) {
+TEST_F(MessageEventTestWithJavaScript,
+ ConstructorWithEventTypeAndDefaultInitDict) {
MessageEventInit init;
- init.set_data("data_value");
+ base::Optional<script::ValueHandleHolder::Reference> reference;
+ EvaluateScript("'data_value'", window(), &reference);
+ init.set_data(&(reference->referenced_value()));
scoped_refptr<MessageEvent> event = new MessageEvent("mytestevent", init);
EXPECT_EQ("mytestevent", event->type());
@@ -66,33 +71,34 @@
EXPECT_FALSE(event->IsBeingDispatched());
EXPECT_FALSE(event->propagation_stopped());
EXPECT_FALSE(event->immediate_propagation_stopped());
- MessageEvent::ResponseType event_data = event->data();
- EXPECT_TRUE(event_data.IsType<std::string>());
- EXPECT_EQ("data_value", event_data.AsType<std::string>());
+ MessageEvent::Response event_data =
+ event->data(window()->environment_settings());
+ EXPECT_TRUE(event_data.IsType<script::Handle<script::ValueHandle>>());
+ auto script_value =
+ event_data.AsType<script::Handle<script::ValueHandle>>().GetScriptValue();
+ auto* isolate = script::GetIsolate(*script_value);
+ script::v8c::EntryScope entry_scope(isolate);
+ v8::Local<v8::Value> v8_value = script::GetV8Value(*script_value);
+ std::string actual =
+ *(v8::String::Utf8Value(isolate, v8_value.As<v8::String>()));
+ EXPECT_EQ("data_value", actual);
}
TEST_F(MessageEventTestWithJavaScript,
ConstructorWithEventTypeAndErrorInitDict) {
std::string result;
- bool success = EvaluateScript(
- "var event = new MessageEvent('dog', "
- " {'cancelable':true, "
- " 'data':'data_value'});"
- "if (event.type == 'dog' &&"
- " event.bubbles == false &&"
- " event.cancelable == true &&"
- " event.data == 'data_value') "
- " event.data;",
- &result);
+ EXPECT_TRUE(
+ EvaluateScript("var event = new MessageEvent('dog', "
+ " {'cancelable':true, "
+ " 'data':'data_value'});"
+ "if (event.type == 'dog' &&"
+ " event.bubbles == false &&"
+ " event.cancelable == true &&"
+ " event.data == 'data_value') "
+ " event.data;",
+ &result))
+ << "Failed to evaluate script.";
EXPECT_EQ("data_value", result);
-
- if (!success) {
- DLOG(ERROR) << "Failed to evaluate test: "
- << "\"" << result << "\"";
- } else {
- LOG(INFO) << "Test result : "
- << "\"" << result << "\"";
- }
}
} // namespace web
diff --git a/cobalt/web/message_port.cc b/cobalt/web/message_port.cc
index bc56140..519e682 100644
--- a/cobalt/web/message_port.cc
+++ b/cobalt/web/message_port.cc
@@ -14,7 +14,9 @@
#include "cobalt/web/message_port.h"
+#include <memory>
#include <string>
+#include <utility>
#include "base/bind.h"
#include "base/bind_helpers.h"
@@ -33,35 +35,63 @@
namespace web {
MessagePort::MessagePort(web::EventTarget* event_target)
- : event_target_(event_target) {}
+ : event_target_(event_target) {
+ if (!event_target_) {
+ return;
+ }
+ Context* context = event_target_->environment_settings()->context();
+ base::MessageLoop* message_loop = context->message_loop();
+ if (!message_loop) {
+ return;
+ }
+ message_loop->task_runner()->PostTask(
+ FROM_HERE,
+ base::BindOnce(&Context::AddEnvironmentSettingsChangeObserver,
+ base::Unretained(context), base::Unretained(this)));
+ remove_environment_settings_change_observer_ =
+ base::BindOnce(&Context::RemoveEnvironmentSettingsChangeObserver,
+ base::Unretained(context), base::Unretained(this));
+}
-MessagePort::~MessagePort() { event_target_ = nullptr; }
+MessagePort::~MessagePort() { Close(); }
-void MessagePort::PostMessage(const std::string& messages) {
+void MessagePort::Close() {
+ if (!event_target_) {
+ return;
+ }
+ if (remove_environment_settings_change_observer_) {
+ std::move(remove_environment_settings_change_observer_).Run();
+ }
+ event_target_ = nullptr;
+}
+
+void MessagePort::PostMessage(const script::ValueHandleHolder& message) {
+ PostMessageSerialized(std::move(SerializeScriptValue(message)));
+}
+
+void MessagePort::PostMessageSerialized(
+ std::unique_ptr<script::DataBuffer> data_buffer) {
+ if (!event_target_ || !data_buffer) {
+ return;
+ }
// TODO: Forward the location of the origating API call to the PostTask call.
base::MessageLoop* message_loop =
event_target_->environment_settings()->context()->message_loop();
- if (message_loop) {
- // https://html.spec.whatwg.org/multipage/workers.html#handler-worker-onmessage
- // TODO: Update MessageEvent to support more types. (b/227665847)
- // TODO: Remove dependency of MessageEvent on net iobuffer (b/227665847)
- message_loop->task_runner()->PostTask(
- FROM_HERE,
- base::Bind(
- [](web::EventTarget* event_target, const std::string& messages) {
- scoped_refptr<net::IOBufferWithSize> buf = base::WrapRefCounted(
- new net::IOBufferWithSize(messages.length()));
- memcpy(buf->data(), messages.data(), messages.length());
- if (event_target) {
- event_target->DispatchEvent(new web::MessageEvent(
- base::Tokens::message(), web::MessageEvent::kText, buf));
- }
- LOG_IF(WARNING, !event_target)
- << "MessagePort event not dispatched "
- "because there is no EventTarget.";
- },
- base::Unretained(event_target_), messages));
+ if (!message_loop) {
+ return;
}
+ // https://html.spec.whatwg.org/multipage/workers.html#handler-worker-onmessage
+ // TODO: Update MessageEvent to support more types. (b/227665847)
+ // TODO: Remove dependency of MessageEvent on net iobuffer (b/227665847)
+ message_loop->task_runner()->PostTask(
+ FROM_HERE, base::BindOnce(&MessagePort::DispatchMessage, AsWeakPtr(),
+ std::move(data_buffer)));
+}
+
+void MessagePort::DispatchMessage(
+ std::unique_ptr<script::DataBuffer> data_buffer) {
+ event_target_->DispatchEvent(
+ new web::MessageEvent(base::Tokens::message(), std::move(data_buffer)));
}
} // namespace web
diff --git a/cobalt/web/message_port.h b/cobalt/web/message_port.h
index 86ff17b..183e35a 100644
--- a/cobalt/web/message_port.h
+++ b/cobalt/web/message_port.h
@@ -15,8 +15,10 @@
#ifndef COBALT_WEB_MESSAGE_PORT_H_
#define COBALT_WEB_MESSAGE_PORT_H_
+#include <memory>
#include <string>
+#include "base/callback_forward.h"
#include "base/memory/weak_ptr.h"
#include "base/message_loop/message_loop.h"
#include "cobalt/base/tokens.h"
@@ -24,6 +26,7 @@
#include "cobalt/script/sequence.h"
#include "cobalt/script/value_handle.h"
#include "cobalt/script/wrappable.h"
+#include "cobalt/web/context.h"
#include "cobalt/web/event_target.h"
#include "cobalt/web/event_target_listener_info.h"
#include "cobalt/web/message_event.h"
@@ -32,21 +35,29 @@
namespace web {
class MessagePort : public script::Wrappable,
- public base::SupportsWeakPtr<MessagePort> {
+ public base::SupportsWeakPtr<MessagePort>,
+ public Context::EnvironmentSettingsChangeObserver {
public:
explicit MessagePort(web::EventTarget* event_target);
~MessagePort();
MessagePort(const MessagePort&) = delete;
MessagePort& operator=(const MessagePort&) = delete;
+ void OnEnvironmentSettingsChanged(bool context_valid) override {
+ if (!context_valid) {
+ Close();
+ }
+ }
+
// This may help for adding support of 'object'
// void postMessage(any message, object transfer);
// -> void PostMessage(const script::ValueHandleHolder& message,
// script::Sequence<script::ValueHandle*> transfer) {}
- void PostMessage(const std::string& message);
+ void PostMessage(const script::ValueHandleHolder& message);
+ void PostMessageSerialized(std::unique_ptr<script::DataBuffer> data_buffer);
void Start() {}
- void Close() {}
+ void Close();
const web::EventTargetListenerInfo::EventListenerScriptValue* onmessage()
const {
@@ -57,9 +68,11 @@
void set_onmessage(
const web::EventTargetListenerInfo::EventListenerScriptValue&
event_listener) {
- if (event_target_)
- event_target_->SetAttributeEventListener(base::Tokens::message(),
- event_listener);
+ if (!event_target_) {
+ return;
+ }
+ event_target_->SetAttributeEventListener(base::Tokens::message(),
+ event_listener);
}
const web::EventTargetListenerInfo::EventListenerScriptValue* onmessageerror()
@@ -71,16 +84,21 @@
void set_onmessageerror(
const web::EventTargetListenerInfo::EventListenerScriptValue&
event_listener) {
- if (event_target_)
- event_target_->SetAttributeEventListener(base::Tokens::messageerror(),
- event_listener);
+ if (!event_target_) {
+ return;
+ }
+ event_target_->SetAttributeEventListener(base::Tokens::messageerror(),
+ event_listener);
}
DEFINE_WRAPPABLE_TYPE(MessagePort);
private:
+ void DispatchMessage(std::unique_ptr<script::DataBuffer> data_buffer);
+
// The event target to dispatch events to.
web::EventTarget* event_target_ = nullptr;
+ base::OnceClosure remove_environment_settings_change_observer_;
};
} // namespace web
diff --git a/cobalt/web/message_port.idl b/cobalt/web/message_port.idl
index acacae8..86b9528 100644
--- a/cobalt/web/message_port.idl
+++ b/cobalt/web/message_port.idl
@@ -16,7 +16,7 @@
// https://html.spec.whatwg.org/dev/web-messaging.html#message-ports
interface MessagePort /* : EventTarget */ {
// [RaisesException]
- void postMessage(USVString message);
+ void postMessage(any message);
// void postMessage(USVString message, sequence<USVString> transfer);
// TODO: Support sequence<object>: b/218501774
// void postMessage(any message, sequence<object> transfer);
diff --git a/cobalt/web/testing/stub_web_context.h b/cobalt/web/testing/stub_web_context.h
index f709d0e..dabc4b6 100644
--- a/cobalt/web/testing/stub_web_context.h
+++ b/cobalt/web/testing/stub_web_context.h
@@ -58,6 +58,11 @@
}
~StubWebContext() final { blob_registry_.reset(); }
+ void AddEnvironmentSettingsChangeObserver(
+ Context::EnvironmentSettingsChangeObserver* observer) final {}
+ void RemoveEnvironmentSettingsChangeObserver(
+ Context::EnvironmentSettingsChangeObserver* observer) final {}
+
// WebInstance
//
base::MessageLoop* message_loop() const final {
diff --git a/cobalt/web/window_or_worker_global_scope.cc b/cobalt/web/window_or_worker_global_scope.cc
index 26cfeff..f5a3fc3 100644
--- a/cobalt/web/window_or_worker_global_scope.cc
+++ b/cobalt/web/window_or_worker_global_scope.cc
@@ -14,7 +14,10 @@
#include "cobalt/web/window_or_worker_global_scope.h"
+#include <utility>
+
#include "cobalt/script/environment_settings.h"
+#include "cobalt/web/csp_delegate_factory.h"
#include "cobalt/web/event_target.h"
namespace cobalt {
@@ -28,12 +31,21 @@
namespace web {
WindowOrWorkerGlobalScope::WindowOrWorkerGlobalScope(
script::EnvironmentSettings* settings, StatTracker* stat_tracker,
- base::ApplicationState initial_state)
+ Options options)
// Global scope object EventTargets require special handling for onerror
// events, see EventTarget constructor for more details.
: EventTarget(settings, kUnpackOnErrorEvents),
crypto_(new Crypto()),
- window_timers_(this, stat_tracker, debugger_hooks(), initial_state) {}
+ window_timers_(this, stat_tracker, debugger_hooks(),
+ options.initial_state),
+ preflight_cache_(new loader::CORSPreflightCache()) {
+ std::unique_ptr<web::CspViolationReporter> violation_reporter(
+ new web::CspViolationReporter(this, options.post_sender));
+ csp_delegate_ = web::CspDelegateFactory::GetInstance()->Create(
+ options.csp_enforcement_mode, std::move(violation_reporter),
+ environment_settings()->creation_url(), options.require_csp,
+ options.csp_policy_changed_callback, options.csp_insecure_allowed_token);
+}
bool WindowOrWorkerGlobalScope::IsWindow() {
return GetWrappableType() == base::GetTypeId<dom::Window>();
diff --git a/cobalt/web/window_or_worker_global_scope.h b/cobalt/web/window_or_worker_global_scope.h
index 6f079ca..b2c8ea4 100644
--- a/cobalt/web/window_or_worker_global_scope.h
+++ b/cobalt/web/window_or_worker_global_scope.h
@@ -15,13 +15,17 @@
#ifndef COBALT_WEB_WINDOW_OR_WORKER_GLOBAL_SCOPE_H_
#define COBALT_WEB_WINDOW_OR_WORKER_GLOBAL_SCOPE_H_
+#include <memory>
#include <string>
#include <vector>
#include "base/logging.h"
#include "base/memory/ref_counted.h"
+#include "cobalt/loader/cors_preflight_cache.h"
#include "cobalt/script/environment_settings.h"
#include "cobalt/web/crypto.h"
+#include "cobalt/web/csp_delegate.h"
+#include "cobalt/web/csp_delegate_type.h"
#include "cobalt/web/event_target.h"
#include "cobalt/web/event_target_listener_info.h"
#include "cobalt/web/navigator_base.h"
@@ -42,9 +46,35 @@
// interfaces.
class WindowOrWorkerGlobalScope : public EventTarget {
public:
+ struct Options {
+ explicit Options(base::ApplicationState initial_state)
+ : initial_state(initial_state),
+ csp_enforcement_mode(web::kCspEnforcementEnable) {}
+
+ Options(base::ApplicationState initial_state,
+ const network_bridge::PostSender& post_sender,
+ csp::CSPHeaderPolicy require_csp,
+ web::CspEnforcementType csp_enforcement_mode,
+ base::Closure csp_policy_changed_callback,
+ int csp_insecure_allowed_token = 0)
+ : initial_state(initial_state),
+ post_sender(post_sender),
+ require_csp(require_csp),
+ csp_enforcement_mode(csp_enforcement_mode),
+ csp_policy_changed_callback(csp_policy_changed_callback),
+ csp_insecure_allowed_token(csp_insecure_allowed_token) {}
+
+ base::ApplicationState initial_state;
+ network_bridge::PostSender post_sender;
+ csp::CSPHeaderPolicy require_csp;
+ web::CspEnforcementType csp_enforcement_mode;
+ base::Closure csp_policy_changed_callback;
+ int csp_insecure_allowed_token;
+ };
+
explicit WindowOrWorkerGlobalScope(script::EnvironmentSettings* settings,
StatTracker* stat_tracker,
- base::ApplicationState initial_state);
+ Options options);
WindowOrWorkerGlobalScope(const WindowOrWorkerGlobalScope&) = delete;
WindowOrWorkerGlobalScope& operator=(const WindowOrWorkerGlobalScope&) =
delete;
@@ -68,6 +98,12 @@
return nullptr;
}
+ web::CspDelegate* csp_delegate() const { return csp_delegate_.get(); }
+
+ const scoped_refptr<loader::CORSPreflightCache> get_preflight_cache() {
+ return preflight_cache_;
+ }
+
DEFINE_WRAPPABLE_TYPE(WindowOrWorkerGlobalScope);
// Web API: WindowTimers (implements)
@@ -104,7 +140,10 @@
web::WindowTimers window_timers_;
private:
+ std::unique_ptr<web::CspDelegate> csp_delegate_;
NavigatorBase* navigator_base_ = nullptr;
+ // Global preflight cache.
+ scoped_refptr<loader::CORSPreflightCache> preflight_cache_;
};
} // namespace web
diff --git a/cobalt/websocket/web_socket.cc b/cobalt/websocket/web_socket.cc
index 13f2004..82db7a7 100644
--- a/cobalt/websocket/web_socket.cc
+++ b/cobalt/websocket/web_socket.cc
@@ -153,9 +153,9 @@
return (all_protocols.size() == sub_protocols.size());
}
-bool IsValidBinaryType(cobalt::web::MessageEvent::ResponseTypeCode code) {
- return (code == cobalt::web::MessageEvent::kBlob) ||
- (code == cobalt::web::MessageEvent::kArrayBuffer);
+bool IsValidBinaryType(cobalt::web::MessageEvent::ResponseType response_type) {
+ return (response_type == cobalt::web::MessageEvent::kBlob) ||
+ (response_type == cobalt::web::MessageEvent::kArrayBuffer);
}
} // namespace
@@ -220,12 +220,12 @@
// "arraybuffer", then set the IDL attribute to this new value.
// Otherwise, throw a SyntaxError exception."
base::StringPiece binary_type_string_piece(binary_type);
- web::MessageEvent::ResponseTypeCode response_code =
- web::MessageEvent::GetResponseTypeCode(binary_type_string_piece);
- if (!IsValidBinaryType(response_code)) {
+ web::MessageEvent::ResponseType response_type =
+ web::MessageEvent::GetResponseType(binary_type_string_piece);
+ if (!IsValidBinaryType(response_type)) {
web::DOMException::Raise(web::DOMException::kSyntaxErr, exception_state);
} else {
- binary_type_ = response_code;
+ binary_type_ = response_type;
}
}
@@ -416,12 +416,12 @@
void WebSocket::OnReceivedData(bool is_text_frame,
scoped_refptr<net::IOBufferWithSize> data) {
- web::MessageEvent::ResponseTypeCode response_type_code = binary_type_;
+ web::MessageEvent::ResponseType response_type = binary_type_;
if (is_text_frame) {
- response_type_code = web::MessageEvent::kText;
+ response_type = web::MessageEvent::kText;
}
this->DispatchEvent(
- new web::MessageEvent(base::Tokens::message(), response_type_code, data));
+ new web::MessageEvent(base::Tokens::message(), response_type, data));
}
void WebSocket::OnWriteDone(uint64_t bytes_written) {
@@ -562,18 +562,13 @@
}
web::CspDelegate* WebSocket::csp_delegate() const {
- DCHECK(settings_);
- if (!settings_) {
- return NULL;
- }
- dom::DOMSettings* dom_settings =
- base::polymorphic_downcast<dom::DOMSettings*>(settings_);
- if (dom_settings && dom_settings->window() &&
- dom_settings->window()->document()) {
- return dom_settings->window()->document()->csp_delegate();
- } else {
- return NULL;
- }
+ DCHECK(environment_settings());
+ DCHECK(environment_settings()->context());
+ DCHECK(environment_settings()->context()->GetWindowOrWorkerGlobalScope());
+ return environment_settings()
+ ->context()
+ ->GetWindowOrWorkerGlobalScope()
+ ->csp_delegate();
}
void WebSocket::Connect(const GURL& url,
diff --git a/cobalt/websocket/web_socket.h b/cobalt/websocket/web_socket.h
index 74909b7..2827dbb 100644
--- a/cobalt/websocket/web_socket.h
+++ b/cobalt/websocket/web_socket.h
@@ -201,7 +201,7 @@
// https://www.w3.org/TR/websockets/#dom-websocket-readystate
uint16 ready_state_;
// https://www.w3.org/TR/websockets/#dom-websocket-binarytype
- web::MessageEvent::ResponseTypeCode binary_type_;
+ web::MessageEvent::ResponseType binary_type_;
// https://www.w3.org/TR/websockets/#dom-websocket-extensions
std::string extensions_;
// https://www.w3.org/TR/websockets/#dom-websocket-protocol
diff --git a/cobalt/websocket/web_socket.idl b/cobalt/websocket/web_socket.idl
index d4e642c..76bb69d 100644
--- a/cobalt/websocket/web_socket.idl
+++ b/cobalt/websocket/web_socket.idl
@@ -40,7 +40,7 @@
optional DOMString reason);
// messaging
- attribute EventHandler onmessage;
+ attribute EventHandler onmessage;
[RaisesException] attribute DOMString binaryType;
[RaisesException] void send(DOMString data);
[RaisesException] void send(ArrayBuffer data);
diff --git a/cobalt/worker/client.idl b/cobalt/worker/client.idl
index fe68a12..8d2e4a9 100644
--- a/cobalt/worker/client.idl
+++ b/cobalt/worker/client.idl
@@ -19,7 +19,7 @@
readonly attribute FrameType frameType;
readonly attribute DOMString id;
readonly attribute ClientType type;
- void postMessage(USVString message);
+ void postMessage(any message);
// TODO: Support sequence<object>: b/218501774
// void postMessage(any message, sequence<object> transfer);
// TODO: Support overloads with dictionary parameter: b/218506730
diff --git a/cobalt/worker/dedicated_worker.cc b/cobalt/worker/dedicated_worker.cc
index 69b0300..0dff482 100644
--- a/cobalt/worker/dedicated_worker.cc
+++ b/cobalt/worker/dedicated_worker.cc
@@ -98,7 +98,7 @@
// void postMessage(any message, object transfer);
// -> void PostMessage(const script::ValueHandleHolder& message,
// script::Sequence<script::ValueHandle*> transfer) {}
-void DedicatedWorker::PostMessage(const std::string& message) {
+void DedicatedWorker::PostMessage(const script::ValueHandleHolder& message) {
DCHECK(worker_);
worker_->PostMessage(message);
}
diff --git a/cobalt/worker/dedicated_worker.h b/cobalt/worker/dedicated_worker.h
index 90c9547..b1264d8 100644
--- a/cobalt/worker/dedicated_worker.h
+++ b/cobalt/worker/dedicated_worker.h
@@ -47,7 +47,7 @@
// void postMessage(any message, object transfer);
// -> void PostMessage(const script::ValueHandleHolder& message,
// script::Sequence<script::ValueHandle*> transfer) {}
- void PostMessage(const std::string& message);
+ void PostMessage(const script::ValueHandleHolder& message);
const EventListenerScriptValue* onmessage() const {
return GetAttributeEventListener(base::Tokens::message());
diff --git a/cobalt/worker/dedicated_worker_global_scope.cc b/cobalt/worker/dedicated_worker_global_scope.cc
index 420dd3a..a03e8a0 100644
--- a/cobalt/worker/dedicated_worker_global_scope.cc
+++ b/cobalt/worker/dedicated_worker_global_scope.cc
@@ -72,7 +72,8 @@
}
}
-void DedicatedWorkerGlobalScope::PostMessage(const std::string& message) {
+void DedicatedWorkerGlobalScope::PostMessage(
+ const script::ValueHandleHolder& message) {
base::polymorphic_downcast<worker::WorkerSettings*>(environment_settings())
->message_port()
->PostMessage(message);
diff --git a/cobalt/worker/dedicated_worker_global_scope.h b/cobalt/worker/dedicated_worker_global_scope.h
index 6b140f5..3793608 100644
--- a/cobalt/worker/dedicated_worker_global_scope.h
+++ b/cobalt/worker/dedicated_worker_global_scope.h
@@ -52,7 +52,7 @@
void set_name(const std::string& name) { name_ = name; }
std::string name() { return name_; }
- void PostMessage(const std::string& message);
+ void PostMessage(const script::ValueHandleHolder& message);
void Close() {}
const web::EventTargetListenerInfo::EventListenerScriptValue* onmessage() {
diff --git a/cobalt/worker/dedicated_worker_global_scope.idl b/cobalt/worker/dedicated_worker_global_scope.idl
index 7f3c6a7..1b42584 100644
--- a/cobalt/worker/dedicated_worker_global_scope.idl
+++ b/cobalt/worker/dedicated_worker_global_scope.idl
@@ -20,7 +20,7 @@
] interface DedicatedWorkerGlobalScope : WorkerGlobalScope {
[Replaceable] readonly attribute DOMString name;
- void postMessage(USVString message);
+ void postMessage(any message);
// TODO: Support sequence<object>: b/218501774
// void postMessage(any message, sequence<object> transfer);
// TODO: Support overloads with dictionary parameter: b/218506730
diff --git a/cobalt/worker/service_worker.h b/cobalt/worker/service_worker.h
index 1e39dfe..a281746 100644
--- a/cobalt/worker/service_worker.h
+++ b/cobalt/worker/service_worker.h
@@ -43,7 +43,7 @@
// Web API: ServiceWorker
//
- void PostMessage(const std::string& message) {
+ void PostMessage(const script::ValueHandleHolder& message) {
DCHECK(message_port_);
if (worker_->worker_global_scope()) message_port_->PostMessage(message);
}
diff --git a/cobalt/worker/service_worker.idl b/cobalt/worker/service_worker.idl
index f76c706..b1b9602 100644
--- a/cobalt/worker/service_worker.idl
+++ b/cobalt/worker/service_worker.idl
@@ -17,7 +17,7 @@
[Exposed = (Window, ServiceWorker)] interface ServiceWorker : EventTarget {
// Todo: Implement postMessage b/219986442
- void postMessage(USVString message);
+ void postMessage(any message);
// void postMessage(any message, sequence<object> transfer);
// void postMessage(any message, optional PostMessageOptions options = {});
diff --git a/cobalt/worker/worker.cc b/cobalt/worker/worker.cc
index 495a95d..b8e283b 100644
--- a/cobalt/worker/worker.cc
+++ b/cobalt/worker/worker.cc
@@ -31,6 +31,11 @@
#include "cobalt/worker/worker_options.h"
#include "cobalt/worker/worker_settings.h"
+#include "cobalt/script/v8c/conversion_helpers.h"
+#include "cobalt/script/v8c/v8c_exception_state.h"
+#include "cobalt/script/v8c/v8c_value_handle.h"
+#include "v8/include/v8.h"
+
namespace cobalt {
namespace worker {
@@ -313,23 +318,20 @@
// TODO(b/226640425): Implement this when Message Ports can be entangled.
}
-// void postMessage(any message, object transfer);
-// -> void PostMessage(const script::ValueHandleHolder& message,
-// script::Sequence<script::ValueHandle*> transfer) {}
-void Worker::PostMessage(const std::string& message) {
+void Worker::PostMessage(const script::ValueHandleHolder& message) {
DCHECK(message_loop());
+ auto serialized_message = script::SerializeScriptValue(message);
if (base::MessageLoop::current() != message_loop()) {
// Block until the worker thread is ready to execute code to handle the
// event.
execution_ready_.Wait();
message_loop()->task_runner()->PostTask(
- FROM_HERE,
- base::BindOnce(&Worker::PostMessage, base::Unretained(this), message));
- return;
+ FROM_HERE, base::BindOnce(&web::MessagePort::PostMessageSerialized,
+ message_port()->AsWeakPtr(),
+ std::move(serialized_message)));
} else {
DCHECK(execution_ready_.IsSignaled());
- DCHECK(message_port());
- if (message_port()) message_port()->PostMessage(message);
+ message_port()->PostMessageSerialized(std::move(serialized_message));
}
}
diff --git a/cobalt/worker/worker.h b/cobalt/worker/worker.h
index fe78f28..2c488ec 100644
--- a/cobalt/worker/worker.h
+++ b/cobalt/worker/worker.h
@@ -17,6 +17,7 @@
#include <memory>
#include <string>
+#include <vector>
#include "base/bind.h"
#include "base/macros.h"
@@ -83,7 +84,7 @@
return web_agent_ ? web_agent_->message_loop() : nullptr;
}
- void PostMessage(const std::string& message);
+ void PostMessage(const script::ValueHandleHolder& message);
// From base::MessageLoop::DestructionObserver.
void WillDestroyCurrentMessageLoop() override;
diff --git a/cobalt/worker/worker.idl b/cobalt/worker/worker.idl
index b9db12b..e05669f 100644
--- a/cobalt/worker/worker.idl
+++ b/cobalt/worker/worker.idl
@@ -23,7 +23,7 @@
interface Worker : EventTarget {
void terminate();
- void postMessage(USVString message);
+ void postMessage(any message);
// TODO: Support sequence<object>: b/218501774
// void postMessage(any message, sequence<object> transfer);
// TODO: Support overloads with dictionary parameter: b/218506730
diff --git a/cobalt/worker/worker_global_scope.cc b/cobalt/worker/worker_global_scope.cc
index edc69fb..3316581 100644
--- a/cobalt/worker/worker_global_scope.cc
+++ b/cobalt/worker/worker_global_scope.cc
@@ -185,9 +185,11 @@
WorkerGlobalScope::WorkerGlobalScope(script::EnvironmentSettings* settings)
: web::WindowOrWorkerGlobalScope(
settings, /*stat_tracker=*/NULL,
- // TODO (b/233788170): once application state is
- // available, update this to use the actual state.
- base::ApplicationState::kApplicationStateStarted),
+ // Using default options for CSP
+ web::WindowOrWorkerGlobalScope::Options(
+ // TODO (b/233788170): once application state is
+ // available, update this to use the actual state.
+ base::ApplicationState::kApplicationStateStarted)),
location_(new WorkerLocation(settings->creation_url())),
navigator_(new WorkerNavigator(settings)) {
set_navigator_base(navigator_);
diff --git a/cobalt/xhr/xml_http_request.cc b/cobalt/xhr/xml_http_request.cc
index 6f16335..56de1ee 100644
--- a/cobalt/xhr/xml_http_request.cc
+++ b/cobalt/xhr/xml_http_request.cc
@@ -168,6 +168,18 @@
// 5. If request's redirect count is twenty, return a network error.
const int kRedirectLimit = 20;
+std::string ClipUrl(const GURL& url, size_t length) {
+ const std::string& spec = url.possibly_invalid_spec();
+ if (spec.size() < length) {
+ return spec;
+ }
+
+ size_t remain = length - 5;
+ size_t head = remain / 2;
+ size_t tail = remain - head;
+
+ return spec.substr(0, head) + "[...]" + spec.substr(spec.size() - tail);
+}
} // namespace
bool XMLHttpRequestImpl::verbose_ = false;
@@ -417,7 +429,7 @@
return;
}
- web::CspDelegate* csp = this->csp_delegate();
+ web::CspDelegate* csp = csp_delegate();
if (csp && !csp->CanLoad(web::CspDelegate::kXhr, request_url_, false)) {
web::DOMException::Raise(web::DOMException::kSecurityErr, exception_state);
return;
@@ -1044,7 +1056,7 @@
return;
}
// This is a redirect. Re-check the CSP.
- web::CspDelegate* csp = this->csp_delegate();
+ web::CspDelegate* csp = csp_delegate();
if (csp &&
!csp->CanLoad(web::CspDelegate::kXhr, new_url, true /* is_redirect */)) {
HandleRequestError(XMLHttpRequest::kNetworkError);
@@ -1099,11 +1111,10 @@
}
web::CspDelegate* XMLHttpRequestImpl::csp_delegate() const {
- // TODO (b/239733363): csp_delegate is currently available through window.
- // Refactor to make it available outside of window then implement this. At
- // that point, there should be no more need to override this function in
- // DOMXMLHttpRequestImpl.
- return NULL;
+ DCHECK(settings_);
+ DCHECK(settings_->context());
+ DCHECK(settings_->context()->GetWindowOrWorkerGlobalScope());
+ return settings_->context()->GetWindowOrWorkerGlobalScope()->csp_delegate();
}
void XMLHttpRequestImpl::TerminateRequest() {
@@ -1236,6 +1247,7 @@
void XMLHttpRequestImpl::StartRequest(const std::string& request_body) {
TRACK_MEMORY_SCOPE("XHR");
+ LOG(INFO) << "Fetching: " << ClipUrl(request_url_, 200);
response_array_buffer_reference_.reset();
@@ -1283,9 +1295,35 @@
url_fetcher_->AddExtraRequestHeader("Origin:" + origin_.SerializedOrigin());
}
bool dopreflight = false;
- // TODO (b/239733363): Include CORS functionality once preflight cache is
- // accessible outside of window. At that point, there should be no more need
- // to override this function in DOMXMLHttpRequestImpl.
+ if (is_cross_origin_) {
+ corspreflight_.reset(new cobalt::loader::CORSPreflight(
+ request_url_, method_, network_module,
+ base::Bind(&DOMXMLHttpRequestImpl::CORSPreflightSuccessCallback,
+ base::Unretained(this)),
+ origin_.SerializedOrigin(),
+ base::Bind(&DOMXMLHttpRequestImpl::CORSPreflightErrorCallback,
+ base::Unretained(this)),
+ settings_->context()
+ ->GetWindowOrWorkerGlobalScope()
+ ->get_preflight_cache()));
+ corspreflight_->set_headers(request_headers_);
+ // For cross-origin requests, don't send or save auth data / cookies unless
+ // withCredentials was set.
+ // To make a cross-origin request, add origin, referrer source, credentials,
+ // omit credentials flag, force preflight flag
+ if (!with_credentials_) {
+ const uint32 kDisableCookiesLoadFlags =
+ net::LOAD_NORMAL | net::LOAD_DO_NOT_SAVE_COOKIES |
+ net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SEND_AUTH_DATA;
+ url_fetcher_->SetLoadFlags(kDisableCookiesLoadFlags);
+ } else {
+ // For credentials mode: If the withCredentials attribute value is true,
+ // "include", and "same-origin" otherwise.
+ corspreflight_->set_credentials_mode_is_include(true);
+ }
+ corspreflight_->set_force_preflight(upload_listener_);
+ dopreflight = corspreflight_->Send();
+ }
DLOG_IF(INFO, verbose()) << __FUNCTION__ << *xhr_;
if (!dopreflight) {
DCHECK(settings_->context()->network_module());
@@ -1413,99 +1451,6 @@
request_url_.spec());
}
-web::CspDelegate* DOMXMLHttpRequestImpl::csp_delegate() const {
- DCHECK(settings_);
- if (settings_->window() && settings_->window()->document()) {
- return settings_->window()->document()->csp_delegate();
- } else {
- return NULL;
- }
-}
-
-void DOMXMLHttpRequestImpl::StartRequest(const std::string& request_body) {
- TRACK_MEMORY_SCOPE("XHR");
-
- response_array_buffer_reference_.reset();
-
- network::NetworkModule* network_module =
- settings_->context()->fetcher_factory()->network_module();
- url_fetcher_ = net::URLFetcher::Create(request_url_, method_, xhr_);
- ++url_fetcher_generation_;
- url_fetcher_->SetRequestContext(network_module->url_request_context_getter());
- if (fetch_callback_) {
- response_body_ = new URLFetcherResponseWriter::Buffer(
- URLFetcherResponseWriter::Buffer::kString);
- response_body_->DisablePreallocate();
- } else {
- response_body_ = new URLFetcherResponseWriter::Buffer(
- response_type_ == XMLHttpRequest::kArrayBuffer
- ? URLFetcherResponseWriter::Buffer::kArrayBuffer
- : URLFetcherResponseWriter::Buffer::kString);
- }
- std::unique_ptr<net::URLFetcherResponseWriter> download_data_writer(
- new URLFetcherResponseWriter(response_body_));
- url_fetcher_->SaveResponseWithWriter(std::move(download_data_writer));
- // Don't retry, let the caller deal with it.
- url_fetcher_->SetAutomaticallyRetryOn5xx(false);
- url_fetcher_->SetExtraRequestHeaders(request_headers_.ToString());
-
- // We want to do cors check and preflight during redirects
- url_fetcher_->SetStopOnRedirect(true);
-
- if (request_body.size()) {
- // If applicable, the request body Content-Type is already set in
- // request_headers.
- url_fetcher_->SetUploadData("", request_body);
- }
-
- // We let data url fetch resources freely but with no response headers.
- is_data_url_ = is_data_url_ || request_url_.SchemeIs("data");
- is_cross_origin_ = (is_redirect_ && is_cross_origin_) ||
- (origin_ != loader::Origin(request_url_) && !is_data_url_);
- is_redirect_ = false;
- // If the CORS flag is set, httpRequest’s method is neither `GET` nor `HEAD`
- // or httpRequest’s mode is "websocket", then append `Origin`/httpRequest’s
- // origin, serialized and UTF-8 encoded, to httpRequest’s header list.
- if (is_cross_origin_ ||
- (method_ != net::URLFetcher::GET && method_ != net::URLFetcher::HEAD)) {
- url_fetcher_->AddExtraRequestHeader("Origin:" + origin_.SerializedOrigin());
- }
- bool dopreflight = false;
- if (is_cross_origin_) {
- corspreflight_.reset(new cobalt::loader::CORSPreflight(
- request_url_, method_, network_module,
- base::Bind(&DOMXMLHttpRequestImpl::CORSPreflightSuccessCallback,
- base::Unretained(this)),
- origin_.SerializedOrigin(),
- base::Bind(&DOMXMLHttpRequestImpl::CORSPreflightErrorCallback,
- base::Unretained(this)),
- settings_->window()->get_preflight_cache()));
- corspreflight_->set_headers(request_headers_);
- // For cross-origin requests, don't send or save auth data / cookies unless
- // withCredentials was set.
- // To make a cross-origin request, add origin, referrer source, credentials,
- // omit credentials flag, force preflight flag
- if (!with_credentials_) {
- const uint32 kDisableCookiesLoadFlags =
- net::LOAD_NORMAL | net::LOAD_DO_NOT_SAVE_COOKIES |
- net::LOAD_DO_NOT_SEND_COOKIES | net::LOAD_DO_NOT_SEND_AUTH_DATA;
- url_fetcher_->SetLoadFlags(kDisableCookiesLoadFlags);
- } else {
- // For credentials mode: If the withCredentials attribute value is true,
- // "include", and "same-origin" otherwise.
- corspreflight_->set_credentials_mode_is_include(true);
- }
- corspreflight_->set_force_preflight(upload_listener_);
- dopreflight = corspreflight_->Send();
- }
- DLOG_IF(INFO, verbose()) << __FUNCTION__ << *xhr_;
- if (!dopreflight) {
- DCHECK(settings_->context()->network_module());
- StartURLFetcher(settings_->context()->network_module()->max_network_delay(),
- url_fetcher_generation_);
- }
-}
-
// https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#document-response-entity-body
scoped_refptr<dom::Document>
DOMXMLHttpRequestImpl::GetDocumentResponseEntityBody() {
diff --git a/cobalt/xhr/xml_http_request.h b/cobalt/xhr/xml_http_request.h
index e3510f0..046e90f 100644
--- a/cobalt/xhr/xml_http_request.h
+++ b/cobalt/xhr/xml_http_request.h
@@ -446,12 +446,7 @@
void GetLoadTimingInfoAndCreateResourceTiming() override;
- protected:
- web::CspDelegate* csp_delegate() const override;
-
private:
- void StartRequest(const std::string& request_body) override;
-
scoped_refptr<dom::Document> GetDocumentResponseEntityBody();
void XMLDecoderLoadCompleteCallback(
diff --git a/docker-compose.yml b/docker-compose.yml
index 1f5f4e3..08f9df6 100644
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -40,6 +40,18 @@
IS_DOCKER: 1
PYTHONPATH: /code
+x-shared-docsite-definitions: &shared-docsite-definitions
+ <<: *build-common-definitions
+ build:
+ context: ./docker/docsite
+ dockerfile: Dockerfile
+ args:
+ - USER=root
+ - UID=2000
+ - GID=2000
+ environment:
+ <<: *shared-build-env
+
x-shared-unittest-definitions: &shared-unittest-definitions
stdin_open: true
tty: true
@@ -125,6 +137,18 @@
- base-bionic
scale: 0
+ docsite:
+ <<: *shared-docsite-definitions
+ image: cobalt-build-docsite
+ ports:
+ # The docsite webapp runs on port 4000.
+ - "4000:4000"
+
+ docsite-deploy:
+ <<: *shared-docsite-definitions
+ image: cobalt-build-docsite-deploy
+ entrypoint: ["/code/third_party/repo-publishing-toolkit-local/preview-site.sh", "deploy"]
+
stub:
<<: *build-common-definitions
build:
@@ -148,7 +172,7 @@
<<: *shared-build-env
PLATFORM: linux-x64x11
CONFIG: ${CONFIG:-debug}
- TARGET: ${TARGET:-cobalt_deploy}
+ TARGET: ${TARGET:-cobalt_install}
linux-x64x11-bionic:
<<: *common-definitions
diff --git a/docker/docsite/Dockerfile b/docker/docsite/Dockerfile
index fc278cc..02b4681 100644
--- a/docker/docsite/Dockerfile
+++ b/docker/docsite/Dockerfile
@@ -12,7 +12,8 @@
# See the License for the specific language governing permissions and
# limitations under the License.
-FROM ruby:2.7-buster
+ARG FROM_IMAGE
+FROM ${FROM_IMAGE:-cobalt-build-base}
ARG USER
ARG UID
@@ -20,14 +21,13 @@
RUN apt update -qqy \
&& apt install -qqy --no-install-recommends \
+ build-essential \
bundler \
doxygen \
git \
- nodejs \
- python \
- # Required for GN build.
- python3 \
- python3-requests \
+ python-pygments \
+ ruby2.5-dev \
+ ruby-execjs \
&& apt-get clean autoclean \
&& apt-get autoremove -y --purge \
&& rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* \
@@ -37,27 +37,19 @@
RUN bundle install --gemfile=/app/Gemfile
-# === Get GN via CIPD
-ARG GN_SHA256SUM="af7b2dcb3905bca56655e12131b365f1cba8e159db80d2022330c4f522fab2ef /tmp/gn.zip"
-ARG GN_HASH=r3styzkFvKVmVeEhMbNl8cuo4VnbgNICIzDE9SL6su8C
-
-RUN curl --location --silent --output /tmp/gn.zip \
- "https://chrome-infra-packages.appspot.com/dl/gn/gn/linux-amd64/+/${GN_HASH}" \
- && echo ${GN_SHA256SUM} | sha256sum --check \
- && unzip /tmp/gn.zip -d /usr/local/bin \
- && rm /tmp/gn.zip
-
# We create and use a non-root user explicitly so that the generated and
# modified files maintain the same permissions as the user that launched the
# Docker container.
RUN addgroup --group --gid "${GID}" defaultgroup \
- && adduser --disabled-password --gecos '' --uid "${UID}" --gid "${GID}" ${USER:-defaultuser}
+ && adduser --disabled-password --gecos '' --uid "${UID}" --gid "${GID}" defaultuser
-# Allow the new uses to run gn and create a descriptive out directory.
+# The new user must be able to execute gn.
RUN chmod a+x /usr/local/bin/gn
+
+# Create an out directory with a descriptive name for gn.
RUN mkdir /project_out_dir \
&& chown ${USER:-defaultuser}:defaultgroup /project_out_dir
USER ${USER:-defaultuser}
-CMD /cobalt/third_party/repo-publishing-toolkit-local/preview-site.sh
+CMD /code/third_party/repo-publishing-toolkit-local/preview-site.sh run
diff --git a/docker/docsite/README.md b/docker/docsite/README.md
index 06ea6fc..58177d1 100644
--- a/docker/docsite/README.md
+++ b/docker/docsite/README.md
@@ -4,25 +4,14 @@
the current working directory, which should be the root of the Cobalt
repository, if that environment variable is not set.
-When the `docsite` service is run, the container will then host the updated
-cobalt.dev site locally on port `4000`.
+When the `docsite` service is run, the container will generate the site and host
+the updated cobalt.dev site locally on port `4000`.
-When the `docsite-build-only` service is run, the container will build and
+When the `docsite-deploy` service is run, the container will build and
output the site content in the directory `out/deploy/www` at the root of the
Cobalt directory, and copy the app.yaml deployable into `out/deploy`.
# How To Run
-docker-compose build --build-arg UID=$(id -u) --build-arg GID=$(id -g) SERVICE
+docker-compose build --no-cache --build-arg USER=defaultuser --build-arg UID=$(id -u) --build-arg GID=$(id -g) SERVICE
docker-compose up SERVICE
-
-# Notes
-
-A separate docker-compose.yml was created due to the root docker-compose.yml
-being unable to locate the Gemfile in the Docker build context.
-
-The Gemfile was copied from third_party/repo-publishing-toolkit/Gemfile because
-we need to run `bundle install` with elevated permissions but if we let the
-`preview-site.sh`, which normally installs gems, run with elevated permissions
-the resulting files added or modified would not be accessible to the user who
-ran the Docker container.
diff --git a/docker/docsite/docker-compose.yml b/docker/docsite/docker-compose.yml
deleted file mode 100644
index 02e0aa5..0000000
--- a/docker/docsite/docker-compose.yml
+++ /dev/null
@@ -1,40 +0,0 @@
-# Copyright 2021 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.
-
-version: '2.4'
-
-services:
- docsite:
- build:
- context: .
- dockerfile: Dockerfile
- container_name: docsite
- environment:
- - IS_DOCKER=1
- - PYTHONPATH=/cobalt
- ports:
- - "4000:4000"
- volumes:
- # We use ../../ when the environment variable COBALT_SRC is not set since
- # this file is located two directories under the root of the repository.
- - ${COBALT_SRC:-../../}:/cobalt/
-
- docsite-build-only:
- container_name: docsite-build-only
- environment:
- # SITE_DST specifies where the files required to deploy the site should be
- # placed, and by default this is under the "out" directory.
- - SITE_DST=${SITE_DST:-/cobalt/out/deploy/www}
- extends:
- service: docsite
diff --git a/docker/linux/base/Dockerfile b/docker/linux/base/Dockerfile
index 84368e4..50dd9e0 100644
--- a/docker/linux/base/Dockerfile
+++ b/docker/linux/base/Dockerfile
@@ -27,6 +27,7 @@
python3-pip \
python3-requests \
python3-setuptools \
+ python3-six \
git ccache \
curl xz-utils \
&& /opt/clean-after-apt.sh
diff --git a/net/disk_cache/cobalt/cobalt_backend_impl.cc b/net/disk_cache/cobalt/cobalt_backend_impl.cc
index 76c845a..8f58f6d 100644
--- a/net/disk_cache/cobalt/cobalt_backend_impl.cc
+++ b/net/disk_cache/cobalt/cobalt_backend_impl.cc
@@ -54,13 +54,34 @@
}
void ReadDiskCacheSize(
- cobalt::persistent_storage::PersistentSettings* settings) {
+ cobalt::persistent_storage::PersistentSettings* settings,
+ int64_t max_bytes) {
+ auto total_size = 0;
+ disk_cache::ResourceTypeMetadata kTypeMetadataNew[disk_cache::kTypeCount];
+
for (int i = 0; i < disk_cache::kTypeCount; i++) {
auto metadata = disk_cache::kTypeMetadata[i];
uint32_t bucket_size =
static_cast<uint32_t>(settings->GetPersistentSettingAsDouble(
metadata.directory, metadata.max_size_bytes));
- disk_cache::kTypeMetadata[i] = {metadata.directory, bucket_size};
+ kTypeMetadataNew[i] = {metadata.directory, bucket_size};
+
+ total_size += bucket_size;
+ }
+
+ // Check if PersistentSettings values are valid and can replace the disk_cache::kTypeMetadata.
+ if (total_size <= max_bytes) {
+ std::copy(std::begin(kTypeMetadataNew), std::end(kTypeMetadataNew), std::begin(disk_cache::kTypeMetadata));
+ return;
+ }
+
+ // PersistentSettings values are invalid and will be replaced by the default values in
+ // disk_cache::kTypeMetadata.
+ for (int i = 0; i < disk_cache::kTypeCount; i++) {
+ auto metadata = disk_cache::kTypeMetadata[i];
+ settings->SetPersistentSetting(
+ metadata.directory,
+ std::make_unique<base::Value>(static_cast<double>(metadata.max_size_bytes)));
}
}
@@ -76,7 +97,7 @@
persistent_settings_ =
std::make_unique<cobalt::persistent_storage::PersistentSettings>(
kPersistentSettingsJson, base::MessageLoop::current()->task_runner());
- ReadDiskCacheSize(persistent_settings_.get());
+ ReadDiskCacheSize(persistent_settings_.get(), max_bytes);
// Initialize disk backend for each resource type.
int64_t total_size = 0;
diff --git a/net/disk_cache/cobalt/resource_type.h b/net/disk_cache/cobalt/resource_type.h
index b6b5cc7..60421ba 100644
--- a/net/disk_cache/cobalt/resource_type.h
+++ b/net/disk_cache/cobalt/resource_type.h
@@ -37,13 +37,13 @@
uint32_t max_size_bytes;
};
-static uint32_t kInitialBytes = 3 * 1024 * 1024;
+static uint32_t kInitialBytes = static_cast<uint32_t> (3 * 1024 * 1024);
// These values are updated on start up in application.cc, using the
// persisted values saved in settings.json.
static ResourceTypeMetadata kTypeMetadata[] = {
{"other", kInitialBytes}, {"html", kInitialBytes},
{"css", kInitialBytes}, {"image", kInitialBytes},
- {"font", kInitialBytes}, {"splash", kInitialBytes},
+ {"font", kInitialBytes}, {"splash", 2 * 1024 * 1024},
{"uncompiled_js", kInitialBytes}, {"compiled_js", kInitialBytes},
};
diff --git a/net/http/http_cache_transaction.cc b/net/http/http_cache_transaction.cc
index da934ee..9f13b95 100644
--- a/net/http/http_cache_transaction.cc
+++ b/net/http/http_cache_transaction.cc
@@ -13,6 +13,7 @@
#include <algorithm>
#include <string>
#include <utility>
+#include <vector>
#include "base/auto_reset.h"
#include "base/bind.h"
@@ -61,6 +62,15 @@
namespace {
+#if defined(STARBOARD)
+// Default allowlist based off MIME types associated with top
+// resource types defined in resource_type.h.
+static const char* const kMimeTypesCacheAllowlist[] = {
+ "text/html", "text/css", "image/gif", "image/jpeg",
+ "image/png", "image/svg+xml", "image/webp", "font/otf",
+ "font/ttf", "font/woff", "font/woff2", "text/javascript"};
+#endif
+
constexpr TimeDelta kStaleRevalidateTimeout = TimeDelta::FromSeconds(60);
// From http://tools.ietf.org/html/draft-ietf-httpbis-p6-cache-21#section-6
@@ -3070,7 +3080,27 @@
// (even though the cert status contains the actual errors) and no SSL
// blocking page is shown. An alternative would be to reverse-map the cert
// status to a net error and replay the net error.
- if ((response_.headers->HasHeaderValue("cache-control", "no-store")) ||
+
+#if defined(STARBOARD)
+ // Only allow caching for specific mime types.
+ std::string mime_type;
+ response_.headers->GetMimeType(&mime_type);
+ // TODO(b/243727663): Empty mime types should not get cached either.
+ bool is_allowed_mime_type = mime_type.empty();
+ if (!is_allowed_mime_type) {
+ for (auto allowed_type : kMimeTypesCacheAllowlist) {
+ if (mime_type.compare(allowed_type) == 0) {
+ is_allowed_mime_type = true;
+ break;
+ }
+ }
+ }
+#else
+ bool is_allowed_mime_type = true;
+#endif
+
+ if (!is_allowed_mime_type ||
+ (response_.headers->HasHeaderValue("cache-control", "no-store")) ||
IsCertStatusError(response_.ssl_info.cert_status)) {
bool stopped = StopCachingImpl(false);
DCHECK(stopped);
diff --git a/net/test/embedded_test_server/default_handlers.cc b/net/test/embedded_test_server/default_handlers.cc
index 06eeb1d..f8ca3c5 100644
--- a/net/test/embedded_test_server/default_handlers.cc
+++ b/net/test/embedded_test_server/default_handlers.cc
@@ -102,7 +102,12 @@
http_response->AddCustomHeader("Vary", vary);
http_response->set_content(content);
+#if defined(STARBOARD)
+ // Cobalt does not currently support text/plain caching.
+ http_response->set_content_type("text/html");
+#else
http_response->set_content_type("text/plain");
+#endif
http_response->AddCustomHeader("Cache-Control", cache_control);
return std::move(http_response);
}
diff --git a/starboard/android/shared/audio_renderer_passthrough.cc b/starboard/android/shared/audio_renderer_passthrough.cc
index b2f7671..7056e8d 100644
--- a/starboard/android/shared/audio_renderer_passthrough.cc
+++ b/starboard/android/shared/audio_renderer_passthrough.cc
@@ -349,7 +349,16 @@
SbTime playback_time =
seek_to_time_ + playback_head_position * kSbTimeSecond /
audio_sample_info_.samples_per_second;
- if (paused_ || playback_rate_ == 0.0) {
+
+ // When underlying AudioTrack is paused, we use returned playback time
+ // directly. Note that we should not use |paused_| or |playback_rate_| here.
+ // As we sync audio sink state on |audio_track_thread_|, when |paused_| is set
+ // to false, the underlying AudioTrack may still be paused. In that case, the
+ // returned playback time and last frame consumed time would be out of date.
+ // For example, when resume the playback, if we call GetAudioTimestamp()
+ // before calling AudioTrack.Play(), the returned playback time and last frame
+ // consumed time would be the same as at when we pause the video.
+ if (audio_track_paused_) {
return playback_time;
}
@@ -358,6 +367,10 @@
SB_LOG_IF(WARNING, now < updated_at)
<< "now (" << now << ") is not greater than updated_at (" << updated_at
<< ").";
+ SB_LOG_IF(WARNING, now - updated_at > kSbTimeSecond)
+ << "Elapsed time (" << now - updated_at
+ << ") is greater than 1s. (playback_time " << playback_time << ")";
+
playback_time += std::max<SbTime>(now - updated_at, 0);
return playback_time;
@@ -469,11 +482,13 @@
if (previous_state.playing() != current_state.playing()) {
if (current_state.playing()) {
audio_track_bridge_->Play();
+ audio_track_paused_ = false;
SB_LOG(INFO) << "Played on AudioTrack thread.";
ScopedLock scoped_lock(mutex_);
stop_called_ = false;
} else {
audio_track_bridge_->Pause();
+ audio_track_paused_ = true;
SB_LOG(INFO) << "Paused on AudioTrack thread.";
}
}
diff --git a/starboard/android/shared/audio_renderer_passthrough.h b/starboard/android/shared/audio_renderer_passthrough.h
index 58a073c..2b96d52 100644
--- a/starboard/android/shared/audio_renderer_passthrough.h
+++ b/starboard/android/shared/audio_renderer_passthrough.h
@@ -15,6 +15,7 @@
#ifndef STARBOARD_ANDROID_SHARED_AUDIO_RENDERER_PASSTHROUGH_H_
#define STARBOARD_ANDROID_SHARED_AUDIO_RENDERER_PASSTHROUGH_H_
+#include <atomic>
#include <memory>
#include <queue>
@@ -137,6 +138,8 @@
JobToken update_status_and_write_data_token_;
int64_t total_frames_written_on_audio_track_thread_ = 0;
+ std::atomic_bool audio_track_paused_{true};
+
std::unique_ptr<JobThread> audio_track_thread_;
std::unique_ptr<AudioTrackBridge> audio_track_bridge_;
};
diff --git a/starboard/contrib/linux/stadia/main.cc b/starboard/contrib/linux/stadia/main.cc
index ae44e9f..77edff2 100644
--- a/starboard/contrib/linux/stadia/main.cc
+++ b/starboard/contrib/linux/stadia/main.cc
@@ -33,10 +33,12 @@
#if SB_IS(EVERGREEN_COMPATIBLE)
if (starboard::shared::starboard::CommandLine(argc, argv)
- .HasSwitch(starboard::shared::starboard::kStartHandlerAtCrash)) {
- third_party::crashpad::wrapper::InstallCrashpadHandler(true);
- } else {
+ .HasSwitch(starboard::shared::starboard::kStartHandlerAtLaunch) &&
+ !starboard::shared::starboard::CommandLine(argc, argv)
+ .HasSwitch(starboard::shared::starboard::kStartHandlerAtCrash)) {
third_party::crashpad::wrapper::InstallCrashpadHandler(false);
+ } else {
+ third_party::crashpad::wrapper::InstallCrashpadHandler(true);
}
#endif
diff --git a/starboard/elf_loader/exported_symbols.cc b/starboard/elf_loader/exported_symbols.cc
index f5282ef..d7c3684 100644
--- a/starboard/elf_loader/exported_symbols.cc
+++ b/starboard/elf_loader/exported_symbols.cc
@@ -60,11 +60,42 @@
namespace elf_loader {
ExportedSymbols::ExportedSymbols() {
+ REGISTER_SYMBOL(kSbDefaultMmapThreshold);
+ REGISTER_SYMBOL(kSbFileAltSepChar);
+ REGISTER_SYMBOL(kSbFileAltSepString);
+ REGISTER_SYMBOL(kSbFileMaxName);
+ REGISTER_SYMBOL(kSbFileMaxOpen);
+ REGISTER_SYMBOL(kSbFileMaxPath);
+ REGISTER_SYMBOL(kSbFileSepChar);
+ REGISTER_SYMBOL(kSbFileSepString);
+ REGISTER_SYMBOL(kSbHasAc3Audio);
+ REGISTER_SYMBOL(kSbHasMediaWebmVp9Support);
+ REGISTER_SYMBOL(kSbHasThreadPrioritySupport);
+ REGISTER_SYMBOL(kSbMallocAlignment);
+#if SB_API_VERSION >= 14
+ REGISTER_SYMBOL(kSbMaxSystemPathCacheDirectorySize);
+#endif // SB_API_VERSION >= 14
+ REGISTER_SYMBOL(kSbMaxThreadLocalKeys);
+ REGISTER_SYMBOL(kSbMaxThreadNameLength);
+ REGISTER_SYMBOL(kSbMaxThreads);
+ REGISTER_SYMBOL(kSbMediaMaxAudioBitrateInBitsPerSecond);
+ REGISTER_SYMBOL(kSbMediaMaxVideoBitrateInBitsPerSecond);
+ REGISTER_SYMBOL(kSbMediaVideoFrameAlignment);
+ REGISTER_SYMBOL(kSbMemoryLogPath);
+ REGISTER_SYMBOL(kSbMemoryPageSize);
+ REGISTER_SYMBOL(kSbNetworkReceiveBufferSize);
+ REGISTER_SYMBOL(kSbPathSepChar);
+ REGISTER_SYMBOL(kSbPathSepString);
+ REGISTER_SYMBOL(kSbPreferredRgbaByteOrder);
+ REGISTER_SYMBOL(kSbUserMaxSignedIn);
+ REGISTER_SYMBOL(SbAccessibilityGetCaptionSettings);
REGISTER_SYMBOL(SbAccessibilityGetDisplaySettings);
REGISTER_SYMBOL(SbAccessibilityGetTextToSpeechSettings);
+ REGISTER_SYMBOL(SbAccessibilitySetCaptionsEnabled);
REGISTER_SYMBOL(SbAudioSinkCreate);
REGISTER_SYMBOL(SbAudioSinkDestroy);
REGISTER_SYMBOL(SbAudioSinkGetMaxChannels);
+ REGISTER_SYMBOL(SbAudioSinkGetMinBufferSizeInFrames);
REGISTER_SYMBOL(SbAudioSinkGetNearestSupportedSampleFrequency);
REGISTER_SYMBOL(SbAudioSinkIsAudioFrameStorageTypeSupported);
REGISTER_SYMBOL(SbAudioSinkIsAudioSampleTypeSupported);
@@ -90,6 +121,7 @@
REGISTER_SYMBOL(SbConditionVariableSignal);
REGISTER_SYMBOL(SbConditionVariableWait);
REGISTER_SYMBOL(SbConditionVariableWaitTimed);
+ REGISTER_SYMBOL(SbCPUFeaturesGet);
REGISTER_SYMBOL(SbDecodeTargetGetInfo);
REGISTER_SYMBOL(SbDecodeTargetRelease);
REGISTER_SYMBOL(SbDirectoryCanOpen);
@@ -109,9 +141,12 @@
REGISTER_SYMBOL(SbDrmDestroySystem);
REGISTER_SYMBOL(SbDrmGenerateSessionUpdateRequest);
REGISTER_SYMBOL(SbDrmGetMetrics);
+ REGISTER_SYMBOL(SbDrmIsServerCertificateUpdatable);
+ REGISTER_SYMBOL(SbDrmUpdateServerCertificate);
REGISTER_SYMBOL(SbDrmUpdateSession);
REGISTER_SYMBOL(SbEventCancel);
REGISTER_SYMBOL(SbEventSchedule);
+ REGISTER_SYMBOL(SbFileAtomicReplace);
REGISTER_SYMBOL(SbFileCanOpen);
REGISTER_SYMBOL(SbFileClose);
REGISTER_SYMBOL(SbFileDelete);
@@ -125,19 +160,8 @@
REGISTER_SYMBOL(SbFileSeek);
REGISTER_SYMBOL(SbFileTruncate);
REGISTER_SYMBOL(SbFileWrite);
- REGISTER_SYMBOL(SbMediaGetAudioConfiguration);
- REGISTER_SYMBOL(SbMediaGetAudioOutputCount);
-#if SB_API_VERSION < 13
- REGISTER_SYMBOL(SbMediaIsSupported);
-#endif // SB_API_VERSION < 13
- REGISTER_SYMBOL(SbMemoryAllocate);
- REGISTER_SYMBOL(SbMemoryAllocateAligned);
- REGISTER_SYMBOL(SbMemoryAllocateNoReport);
- REGISTER_SYMBOL(SbMemoryDeallocate);
- REGISTER_SYMBOL(SbMemoryDeallocateAligned);
- REGISTER_SYMBOL(SbMemoryDeallocateNoReport);
- REGISTER_SYMBOL(SbMemoryReallocate);
- REGISTER_SYMBOL(SbMemorySetReporter);
+ REGISTER_SYMBOL(SbGetEglInterface);
+ REGISTER_SYMBOL(SbGetGlesInterface);
REGISTER_SYMBOL(SbImageDecode);
REGISTER_SYMBOL(SbImageIsDecodeSupported);
REGISTER_SYMBOL(SbLog);
@@ -148,23 +172,64 @@
REGISTER_SYMBOL(SbLogRawDumpStack);
REGISTER_SYMBOL(SbLogRawFormat);
REGISTER_SYMBOL(SbMediaCanPlayMimeAndKeySystem);
+ REGISTER_SYMBOL(SbMediaGetAudioBufferBudget);
+ REGISTER_SYMBOL(SbMediaGetAudioConfiguration);
+ REGISTER_SYMBOL(SbMediaGetAudioOutputCount);
+ REGISTER_SYMBOL(SbMediaGetBufferAlignment);
+ REGISTER_SYMBOL(SbMediaGetBufferAllocationUnit);
+ REGISTER_SYMBOL(SbMediaGetBufferGarbageCollectionDurationThreshold);
+ REGISTER_SYMBOL(SbMediaGetBufferPadding);
+ REGISTER_SYMBOL(SbMediaGetBufferStorageType);
+ REGISTER_SYMBOL(SbMediaGetInitialBufferCapacity);
+ REGISTER_SYMBOL(SbMediaGetMaxBufferCapacity);
+ REGISTER_SYMBOL(SbMediaGetProgressiveBufferBudget);
+ REGISTER_SYMBOL(SbMediaGetVideoBufferBudget);
+ REGISTER_SYMBOL(SbMediaIsBufferPoolAllocateOnDemand);
+ REGISTER_SYMBOL(SbMediaIsBufferUsingMemoryPool);
+#if SB_API_VERSION < 13
+ REGISTER_SYMBOL(SbMediaIsSupported);
+#endif // SB_API_VERSION < 13
+ REGISTER_SYMBOL(SbMediaSetAudioWriteDuration);
+ REGISTER_SYMBOL(SbMemoryAllocate);
+ REGISTER_SYMBOL(SbMemoryAllocateAligned);
REGISTER_SYMBOL(SbMemoryAllocateAlignedUnchecked);
+ REGISTER_SYMBOL(SbMemoryAllocateNoReport);
REGISTER_SYMBOL(SbMemoryAllocateUnchecked);
#if SB_API_VERSION < 13
REGISTER_SYMBOL(SbMemoryCompare);
REGISTER_SYMBOL(SbMemoryCopy);
+#endif
+ REGISTER_SYMBOL(SbMemoryDeallocate);
+ REGISTER_SYMBOL(SbMemoryDeallocateAligned);
+ REGISTER_SYMBOL(SbMemoryDeallocateNoReport);
+#if SB_API_VERSION < 13
REGISTER_SYMBOL(SbMemoryFindByte);
#endif
+#if SB_CAN(MAP_EXECUTABLE_MEMORY)
+ REGISTER_SYMBOL(SbMemoryFlush);
+#endif // SB_CAN(MAP_EXECUTABLE_MEMORY)
REGISTER_SYMBOL(SbMemoryFree);
REGISTER_SYMBOL(SbMemoryFreeAligned);
REGISTER_SYMBOL(SbMemoryGetStackBounds);
+ REGISTER_SYMBOL(SbMemoryMap);
#if SB_API_VERSION < 13
REGISTER_SYMBOL(SbMemoryMove);
#endif
+ REGISTER_SYMBOL(SbMemoryProtect);
+ REGISTER_SYMBOL(SbMemoryReallocate);
REGISTER_SYMBOL(SbMemoryReallocateUnchecked);
#if SB_API_VERSION < 13
REGISTER_SYMBOL(SbMemorySet);
#endif
+ REGISTER_SYMBOL(SbMemorySetReporter);
+ REGISTER_SYMBOL(SbMemoryUnmap);
+ REGISTER_SYMBOL(SbMicrophoneClose);
+ REGISTER_SYMBOL(SbMicrophoneCreate);
+ REGISTER_SYMBOL(SbMicrophoneDestroy);
+ REGISTER_SYMBOL(SbMicrophoneGetAvailable);
+ REGISTER_SYMBOL(SbMicrophoneIsSampleRateSupported);
+ REGISTER_SYMBOL(SbMicrophoneOpen);
+ REGISTER_SYMBOL(SbMicrophoneRead);
REGISTER_SYMBOL(SbMutexAcquire);
REGISTER_SYMBOL(SbMutexAcquireTry);
REGISTER_SYMBOL(SbMutexCreate);
@@ -174,10 +239,15 @@
REGISTER_SYMBOL(SbPlayerCreate);
REGISTER_SYMBOL(SbPlayerDestroy);
REGISTER_SYMBOL(SbPlayerGetCurrentFrame);
+ REGISTER_SYMBOL(SbPlayerGetInfo2);
+ REGISTER_SYMBOL(SbPlayerGetMaximumNumberOfSamplesPerWrite);
+ REGISTER_SYMBOL(SbPlayerGetPreferredOutputMode);
+ REGISTER_SYMBOL(SbPlayerSeek2);
REGISTER_SYMBOL(SbPlayerSetBounds);
REGISTER_SYMBOL(SbPlayerSetPlaybackRate);
REGISTER_SYMBOL(SbPlayerSetVolume);
REGISTER_SYMBOL(SbPlayerWriteEndOfStream);
+ REGISTER_SYMBOL(SbPlayerWriteSample2);
REGISTER_SYMBOL(SbSocketAccept);
REGISTER_SYMBOL(SbSocketBind);
REGISTER_SYMBOL(SbSocketClearLastError);
@@ -190,6 +260,7 @@
REGISTER_SYMBOL(SbSocketGetLocalAddress);
REGISTER_SYMBOL(SbSocketIsConnected);
REGISTER_SYMBOL(SbSocketIsConnectedAndIdle);
+ REGISTER_SYMBOL(SbSocketIsIpv6Supported);
REGISTER_SYMBOL(SbSocketJoinMulticastGroup);
REGISTER_SYMBOL(SbSocketListen);
REGISTER_SYMBOL(SbSocketReceiveFrom);
@@ -209,6 +280,17 @@
REGISTER_SYMBOL(SbSocketWaiterWait);
REGISTER_SYMBOL(SbSocketWaiterWaitTimed);
REGISTER_SYMBOL(SbSocketWaiterWakeUp);
+#if SB_API_VERSION == 12
+ REGISTER_SYMBOL(SbSpeechRecognizerCancel);
+ REGISTER_SYMBOL(SbSpeechRecognizerCreate);
+ REGISTER_SYMBOL(SbSpeechRecognizerDestroy);
+ REGISTER_SYMBOL(SbSpeechRecognizerIsSupported);
+ REGISTER_SYMBOL(SbSpeechRecognizerStart);
+ REGISTER_SYMBOL(SbSpeechRecognizerStop);
+#endif // SB_API_VERSION == 12
+ REGISTER_SYMBOL(SbSpeechSynthesisCancel);
+ REGISTER_SYMBOL(SbSpeechSynthesisIsSupported);
+ REGISTER_SYMBOL(SbSpeechSynthesisSpeak);
REGISTER_SYMBOL(SbStorageCloseRecord);
REGISTER_SYMBOL(SbStorageDeleteRecord);
REGISTER_SYMBOL(SbStorageGetRecordSize);
@@ -255,9 +337,11 @@
#endif
REGISTER_SYMBOL(SbSystemGetDeviceType);
REGISTER_SYMBOL(SbSystemGetErrorString);
+ REGISTER_SYMBOL(SbSystemGetExtension);
REGISTER_SYMBOL(SbSystemGetLastError);
REGISTER_SYMBOL(SbSystemGetLocaleId);
REGISTER_SYMBOL(SbSystemGetNumberOfProcessors);
+ REGISTER_SYMBOL(SbSystemGetPath);
REGISTER_SYMBOL(SbSystemGetProperty);
REGISTER_SYMBOL(SbSystemGetRandomData);
REGISTER_SYMBOL(SbSystemGetRandomUInt64);
@@ -269,26 +353,35 @@
REGISTER_SYMBOL(SbSystemHasCapability);
REGISTER_SYMBOL(SbSystemHideSplashScreen);
REGISTER_SYMBOL(SbSystemIsDebuggerAttached);
+#if SB_API_VERSION >= 13
+ REGISTER_SYMBOL(SbSystemNetworkIsDisconnected);
+#endif // SB_API_VERSION >= 13
REGISTER_SYMBOL(SbSystemRaisePlatformError);
#if SB_API_VERSION >= 13
REGISTER_SYMBOL(SbSystemRequestBlur);
REGISTER_SYMBOL(SbSystemRequestConceal);
REGISTER_SYMBOL(SbSystemRequestFocus);
REGISTER_SYMBOL(SbSystemRequestFreeze);
+#endif // SB_API_VERSION >= 13
+#if SB_API_VERSION < 13
+ REGISTER_SYMBOL(SbSystemRequestPause);
+#endif // SB_API_VERSION < 13
+#if SB_API_VERSION >= 13
REGISTER_SYMBOL(SbSystemRequestReveal);
REGISTER_SYMBOL(SbSystemRequestStop);
-#else
- REGISTER_SYMBOL(SbSystemRequestPause);
+#endif // SB_API_VERSION >= 13
+#if SB_API_VERSION < 13
REGISTER_SYMBOL(SbSystemRequestStop);
REGISTER_SYMBOL(SbSystemRequestSuspend);
REGISTER_SYMBOL(SbSystemRequestUnpause);
-#endif // SB_API_VERSION >= 13
-
+#endif // SB_API_VERSION < 13
+ REGISTER_SYMBOL(SbSystemSignWithCertificationSecretKey);
#if SB_API_VERSION < 13
REGISTER_SYMBOL(SbSystemSort);
#endif // SB_API_VERSION < 13
-
+ REGISTER_SYMBOL(SbSystemSupportsResume);
REGISTER_SYMBOL(SbSystemSymbolize);
+ REGISTER_SYMBOL(SbThreadContextGetPointer);
REGISTER_SYMBOL(SbThreadCreate);
REGISTER_SYMBOL(SbThreadCreateLocalKey);
REGISTER_SYMBOL(SbThreadDestroyLocalKey);
@@ -299,134 +392,42 @@
REGISTER_SYMBOL(SbThreadGetName);
REGISTER_SYMBOL(SbThreadIsEqual);
REGISTER_SYMBOL(SbThreadJoin);
- REGISTER_SYMBOL(SbThreadSetLocalValue);
- REGISTER_SYMBOL(SbThreadSetName);
- REGISTER_SYMBOL(SbThreadSleep);
- REGISTER_SYMBOL(SbThreadYield);
- REGISTER_SYMBOL(SbTimeGetMonotonicNow);
- REGISTER_SYMBOL(SbTimeGetNow);
- REGISTER_SYMBOL(SbTimeZoneGetCurrent);
- REGISTER_SYMBOL(SbTimeZoneGetName);
- REGISTER_SYMBOL(SbUserGetCurrent);
- REGISTER_SYMBOL(SbUserGetProperty);
- REGISTER_SYMBOL(SbUserGetPropertySize);
- REGISTER_SYMBOL(SbUserGetSignedIn);
- REGISTER_SYMBOL(SbWindowCreate);
- REGISTER_SYMBOL(SbWindowDestroy);
- REGISTER_SYMBOL(SbWindowGetPlatformHandle);
- REGISTER_SYMBOL(SbWindowGetSize);
- REGISTER_SYMBOL(SbWindowSetDefaultOptions);
- REGISTER_SYMBOL(SbSystemGetPath);
- REGISTER_SYMBOL(SbGetEglInterface);
- REGISTER_SYMBOL(SbGetGlesInterface);
- REGISTER_SYMBOL(SbFileAtomicReplace);
-
-#if SB_CAN(MAP_EXECUTABLE_MEMORY)
- REGISTER_SYMBOL(SbMemoryFlush);
-#endif // SB_CAN(MAP_EXECUTABLE_MEMORY)
-
- REGISTER_SYMBOL(SbPlayerGetPreferredOutputMode);
- REGISTER_SYMBOL(SbMemoryMap);
- REGISTER_SYMBOL(SbMemoryUnmap);
- REGISTER_SYMBOL(SbMemoryProtect);
- REGISTER_SYMBOL(SbUiNavGetInterface);
- REGISTER_SYMBOL(SbWindowBlurOnScreenKeyboard);
- REGISTER_SYMBOL(SbWindowFocusOnScreenKeyboard);
- REGISTER_SYMBOL(SbWindowGetOnScreenKeyboardBoundingRect);
- REGISTER_SYMBOL(SbWindowHideOnScreenKeyboard);
- REGISTER_SYMBOL(SbWindowIsOnScreenKeyboardShown);
- REGISTER_SYMBOL(SbWindowSetOnScreenKeyboardKeepFocus);
- REGISTER_SYMBOL(SbWindowShowOnScreenKeyboard);
- REGISTER_SYMBOL(SbWindowOnScreenKeyboardSuggestionsSupported);
- REGISTER_SYMBOL(SbWindowUpdateOnScreenKeyboardSuggestions);
- REGISTER_SYMBOL(SbWindowOnScreenKeyboardIsSupported);
- REGISTER_SYMBOL(SbAccessibilityGetCaptionSettings);
- REGISTER_SYMBOL(SbAccessibilitySetCaptionsEnabled);
- REGISTER_SYMBOL(SbMicrophoneClose);
- REGISTER_SYMBOL(SbMicrophoneCreate);
- REGISTER_SYMBOL(SbMicrophoneDestroy);
- REGISTER_SYMBOL(SbMicrophoneGetAvailable);
- REGISTER_SYMBOL(SbMicrophoneIsSampleRateSupported);
- REGISTER_SYMBOL(SbMicrophoneOpen);
- REGISTER_SYMBOL(SbMicrophoneRead);
- REGISTER_SYMBOL(SbSocketIsIpv6Supported);
- REGISTER_SYMBOL(SbSpeechSynthesisCancel);
- REGISTER_SYMBOL(SbSpeechSynthesisSpeak);
- REGISTER_SYMBOL(SbTimeGetMonotonicThreadNow);
-#if SB_API_VERSION == 12
- REGISTER_SYMBOL(SbSpeechRecognizerIsSupported);
-#endif
-#if SB_API_VERSION == 12
- REGISTER_SYMBOL(SbSpeechRecognizerCreate);
- REGISTER_SYMBOL(SbSpeechRecognizerDestroy);
- REGISTER_SYMBOL(SbSpeechRecognizerStart);
- REGISTER_SYMBOL(SbSpeechRecognizerStop);
- REGISTER_SYMBOL(SbSpeechRecognizerCancel);
-#endif // SB_API_VERSION == 12
- REGISTER_SYMBOL(SbSpeechSynthesisIsSupported);
- REGISTER_SYMBOL(SbTimeIsTimeThreadNowSupported);
- REGISTER_SYMBOL(SbDrmIsServerCertificateUpdatable);
- REGISTER_SYMBOL(SbDrmUpdateServerCertificate);
- REGISTER_SYMBOL(SbMediaGetAudioBufferBudget);
- REGISTER_SYMBOL(SbMediaGetBufferAlignment);
- REGISTER_SYMBOL(SbMediaGetBufferAllocationUnit);
- REGISTER_SYMBOL(SbMediaGetBufferGarbageCollectionDurationThreshold);
- REGISTER_SYMBOL(SbMediaGetBufferPadding);
- REGISTER_SYMBOL(SbMediaGetBufferStorageType);
- REGISTER_SYMBOL(SbMediaGetInitialBufferCapacity);
- REGISTER_SYMBOL(SbMediaGetMaxBufferCapacity);
- REGISTER_SYMBOL(SbMediaGetProgressiveBufferBudget);
- REGISTER_SYMBOL(SbMediaGetVideoBufferBudget);
- REGISTER_SYMBOL(SbMediaIsBufferPoolAllocateOnDemand);
- REGISTER_SYMBOL(SbMediaIsBufferUsingMemoryPool);
- REGISTER_SYMBOL(SbPlayerGetInfo2);
- REGISTER_SYMBOL(SbPlayerGetMaximumNumberOfSamplesPerWrite);
- REGISTER_SYMBOL(SbPlayerSeek2);
- REGISTER_SYMBOL(SbPlayerWriteSample2);
- REGISTER_SYMBOL(SbSystemSupportsResume);
- REGISTER_SYMBOL(SbAudioSinkGetMinBufferSizeInFrames);
- REGISTER_SYMBOL(SbCPUFeaturesGet);
- REGISTER_SYMBOL(SbMediaSetAudioWriteDuration);
- REGISTER_SYMBOL(SbSystemGetExtension);
- REGISTER_SYMBOL(SbSystemSignWithCertificationSecretKey);
- REGISTER_SYMBOL(SbThreadContextGetPointer);
REGISTER_SYMBOL(SbThreadSamplerCreate);
REGISTER_SYMBOL(SbThreadSamplerDestroy);
REGISTER_SYMBOL(SbThreadSamplerFreeze);
REGISTER_SYMBOL(SbThreadSamplerIsSupported);
REGISTER_SYMBOL(SbThreadSamplerThaw);
+ REGISTER_SYMBOL(SbThreadSetLocalValue);
+ REGISTER_SYMBOL(SbThreadSetName);
+ REGISTER_SYMBOL(SbThreadSleep);
+ REGISTER_SYMBOL(SbThreadYield);
+ REGISTER_SYMBOL(SbTimeGetMonotonicNow);
+ REGISTER_SYMBOL(SbTimeGetMonotonicThreadNow);
+ REGISTER_SYMBOL(SbTimeGetNow);
+ REGISTER_SYMBOL(SbTimeIsTimeThreadNowSupported);
+ REGISTER_SYMBOL(SbTimeZoneGetCurrent);
+ REGISTER_SYMBOL(SbTimeZoneGetName);
+ REGISTER_SYMBOL(SbUiNavGetInterface);
+ REGISTER_SYMBOL(SbUserGetCurrent);
+ REGISTER_SYMBOL(SbUserGetProperty);
+ REGISTER_SYMBOL(SbUserGetPropertySize);
+ REGISTER_SYMBOL(SbUserGetSignedIn);
+ REGISTER_SYMBOL(SbWindowBlurOnScreenKeyboard);
+ REGISTER_SYMBOL(SbWindowCreate);
+ REGISTER_SYMBOL(SbWindowDestroy);
+ REGISTER_SYMBOL(SbWindowFocusOnScreenKeyboard);
REGISTER_SYMBOL(SbWindowGetDiagonalSizeInInches);
- REGISTER_SYMBOL(kSbDefaultMmapThreshold);
- REGISTER_SYMBOL(kSbFileMaxName);
- REGISTER_SYMBOL(kSbFileMaxOpen);
- REGISTER_SYMBOL(kSbFileAltSepChar);
- REGISTER_SYMBOL(kSbFileAltSepString);
- REGISTER_SYMBOL(kSbFileMaxPath);
- REGISTER_SYMBOL(kSbFileSepChar);
- REGISTER_SYMBOL(kSbFileSepString);
- REGISTER_SYMBOL(kSbHasAc3Audio);
- REGISTER_SYMBOL(kSbHasMediaWebmVp9Support);
- REGISTER_SYMBOL(kSbHasThreadPrioritySupport);
- REGISTER_SYMBOL(kSbMallocAlignment);
-#if SB_API_VERSION >= 14
- REGISTER_SYMBOL(kSbMaxSystemPathCacheDirectorySize);
-#endif // SB_API_VERSION >= 14
- REGISTER_SYMBOL(kSbMaxThreadLocalKeys);
- REGISTER_SYMBOL(kSbMaxThreadNameLength);
- REGISTER_SYMBOL(kSbMediaMaxAudioBitrateInBitsPerSecond);
- REGISTER_SYMBOL(kSbMediaMaxVideoBitrateInBitsPerSecond);
- REGISTER_SYMBOL(kSbMediaVideoFrameAlignment);
- REGISTER_SYMBOL(kSbMemoryLogPath);
- REGISTER_SYMBOL(kSbMemoryPageSize);
- REGISTER_SYMBOL(kSbNetworkReceiveBufferSize);
- REGISTER_SYMBOL(kSbMaxThreads);
- REGISTER_SYMBOL(kSbPathSepChar);
- REGISTER_SYMBOL(kSbPathSepString);
- REGISTER_SYMBOL(kSbPreferredRgbaByteOrder);
- REGISTER_SYMBOL(kSbUserMaxSignedIn);
-#if SB_API_VERSION >= 13
- REGISTER_SYMBOL(SbSystemNetworkIsDisconnected);
-#endif // SB_API_VERSION >= 13
+ REGISTER_SYMBOL(SbWindowGetOnScreenKeyboardBoundingRect);
+ REGISTER_SYMBOL(SbWindowGetPlatformHandle);
+ REGISTER_SYMBOL(SbWindowGetSize);
+ REGISTER_SYMBOL(SbWindowHideOnScreenKeyboard);
+ REGISTER_SYMBOL(SbWindowIsOnScreenKeyboardShown);
+ REGISTER_SYMBOL(SbWindowOnScreenKeyboardIsSupported);
+ REGISTER_SYMBOL(SbWindowOnScreenKeyboardSuggestionsSupported);
+ REGISTER_SYMBOL(SbWindowSetDefaultOptions);
+ REGISTER_SYMBOL(SbWindowSetOnScreenKeyboardKeepFocus);
+ REGISTER_SYMBOL(SbWindowShowOnScreenKeyboard);
+ REGISTER_SYMBOL(SbWindowUpdateOnScreenKeyboardSuggestions);
} // NOLINT
const void* ExportedSymbols::Lookup(const char* name) {
diff --git a/starboard/linux/x64x11/main.cc b/starboard/linux/x64x11/main.cc
index d2bb68a..56e1caa 100644
--- a/starboard/linux/x64x11/main.cc
+++ b/starboard/linux/x64x11/main.cc
@@ -35,10 +35,12 @@
#if SB_IS(EVERGREEN_COMPATIBLE)
if (starboard::shared::starboard::CommandLine(argc, argv)
- .HasSwitch(starboard::shared::starboard::kStartHandlerAtCrash)) {
- third_party::crashpad::wrapper::InstallCrashpadHandler(true);
- } else {
+ .HasSwitch(starboard::shared::starboard::kStartHandlerAtLaunch) &&
+ !starboard::shared::starboard::CommandLine(argc, argv)
+ .HasSwitch(starboard::shared::starboard::kStartHandlerAtCrash)) {
third_party::crashpad::wrapper::InstallCrashpadHandler(false);
+ } else {
+ third_party::crashpad::wrapper::InstallCrashpadHandler(true);
}
#endif
diff --git a/starboard/raspi/shared/main.cc b/starboard/raspi/shared/main.cc
index d935df8..ee0d66c 100644
--- a/starboard/raspi/shared/main.cc
+++ b/starboard/raspi/shared/main.cc
@@ -38,10 +38,12 @@
#if SB_IS(EVERGREEN_COMPATIBLE)
if (starboard::shared::starboard::CommandLine(argc, argv)
- .HasSwitch(starboard::shared::starboard::kStartHandlerAtCrash)) {
- third_party::crashpad::wrapper::InstallCrashpadHandler(true);
- } else {
+ .HasSwitch(starboard::shared::starboard::kStartHandlerAtLaunch) &&
+ !starboard::shared::starboard::CommandLine(argc, argv)
+ .HasSwitch(starboard::shared::starboard::kStartHandlerAtCrash)) {
third_party::crashpad::wrapper::InstallCrashpadHandler(false);
+ } else {
+ third_party::crashpad::wrapper::InstallCrashpadHandler(true);
}
#endif
starboard::raspi::shared::ApplicationDispmanx application;
diff --git a/starboard/shared/starboard/player/filter/BUILD.gn b/starboard/shared/starboard/player/filter/BUILD.gn
index c37a424..f5f9d4f 100644
--- a/starboard/shared/starboard/player/filter/BUILD.gn
+++ b/starboard/shared/starboard/player/filter/BUILD.gn
@@ -23,8 +23,8 @@
"//starboard/shared/starboard/player/filter/audio_frame_tracker.cc",
"//starboard/shared/starboard/player/filter/audio_frame_tracker.h",
"//starboard/shared/starboard/player/filter/audio_renderer_internal.h",
- "//starboard/shared/starboard/player/filter/audio_renderer_internal_impl.cc",
- "//starboard/shared/starboard/player/filter/audio_renderer_internal_impl.h",
+ "//starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.cc",
+ "//starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.h",
"//starboard/shared/starboard/player/filter/audio_renderer_sink.h",
"//starboard/shared/starboard/player/filter/audio_renderer_sink_impl.cc",
"//starboard/shared/starboard/player/filter/audio_renderer_sink_impl.h",
diff --git a/starboard/shared/starboard/player/filter/audio_renderer_internal_impl.cc b/starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.cc
similarity index 87%
rename from starboard/shared/starboard/player/filter/audio_renderer_internal_impl.cc
rename to starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.cc
index 5e0536b..709cd8b 100644
--- a/starboard/shared/starboard/player/filter/audio_renderer_internal_impl.cc
+++ b/starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.cc
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#include "starboard/shared/starboard/player/filter/audio_renderer_internal_impl.h"
+#include "starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.h"
#include <algorithm>
#include <string>
@@ -29,7 +29,7 @@
namespace {
// This class works only when the input format and output format are the same.
-// It allows for a simplified AudioRendererImpl implementation by always using a
+// It allows for a simplified AudioRendererPcm implementation by always using a
// resampler.
class IdentityAudioResampler : public AudioResampler {
public:
@@ -50,7 +50,7 @@
bool eos_reached_;
};
-// AudioRendererImpl uses AudioTimeStretcher internally to adjust to playback
+// AudioRendererPcm uses AudioTimeStretcher internally to adjust to playback
// rate. So we try to use kSbMediaAudioSampleTypeFloat32 and only use
// kSbMediaAudioSampleTypeInt16Deprecated when float32 is not supported. To use
// kSbMediaAudioSampleTypeFloat32 will cause an extra conversion from float32 to
@@ -65,7 +65,7 @@
} // namespace
-AudioRendererImpl::AudioRendererImpl(
+AudioRendererPcm::AudioRendererPcm(
scoped_ptr<AudioDecoder> decoder,
scoped_ptr<AudioRendererSink> audio_renderer_sink,
const SbMediaAudioSampleInfo& audio_sample_info,
@@ -80,9 +80,9 @@
frames_consumed_set_at_(SbTimeGetMonotonicNow()),
decoder_(decoder.Pass()),
process_audio_data_job_(
- std::bind(&AudioRendererImpl::ProcessAudioData, this)),
+ std::bind(&AudioRendererPcm::ProcessAudioData, this)),
audio_renderer_sink_(audio_renderer_sink.Pass()) {
- SB_DLOG(INFO) << "Creating AudioRendererImpl with " << channels_
+ SB_DLOG(INFO) << "Creating AudioRendererPcm with " << channels_
<< " channels, " << bytes_per_frame_ << " bytes per frame, "
<< max_cached_frames_ << " max cached frames, and "
<< min_frames_per_append_ << " min frames per append.";
@@ -93,22 +93,22 @@
frame_buffers_[0] = &frame_buffer_[0];
#if SB_PLAYER_FILTER_ENABLE_STATE_CHECK
- Schedule(std::bind(&AudioRendererImpl::CheckAudioSinkStatus, this),
+ Schedule(std::bind(&AudioRendererPcm::CheckAudioSinkStatus, this),
kCheckAudioSinkStatusInterval);
#endif // SB_PLAYER_FILTER_ENABLE_STATE_CHECK
}
-AudioRendererImpl::~AudioRendererImpl() {
- SB_DLOG(INFO) << "Destroying AudioRendererImpl with " << channels_
+AudioRendererPcm::~AudioRendererPcm() {
+ SB_DLOG(INFO) << "Destroying AudioRendererPcm with " << channels_
<< " channels, " << bytes_per_frame_ << " bytes per frame, "
<< max_cached_frames_ << " max cached frames, and "
<< min_frames_per_append_ << " min frames per append.";
SB_DCHECK(BelongsToCurrentThread());
}
-void AudioRendererImpl::Initialize(const ErrorCB& error_cb,
- const PrerolledCB& prerolled_cb,
- const EndedCB& ended_cb) {
+void AudioRendererPcm::Initialize(const ErrorCB& error_cb,
+ const PrerolledCB& prerolled_cb,
+ const EndedCB& ended_cb) {
SB_DCHECK(error_cb);
SB_DCHECK(prerolled_cb);
SB_DCHECK(ended_cb);
@@ -120,11 +120,11 @@
prerolled_cb_ = prerolled_cb;
ended_cb_ = ended_cb;
- decoder_->Initialize(std::bind(&AudioRendererImpl::OnDecoderOutput, this),
+ decoder_->Initialize(std::bind(&AudioRendererPcm::OnDecoderOutput, this),
error_cb);
}
-void AudioRendererImpl::WriteSample(
+void AudioRendererPcm::WriteSample(
const scoped_refptr<InputBuffer>& input_buffer) {
SB_DCHECK(BelongsToCurrentThread());
SB_DCHECK(input_buffer);
@@ -139,11 +139,11 @@
can_accept_more_data_ = false;
decoder_->Decode(input_buffer,
- std::bind(&AudioRendererImpl::OnDecoderConsumed, this));
+ std::bind(&AudioRendererPcm::OnDecoderConsumed, this));
first_input_written_ = true;
}
-void AudioRendererImpl::WriteEndOfStream() {
+void AudioRendererPcm::WriteEndOfStream() {
SB_DCHECK(BelongsToCurrentThread());
// TODO: Check |can_accept_more_data_| and make WriteEndOfStream() depend on
// CanAcceptMoreData() or callback.
@@ -162,28 +162,28 @@
first_input_written_ = true;
}
-void AudioRendererImpl::SetVolume(double volume) {
+void AudioRendererPcm::SetVolume(double volume) {
SB_DCHECK(BelongsToCurrentThread());
audio_renderer_sink_->SetVolume(volume);
}
-bool AudioRendererImpl::IsEndOfStreamWritten() const {
+bool AudioRendererPcm::IsEndOfStreamWritten() const {
SB_DCHECK(BelongsToCurrentThread());
return eos_state_ >= kEOSWrittenToDecoder;
}
-bool AudioRendererImpl::IsEndOfStreamPlayed() const {
+bool AudioRendererPcm::IsEndOfStreamPlayed() const {
ScopedLock lock(mutex_);
return IsEndOfStreamPlayed_Locked();
}
-bool AudioRendererImpl::CanAcceptMoreData() const {
+bool AudioRendererPcm::CanAcceptMoreData() const {
SB_DCHECK(BelongsToCurrentThread());
return eos_state_ == kEOSNotReceived && can_accept_more_data_ &&
(!decoder_sample_rate_ || !time_stretcher_.IsQueueFull());
}
-void AudioRendererImpl::Play() {
+void AudioRendererPcm::Play() {
SB_DCHECK(BelongsToCurrentThread());
ScopedLock lock(mutex_);
@@ -191,14 +191,14 @@
consume_frames_called_ = false;
}
-void AudioRendererImpl::Pause() {
+void AudioRendererPcm::Pause() {
SB_DCHECK(BelongsToCurrentThread());
ScopedLock lock(mutex_);
paused_ = true;
}
-void AudioRendererImpl::SetPlaybackRate(double playback_rate) {
+void AudioRendererPcm::SetPlaybackRate(double playback_rate) {
SB_DCHECK(BelongsToCurrentThread());
ScopedLock lock(mutex_);
@@ -223,7 +223,7 @@
}
}
-void AudioRendererImpl::Seek(SbTime seek_to_time) {
+void AudioRendererPcm::Seek(SbTime seek_to_time) {
SB_DCHECK(BelongsToCurrentThread());
SB_DCHECK(seek_to_time >= 0);
@@ -272,15 +272,15 @@
CancelPendingJobs();
#if SB_PLAYER_FILTER_ENABLE_STATE_CHECK
- Schedule(std::bind(&AudioRendererImpl::CheckAudioSinkStatus, this),
+ Schedule(std::bind(&AudioRendererPcm::CheckAudioSinkStatus, this),
kCheckAudioSinkStatusInterval);
#endif // SB_PLAYER_FILTER_ENABLE_STATE_CHECK
}
-SbTime AudioRendererImpl::GetCurrentMediaTime(bool* is_playing,
- bool* is_eos_played,
- bool* is_underflow,
- double* playback_rate) {
+SbTime AudioRendererPcm::GetCurrentMediaTime(bool* is_playing,
+ bool* is_eos_played,
+ bool* is_underflow,
+ double* playback_rate) {
SB_DCHECK(is_playing);
SB_DCHECK(is_eos_played);
SB_DCHECK(is_underflow);
@@ -364,10 +364,10 @@
return media_time;
}
-void AudioRendererImpl::GetSourceStatus(int* frames_in_buffer,
- int* offset_in_frames,
- bool* is_playing,
- bool* is_eos_reached) {
+void AudioRendererPcm::GetSourceStatus(int* frames_in_buffer,
+ int* offset_in_frames,
+ bool* is_playing,
+ bool* is_eos_reached) {
#if SB_PLAYER_FILTER_ENABLE_STATE_CHECK
sink_callbacks_since_last_check_.increment();
#endif // SB_PLAYER_FILTER_ENABLE_STATE_CHECK
@@ -406,14 +406,13 @@
if (silence_frames_to_write <= max_cached_frames_ - start_offset) {
memset(frame_buffer_.data() + start_offset * bytes_per_frame_, 0,
- silence_frames_to_write * bytes_per_frame_);
+ silence_frames_to_write * bytes_per_frame_);
} else {
memset(frame_buffer_.data() + start_offset * bytes_per_frame_, 0,
- (max_cached_frames_ - start_offset) * bytes_per_frame_);
- memset(
- frame_buffer_.data(), 0,
- (silence_frames_to_write - max_cached_frames_ + start_offset) *
- bytes_per_frame_);
+ (max_cached_frames_ - start_offset) * bytes_per_frame_);
+ memset(frame_buffer_.data(), 0,
+ (silence_frames_to_write - max_cached_frames_ + start_offset) *
+ bytes_per_frame_);
}
silence_frames_written_after_eos_on_sink_thread_ +=
silence_frames_to_write;
@@ -422,8 +421,8 @@
}
}
-void AudioRendererImpl::ConsumeFrames(int frames_consumed,
- SbTime frames_consumed_at) {
+void AudioRendererPcm::ConsumeFrames(int frames_consumed,
+ SbTime frames_consumed_at) {
#if SB_PLAYER_FILTER_ENABLE_STATE_CHECK
sink_callbacks_since_last_check_.increment();
#endif // SB_PLAYER_FILTER_ENABLE_STATE_CHECK
@@ -450,8 +449,8 @@
}
}
-void AudioRendererImpl::OnError(bool capability_changed,
- const std::string& error_message) {
+void AudioRendererPcm::OnError(bool capability_changed,
+ const std::string& error_message) {
SB_DCHECK(error_cb_);
if (capability_changed) {
error_cb_(kSbPlayerErrorCapabilityChanged, error_message);
@@ -463,7 +462,7 @@
}
}
-void AudioRendererImpl::UpdateVariablesOnSinkThread_Locked(
+void AudioRendererPcm::UpdateVariablesOnSinkThread_Locked(
SbTime system_time_on_consume_frames) {
mutex_.DCheckAcquired();
@@ -504,7 +503,7 @@
}
}
-void AudioRendererImpl::OnFirstOutput(
+void AudioRendererPcm::OnFirstOutput(
const SbMediaAudioSampleType decoded_sample_type,
const SbMediaAudioFrameStorageType decoded_storage_type,
const int decoded_sample_rate) {
@@ -544,13 +543,13 @@
}
}
-bool AudioRendererImpl::IsEndOfStreamPlayed_Locked() const {
+bool AudioRendererPcm::IsEndOfStreamPlayed_Locked() const {
mutex_.DCheckAcquired();
return eos_state_ >= kEOSSentToSink &&
total_frames_sent_to_sink_ == total_frames_consumed_by_sink_;
}
-void AudioRendererImpl::OnDecoderConsumed() {
+void AudioRendererPcm::OnDecoderConsumed() {
SB_DCHECK(BelongsToCurrentThread());
// TODO: Unify EOS and non EOS request once WriteEndOfStream() depends on
@@ -562,7 +561,7 @@
}
}
-void AudioRendererImpl::OnDecoderOutput() {
+void AudioRendererPcm::OnDecoderOutput() {
SB_DCHECK(BelongsToCurrentThread());
++pending_decoder_outputs_;
@@ -575,7 +574,7 @@
ProcessAudioData();
}
-void AudioRendererImpl::ProcessAudioData() {
+void AudioRendererPcm::ProcessAudioData() {
SB_DCHECK(BelongsToCurrentThread());
process_audio_data_job_token_.ResetToInvalid();
@@ -673,7 +672,7 @@
}
}
-bool AudioRendererImpl::AppendAudioToFrameBuffer(bool* is_frame_buffer_full) {
+bool AudioRendererPcm::AppendAudioToFrameBuffer(bool* is_frame_buffer_full) {
SB_DCHECK(BelongsToCurrentThread());
SB_DCHECK(is_frame_buffer_full);
@@ -722,17 +721,16 @@
int frames_appended = 0;
if (frames_to_append > max_cached_frames_ - offset_to_append) {
- memcpy(&frame_buffer_[offset_to_append * bytes_per_frame_],
- source_buffer,
- (max_cached_frames_ - offset_to_append) * bytes_per_frame_);
+ memcpy(&frame_buffer_[offset_to_append * bytes_per_frame_], source_buffer,
+ (max_cached_frames_ - offset_to_append) * bytes_per_frame_);
source_buffer += (max_cached_frames_ - offset_to_append) * bytes_per_frame_;
frames_to_append -= max_cached_frames_ - offset_to_append;
frames_appended += max_cached_frames_ - offset_to_append;
offset_to_append = 0;
}
- memcpy(&frame_buffer_[offset_to_append * bytes_per_frame_],
- source_buffer, frames_to_append * bytes_per_frame_);
+ memcpy(&frame_buffer_[offset_to_append * bytes_per_frame_], source_buffer,
+ frames_to_append * bytes_per_frame_);
frames_appended += frames_to_append;
total_frames_sent_to_sink_ += frames_appended;
@@ -741,7 +739,7 @@
}
#if SB_PLAYER_FILTER_ENABLE_STATE_CHECK
-void AudioRendererImpl::CheckAudioSinkStatus() {
+void AudioRendererPcm::CheckAudioSinkStatus() {
SB_DCHECK(BelongsToCurrentThread());
// Check if sink callbacks are called too frequently.
@@ -770,7 +768,7 @@
<< sink_callbacks_since_last_check
<< " callbacks since last check.";
}
- Schedule(std::bind(&AudioRendererImpl::CheckAudioSinkStatus, this),
+ Schedule(std::bind(&AudioRendererPcm::CheckAudioSinkStatus, this),
kCheckAudioSinkStatusInterval);
}
#endif // SB_PLAYER_FILTER_ENABLE_STATE_CHECK
diff --git a/starboard/shared/starboard/player/filter/audio_renderer_internal_impl.h b/starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.h
similarity index 92%
rename from starboard/shared/starboard/player/filter/audio_renderer_internal_impl.h
rename to starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.h
index 1129b9d..7c37d7b 100644
--- a/starboard/shared/starboard/player/filter/audio_renderer_internal_impl.h
+++ b/starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.h
@@ -12,8 +12,8 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#ifndef STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_RENDERER_INTERNAL_IMPL_H_
-#define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_RENDERER_INTERNAL_IMPL_H_
+#ifndef STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_RENDERER_INTERNAL_PCM_H_
+#define STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_RENDERER_INTERNAL_PCM_H_
#include <functional>
#include <string>
@@ -54,10 +54,10 @@
// A class that sits in between the audio decoder, the audio sink and the
// pipeline to coordinate data transfer between these parties. It also serves
// as the authority of playback time.
-class AudioRendererImpl : public AudioRenderer,
- public MediaTimeProvider,
- private AudioRendererSink::RenderCallback,
- private JobQueue::JobOwner {
+class AudioRendererPcm : public AudioRenderer,
+ public MediaTimeProvider,
+ private AudioRendererSink::RenderCallback,
+ private JobQueue::JobOwner {
public:
// |max_cached_frames| is a soft limit for the max audio frames this class can
// cache so it can:
@@ -66,12 +66,12 @@
// longer accept more data.
// |min_frames_per_append| is the min number of frames that the audio renderer
// tries to append to the sink buffer at once.
- AudioRendererImpl(scoped_ptr<AudioDecoder> decoder,
- scoped_ptr<AudioRendererSink> audio_renderer_sink,
- const SbMediaAudioSampleInfo& audio_sample_info,
- int max_cached_frames,
- int min_frames_per_append);
- ~AudioRendererImpl() override;
+ AudioRendererPcm(scoped_ptr<AudioDecoder> decoder,
+ scoped_ptr<AudioRendererSink> audio_renderer_sink,
+ const SbMediaAudioSampleInfo& audio_sample_info,
+ int max_cached_frames,
+ int min_frames_per_append);
+ ~AudioRendererPcm() override;
void Initialize(const ErrorCB& error_cb,
const PrerolledCB& prerolled_cb,
@@ -215,4 +215,4 @@
} // namespace shared
} // namespace starboard
-#endif // STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_RENDERER_INTERNAL_IMPL_H_
+#endif // STARBOARD_SHARED_STARBOARD_PLAYER_FILTER_AUDIO_RENDERER_INTERNAL_PCM_H_
diff --git a/starboard/shared/starboard/player/filter/audio_renderer_sink.h b/starboard/shared/starboard/player/filter/audio_renderer_sink.h
index 5aa8a1f..de4e394 100644
--- a/starboard/shared/starboard/player/filter/audio_renderer_sink.h
+++ b/starboard/shared/starboard/player/filter/audio_renderer_sink.h
@@ -27,7 +27,7 @@
namespace player {
namespace filter {
-// The interface used by AudioRendererImpl to output audio samples.
+// The interface used by AudioRendererPcm to output audio samples.
class AudioRendererSink {
public:
class RenderCallback {
diff --git a/starboard/shared/starboard/player/filter/player_components.cc b/starboard/shared/starboard/player/filter/player_components.cc
index f8eb7b0..94d71e0 100644
--- a/starboard/shared/starboard/player/filter/player_components.cc
+++ b/starboard/shared/starboard/player/filter/player_components.cc
@@ -18,7 +18,7 @@
#include "starboard/shared/starboard/application.h"
#include "starboard/shared/starboard/command_line.h"
#include "starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.h"
-#include "starboard/shared/starboard/player/filter/audio_renderer_internal_impl.h"
+#include "starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.h"
#include "starboard/shared/starboard/player/filter/audio_renderer_sink_impl.h"
#include "starboard/shared/starboard/player/filter/media_time_provider_impl.h"
#include "starboard/shared/starboard/player/filter/punchout_video_renderer_sink.h"
@@ -52,7 +52,7 @@
class PlayerComponentsImpl : public PlayerComponents {
public:
PlayerComponentsImpl(scoped_ptr<MediaTimeProviderImpl> media_time_provider,
- scoped_ptr<AudioRendererImpl> audio_renderer,
+ scoped_ptr<AudioRendererPcm> audio_renderer,
scoped_ptr<VideoRendererImpl> video_renderer)
: media_time_provider_(media_time_provider.Pass()),
audio_renderer_(audio_renderer.Pass()),
@@ -72,7 +72,7 @@
private:
// |media_time_provider_| will only be used when |audio_renderer_| is nullptr.
scoped_ptr<MediaTimeProviderImpl> media_time_provider_;
- scoped_ptr<AudioRendererImpl> audio_renderer_;
+ scoped_ptr<AudioRendererPcm> audio_renderer_;
scoped_ptr<VideoRendererImpl> video_renderer_;
};
@@ -216,7 +216,7 @@
}
scoped_ptr<MediaTimeProviderImpl> media_time_provider_impl;
- scoped_ptr<AudioRendererImpl> audio_renderer;
+ scoped_ptr<AudioRendererPcm> audio_renderer;
scoped_ptr<VideoRendererImpl> video_renderer;
if (creation_parameters.audio_codec() != kSbMediaAudioCodecNone) {
@@ -228,9 +228,9 @@
&min_frames_per_append);
audio_renderer.reset(
- new AudioRendererImpl(audio_decoder.Pass(), audio_renderer_sink.Pass(),
- creation_parameters.audio_sample_info(),
- max_cached_frames, min_frames_per_append));
+ new AudioRendererPcm(audio_decoder.Pass(), audio_renderer_sink.Pass(),
+ creation_parameters.audio_sample_info(),
+ max_cached_frames, min_frames_per_append));
}
if (creation_parameters.video_codec() != kSbMediaVideoCodecNone) {
diff --git a/starboard/shared/starboard/player/filter/testing/audio_renderer_internal_test.cc b/starboard/shared/starboard/player/filter/testing/audio_renderer_internal_test.cc
index c7b15c9..ae7e57c 100644
--- a/starboard/shared/starboard/player/filter/testing/audio_renderer_internal_test.cc
+++ b/starboard/shared/starboard/player/filter/testing/audio_renderer_internal_test.cc
@@ -12,7 +12,7 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-#include "starboard/shared/starboard/player/filter/audio_renderer_internal_impl.h"
+#include "starboard/shared/starboard/player/filter/audio_renderer_internal_pcm.h"
#include <functional>
#include <set>
@@ -114,7 +114,7 @@
const int kMaxCachedFrames = 256 * 1024;
const int kMaxFramesPerAppend = 16384;
- audio_renderer_.reset(new AudioRendererImpl(
+ audio_renderer_.reset(new AudioRendererPcm(
make_scoped_ptr<AudioDecoder>(audio_decoder_),
make_scoped_ptr<AudioRendererSink>(audio_renderer_sink_),
GetDefaultAudioSampleInfo(), kMaxCachedFrames, kMaxFramesPerAppend));
@@ -231,7 +231,7 @@
AudioDecoder::ConsumedCB consumed_cb_;
bool prerolled_ = true;
- scoped_ptr<AudioRendererImpl> audio_renderer_;
+ scoped_ptr<AudioRendererPcm> audio_renderer_;
MockAudioDecoder* audio_decoder_;
MockAudioRendererSink* audio_renderer_sink_;
AudioRendererSink::RenderCallback* renderer_callback_;
diff --git a/starboard/shared/starboard/starboard_switches.cc b/starboard/shared/starboard/starboard_switches.cc
index 7da02f4..ad4917e 100644
--- a/starboard/shared/starboard/starboard_switches.cc
+++ b/starboard/shared/starboard/starboard_switches.cc
@@ -19,6 +19,7 @@
namespace starboard {
const char kStartHandlerAtCrash[] = "start_handler_at_crash";
+const char kStartHandlerAtLaunch[] = "start_handler_at_launch";
} // namespace starboard
} // namespace shared
diff --git a/starboard/shared/starboard/starboard_switches.h b/starboard/shared/starboard/starboard_switches.h
index 025e03b..55fea4e 100644
--- a/starboard/shared/starboard/starboard_switches.h
+++ b/starboard/shared/starboard/starboard_switches.h
@@ -25,6 +25,10 @@
// before the app runs and keeping it running all the time. This option reduces
// memory consumption by the crash handler.
extern const char kStartHandlerAtCrash[];
+// Use this flag to start the handler
+// before the app launches. Without this flag, the crash handler starts only
+// when a crash happens. This option increases the memory consumption.
+extern const char kStartHandlerAtLaunch[];
} // namespace starboard
} // namespace shared
diff --git a/starboard/shared/test_webapi_extension/BUILD.gn b/starboard/shared/test_webapi_extension/BUILD.gn
deleted file mode 100644
index 331ced9..0000000
--- a/starboard/shared/test_webapi_extension/BUILD.gn
+++ /dev/null
@@ -1,29 +0,0 @@
-# Copyright 2021 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.
-
-static_library("cobalt_test_webapi_extension") {
- # List of all source files and header files needed to support the IDL
- # definitions.
- sources = [
- "my_new_interface.cc",
- "my_new_interface.h",
- "webapi_extension.cc",
- ]
-
- deps = [
- "//base",
- "//cobalt/dom",
- "//cobalt/script",
- ]
-}
diff --git a/starboard/shared/test_webapi_extension/my_new_enum.idl b/starboard/shared/test_webapi_extension/my_new_enum.idl
deleted file mode 100644
index 8d2f185..0000000
--- a/starboard/shared/test_webapi_extension/my_new_enum.idl
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2017 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.
-
-enum MyNewEnum {
- "apples",
- "oranges",
- "peaches"
-};
diff --git a/starboard/shared/test_webapi_extension/my_new_interface.cc b/starboard/shared/test_webapi_extension/my_new_interface.cc
deleted file mode 100644
index e704629..0000000
--- a/starboard/shared/test_webapi_extension/my_new_interface.cc
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2017 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/shared/test_webapi_extension/my_new_interface.h"
-
-namespace cobalt {
-namespace webapi_extension {
-
-MyNewInterface::MyNewInterface(const scoped_refptr<dom::Window>& window) {
- // Provide an initial value for the enum.
- enum_value_ = kMyNewEnumApples;
-}
-
-MyNewInterface::~MyNewInterface() {}
-
-} // namespace webapi_extension
-} // namespace cobalt
diff --git a/starboard/shared/test_webapi_extension/my_new_interface.h b/starboard/shared/test_webapi_extension/my_new_interface.h
deleted file mode 100644
index 29a1fdb..0000000
--- a/starboard/shared/test_webapi_extension/my_new_interface.h
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2017 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_TEST_WEBAPI_EXTENSION_MY_NEW_INTERFACE_H_
-#define STARBOARD_SHARED_TEST_WEBAPI_EXTENSION_MY_NEW_INTERFACE_H_
-
-#include <string>
-
-#include "cobalt/dom/window.h"
-#include "cobalt/script/wrappable.h"
-#include "starboard/shared/test_webapi_extension/my_new_enum.h"
-
-namespace cobalt {
-namespace webapi_extension {
-
-class MyNewInterface : public script::Wrappable {
- public:
- explicit MyNewInterface(const scoped_refptr<dom::Window>& window);
-
- const std::string& foo() const { return foo_; }
- void set_foo(const std::string& value) { foo_ = value; }
-
- void SetMyNewEnum(MyNewEnum value) { enum_value_ = value; }
- MyNewEnum GetMyNewEnum() const { return enum_value_; }
-
- // All types derived from script::Wrappable must have this annotation.
- DEFINE_WRAPPABLE_TYPE(MyNewInterface);
-
- private:
- // Since script::Wrappable inherits from base::RefCounted<>, we make the
- // destructor private.
- ~MyNewInterface() override;
-
- std::string foo_;
-
- MyNewEnum enum_value_;
-
- DISALLOW_COPY_AND_ASSIGN(MyNewInterface);
-};
-
-} // namespace webapi_extension
-} // namespace cobalt
-
-#endif // STARBOARD_SHARED_TEST_WEBAPI_EXTENSION_MY_NEW_INTERFACE_H_
diff --git a/starboard/shared/test_webapi_extension/webapi_extension.cc b/starboard/shared/test_webapi_extension/webapi_extension.cc
deleted file mode 100644
index 23791dd..0000000
--- a/starboard/shared/test_webapi_extension/webapi_extension.cc
+++ /dev/null
@@ -1,34 +0,0 @@
-// Copyright 2017 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 "base/compiler_specific.h"
-#include "cobalt/script/global_environment.h"
-#include "starboard/shared/test_webapi_extension/my_new_interface.h"
-
-namespace cobalt {
-namespace browser {
-
-base::Optional<std::string> GetWebAPIExtensionObjectPropertyName() {
- return std::string("myInterface");
-}
-
-scoped_refptr<script::Wrappable> CreateWebAPIExtensionObject(
- const scoped_refptr<dom::Window>& window,
- script::GlobalEnvironment* global_environment) {
- return scoped_refptr<script::Wrappable>(
- new webapi_extension::MyNewInterface(window));
-}
-
-} // namespace browser
-} // namespace cobalt
diff --git a/starboard/win/shared/platform_configuration/BUILD.gn b/starboard/win/shared/platform_configuration/BUILD.gn
index 37e60e7..7d01219 100644
--- a/starboard/win/shared/platform_configuration/BUILD.gn
+++ b/starboard/win/shared/platform_configuration/BUILD.gn
@@ -263,6 +263,9 @@
# objects.
# https://connect.microsoft.com/VisualStudio/feedback/details/783808/static-analyzer-warning-c28285-for-std-min-and-std-max
"/wd28285",
+
+ # Deprecated function warning.
+ "/wd4996",
]
}
diff --git a/third_party/angle/src/libANGLE/renderer/d3d/d3d11/winrt/CoreWindowNativeWindow.cpp b/third_party/angle/src/libANGLE/renderer/d3d/d3d11/winrt/CoreWindowNativeWindow.cpp
index 57dcb4f..acc7a5a 100644
--- a/third_party/angle/src/libANGLE/renderer/d3d/d3d11/winrt/CoreWindowNativeWindow.cpp
+++ b/third_party/angle/src/libANGLE/renderer/d3d/d3d11/winrt/CoreWindowNativeWindow.cpp
@@ -162,7 +162,7 @@
swapChainDesc.SampleDesc.Quality = 0;
swapChainDesc.BufferUsage =
DXGI_USAGE_SHADER_INPUT | DXGI_USAGE_RENDER_TARGET_OUTPUT | DXGI_USAGE_BACK_BUFFER;
- swapChainDesc.BufferCount = 4;
+ swapChainDesc.BufferCount = 3;
swapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_SEQUENTIAL;
swapChainDesc.Scaling = DXGI_SCALING_STRETCH;
swapChainDesc.AlphaMode = DXGI_ALPHA_MODE_UNSPECIFIED;
@@ -200,7 +200,7 @@
result = device->QueryInterface(__uuidof(IDXGIDevice1), (void **)pDXGIDevice.GetAddressOf());
if (SUCCEEDED(result))
{
- pDXGIDevice->SetMaximumFrameLatency(swapChainDesc.BufferCount-1);
+ pDXGIDevice->SetMaximumFrameLatency(swapChainDesc.BufferCount);
}
return result;
diff --git a/third_party/web_platform_tests/cors/resources/304.py b/third_party/web_platform_tests/cors/resources/304.py
index 2fc83b9..265569d 100755
--- a/third_party/web_platform_tests/cors/resources/304.py
+++ b/third_party/web_platform_tests/cors/resources/304.py
@@ -38,7 +38,9 @@
else:
status = 200, "OK"
headers.append(("Access-Control-Allow-Origin", "*"))
- headers.append(("Content-Type", "text/plain"))
+ # Cobalt does not support text/plain caching.
+ # headers.append(("Content-Type", "text/plain"))
+ headers.append(("Content-Type", "text/html"))
headers.append(("Cache-Control", "private, max-age=3, must-revalidate"))
headers.append(("ETag", etag))
return status, headers, "Success"
diff --git a/third_party/web_platform_tests/workers/interfaces/WorkerUtils/WindowTimers/005.html b/third_party/web_platform_tests/workers/interfaces/WorkerUtils/WindowTimers/005.html
index a1e5044..06885e4 100644
--- a/third_party/web_platform_tests/workers/interfaces/WorkerUtils/WindowTimers/005.html
+++ b/third_party/web_platform_tests/workers/interfaces/WorkerUtils/WindowTimers/005.html
@@ -8,7 +8,7 @@
async_test(function () {
var worker = new Worker('005.js');
worker.onmessage = this.step_func(function (e) {
- assert_equals(e.data, '1');
+ assert_equals(e.data, 1);
this.done();
});
});
