Import Cobalt 23.master.0.308707
diff --git a/cobalt/bindings/contexts.py b/cobalt/bindings/contexts.py
index 9285877..fb03640 100644
--- a/cobalt/bindings/contexts.py
+++ b/cobalt/bindings/contexts.py
@@ -244,7 +244,8 @@
not idl_type.is_callback_interface), 'Callback types not supported.'
element_cobalt_type = self.idl_type_to_cobalt_type(
self.resolve_typedef(result_idl_type))
- result = '::cobalt::script::Promise< %s >' % element_cobalt_type
+ result = 'std::unique_ptr<::cobalt::script::Promise< %s* > >' % (
+ element_cobalt_type)
return result
def idl_union_type_to_cobalt(self, idl_type):
diff --git a/cobalt/bindings/v8c/templates/interface.cc.template b/cobalt/bindings/v8c/templates/interface.cc.template
index a11e229..65f703c 100644
--- a/cobalt/bindings/v8c/templates/interface.cc.template
+++ b/cobalt/bindings/v8c/templates/interface.cc.template
@@ -40,6 +40,7 @@
#include "cobalt/script/v8c/entry_scope.h"
#include "cobalt/script/v8c/helpers.h"
#include "cobalt/script/v8c/native_promise.h"
+#include "cobalt/script/v8c/script_promise.h"
#include "cobalt/script/v8c/type_traits.h"
#include "cobalt/script/v8c/v8c_typed_arrays.h"
#include "cobalt/script/v8c/v8c_data_view.h"
diff --git a/cobalt/black_box_tests/testdata/service_worker_test.js b/cobalt/black_box_tests/testdata/service_worker_test.js
index 44ffc55..5b9e117 100644
--- a/cobalt/black_box_tests/testdata/service_worker_test.js
+++ b/cobalt/black_box_tests/testdata/service_worker_test.js
@@ -53,10 +53,10 @@
self.clients.matchAll(options).then(function (clients) {
console.log('(Expected) self.clients.matchAll():', clients.length, clients);
for (var i = 0; i < clients.length; i++) {
- console.log('Client with url', clients[i].url);
- console.log('Client with frameType', clients[i].frameType);
- console.log('Client with id', clients[i].id);
- console.log('Client with type', clients[i].type);
+ console.log('Client with url', clients[i].url,
+ 'frameType', clients[i].frameType,
+ 'id', clients[i].id,
+ 'type', clients[i].type);
}
}, function (error) {
console.log(`(Unexpected) self.clients.matchAll(): ${error}`, error);
@@ -106,10 +106,10 @@
console.log('(Expected) self.clients.matchAll():', clients.length, clients);
// Note: This will return 0 clients if none are controlled so far.
for (var i = 0; i < clients.length; i++) {
- console.log('Client with url', clients[i].url);
- console.log('Client with frameType', clients[i].frameType);
- console.log('Client with id', clients[i].id);
- console.log('Client with type', clients[i].type);
+ console.log('Client with url', clients[i].url,
+ 'frameType', clients[i].frameType,
+ 'id', clients[i].id,
+ 'type', clients[i].type);
}
}, function (error) {
console.log(`(Unexpected) self.clients.matchAll(): ${error}`, error);
@@ -123,18 +123,18 @@
self.clients.matchAll(options).then(function (clients) {
console.log('(Expected) self.clients.matchAll():', clients.length, clients);
for (var i = 0; i < clients.length; i++) {
- console.log('Client with url', clients[i].url);
- console.log('Client with frameType', clients[i].frameType);
- console.log('Client with id', clients[i].id);
- console.log('Client with type', clients[i].type);
+ console.log('Client with url', clients[i].url,
+ 'frameType', clients[i].frameType,
+ 'id', clients[i].id,
+ 'type', clients[i].type);
console.log('self.clients.get()');
self.clients.get(clients[i].id).then(function (client) {
console.log('(Expected) self.clients.get():', client);
- console.log('Client with url', client.url);
- console.log('Client with frameType', client.frameType);
- console.log('Client with id', client.id);
- console.log('Client with type', client.type);
+ console.log('Client with url', client.url,
+ 'frameType', client.frameType,
+ 'id', client.id,
+ 'type', client.type);
}, function (error) {
console.log(`(Unexpected) self.clients.get(): ${error}`, error);
});
diff --git a/cobalt/black_box_tests/testdata/service_worker_test_claimable.js b/cobalt/black_box_tests/testdata/service_worker_test_claimable.js
index cc0fcde..21cb0d7 100644
--- a/cobalt/black_box_tests/testdata/service_worker_test_claimable.js
+++ b/cobalt/black_box_tests/testdata/service_worker_test_claimable.js
@@ -27,37 +27,47 @@
});
}
+function delay_promise(delay) {
+ return new Promise(function (resolve) {
+ setTimeout(resolve.bind(null), delay)
+ });
+}
+
self.oninstall = function (e) {
console.log('oninstall event received', e);
+ e.waitUntil(delay_promise(500).then(() => console.log('Promised delay.'), () => console.log('\nPromised rejected.\n')));
}
+
self.onactivate = function (e) {
console.log('onactivate event received', e);
// Claim should pass here, since the state is activating.
console.log('self.clients.claim()');
- self.clients.claim().then(function (result) {
+ e.waitUntil(self.clients.claim().then(function (result) {
console.log('(Expected) self.clients.claim():', result);
var options = {
includeUncontrolled: false, type: 'window'
};
- console.log('self.clients.matchAll(options)');
- self.clients.matchAll(options).then(function (clients) {
- console.log('(Expected) self.clients.matchAll():', clients.length, clients);
- for (var i = 0; i < clients.length; i++) {
- console.log('Client with url', clients[i].url);
- console.log('Client with frameType', clients[i].frameType);
- console.log('Client with id', clients[i].id);
- console.log('Client with type', clients[i].type);
- clients[i].postMessage(`You have been claimed, client with id ${clients[i].id}`);
- }
- }, function (error) {
- console.log(`(Unexpected) self.clients.matchAll(): ${error}`, error);
- });
+ e.waitUntil(delay_promise(1000).then(function () {
+ console.log('self.clients.matchAll(options)');
+ e.waitUntil(self.clients.matchAll(options).then(function (clients) {
+ console.log('(Expected) self.clients.matchAll():', clients.length, clients);
+ for (var i = 0; i < clients.length; i++) {
+ console.log('Client with url', clients[i].url,
+ 'frameType', clients[i].frameType,
+ 'id', clients[i].id,
+ 'type', clients[i].type);
+ clients[i].postMessage(`You have been claimed, client with id ${clients[i].id}`);
+ }
+ }, function (error) {
+ console.log(`(Unexpected) self.clients.matchAll(): ${error}`, error);
+ }));
+ }));
}, function (error) {
console.log(`(Unexpected) self.clients.claim(): ${error}`, error);
- });
+ }));
}
console.log('self.registration', self.registration);
@@ -73,10 +83,10 @@
self.clients.matchAll(options).then(function (clients) {
console.log('(Expected) self.clients.matchAll():', clients.length, clients);
for (var i = 0; i < clients.length; i++) {
- console.log('Client with url', clients[i].url);
- console.log('Client with frameType', clients[i].frameType);
- console.log('Client with id', clients[i].id);
- console.log('Client with type', clients[i].type);
+ console.log('Client with url', clients[i].url,
+ 'frameType', clients[i].frameType,
+ 'id', clients[i].id,
+ 'type', clients[i].type);
}
}, function (error) {
console.log(`(Unexpected) self.clients.matchAll(): ${error}`, error);
diff --git a/cobalt/browser/BUILD.gn b/cobalt/browser/BUILD.gn
index 529dd2f..4c30f02 100644
--- a/cobalt/browser/BUILD.gn
+++ b/cobalt/browser/BUILD.gn
@@ -155,6 +155,7 @@
"//cobalt/browser/memory_settings:browser_memory_settings",
"//cobalt/browser/memory_tracker:memory_tracker_tool",
"//cobalt/build:cobalt_build_id",
+ "//cobalt/cache",
"//cobalt/configuration",
"//cobalt/css_parser",
"//cobalt/cssom",
diff --git a/cobalt/browser/application.cc b/cobalt/browser/application.cc
index d710cae..5fa7318 100644
--- a/cobalt/browser/application.cc
+++ b/cobalt/browser/application.cc
@@ -61,6 +61,7 @@
#include "cobalt/browser/switches.h"
#include "cobalt/browser/user_agent_platform_info.h"
#include "cobalt/browser/user_agent_string.h"
+#include "cobalt/cache/cache.h"
#include "cobalt/configuration/configuration.h"
#include "cobalt/extension/crash_handler.h"
#include "cobalt/extension/installation_manager.h"
@@ -648,6 +649,9 @@
watchdog::Watchdog::CreateInstance(persistent_settings_.get());
DCHECK(watchdog);
+ cobalt::cache::Cache::GetInstance()->set_persistent_settings(
+ persistent_settings_.get());
+
base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
base::Optional<cssom::ViewportSize> requested_viewport_size =
GetRequestedViewportSize(command_line);
@@ -661,6 +665,7 @@
// Create the main components of our browser.
BrowserModule::Options options(web_options);
network_module_options.preferred_language = language;
+ network_module_options.persistent_settings = persistent_settings_.get();
options.persistent_settings = persistent_settings_.get();
options.command_line_auto_mem_settings =
memory_settings::GetSettings(*command_line);
@@ -860,7 +865,7 @@
#if SB_IS(EVERGREEN)
updater_module_.get(),
#endif
- options, persistent_settings_.get()));
+ options));
UpdateUserAgent();
diff --git a/cobalt/browser/browser_module.cc b/cobalt/browser/browser_module.cc
index 8b7b1d4..79dd071 100644
--- a/cobalt/browser/browser_module.cc
+++ b/cobalt/browser/browser_module.cc
@@ -219,16 +219,15 @@
} // namespace
-BrowserModule::BrowserModule(
- const GURL& url, base::ApplicationState initial_application_state,
- base::EventDispatcher* event_dispatcher,
- account::AccountManager* account_manager,
- network::NetworkModule* network_module,
+BrowserModule::BrowserModule(const GURL& url,
+ base::ApplicationState initial_application_state,
+ base::EventDispatcher* event_dispatcher,
+ account::AccountManager* account_manager,
+ network::NetworkModule* network_module,
#if SB_IS(EVERGREEN)
- updater::UpdaterModule* updater_module,
+ updater::UpdaterModule* updater_module,
#endif
- const Options& options,
- persistent_storage::PersistentSettings* persistent_settings)
+ const Options& options)
: ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
ALLOW_THIS_IN_INITIALIZER_LIST(
weak_this_(weak_ptr_factory_.GetWeakPtr())),
@@ -298,8 +297,7 @@
next_timeline_id_(1),
current_splash_screen_timeline_id_(-1),
current_main_web_module_timeline_id_(-1),
- service_worker_registry_(network_module),
- persistent_settings_(persistent_settings) {
+ service_worker_registry_(network_module) {
TRACE_EVENT0("cobalt::browser", "BrowserModule::BrowserModule()");
// Apply platform memory setting adjustments and defaults.
@@ -2075,7 +2073,7 @@
dom_settings->window()->navigator()->user_agent_data();
h5vcc_settings.global_environment =
dom_settings->context()->global_environment();
- h5vcc_settings.persistent_settings = persistent_settings_;
+ h5vcc_settings.persistent_settings = options_.persistent_settings;
auto* h5vcc_object = new h5vcc::H5vcc(h5vcc_settings);
if (!web_module_created_callback_.is_null()) {
diff --git a/cobalt/browser/browser_module.h b/cobalt/browser/browser_module.h
index 0706039..a12551e 100644
--- a/cobalt/browser/browser_module.h
+++ b/cobalt/browser/browser_module.h
@@ -131,8 +131,7 @@
#if SB_IS(EVERGREEN)
updater::UpdaterModule* updater_module,
#endif
- const Options& options,
- persistent_storage::PersistentSettings* persistent_settings);
+ const Options& options);
~BrowserModule();
std::string GetUserAgent() { return network_module_->GetUserAgent(); }
@@ -724,8 +723,6 @@
// Manages the Service Workers.
ServiceWorkerRegistry service_worker_registry_;
-
- persistent_storage::PersistentSettings* persistent_settings_;
};
} // namespace browser
diff --git a/cobalt/build/ninja/README b/cobalt/build/ninja/README
deleted file mode 100644
index fe0f765..0000000
--- a/cobalt/build/ninja/README
+++ /dev/null
@@ -1,7 +0,0 @@
-ninja-win.exe built with MSVC 2012
-from
-https://github.com/REDACTED/ninja/commit/1287257fe343c4b6b0f760308a7bec52d86b0edf
-
-ninja-linux built with gcc
-from
-https://github.com/REDACTED/ninja/commit/613d89893e56acc8c3670a66a33fcd2caf7d9050
diff --git a/cobalt/build/ninja/ninja-linux b/cobalt/build/ninja/ninja-linux
deleted file mode 100755
index 1f30022..0000000
--- a/cobalt/build/ninja/ninja-linux
+++ /dev/null
Binary files differ
diff --git a/cobalt/build/ninja/ninja-linux32.armv7l b/cobalt/build/ninja/ninja-linux32.armv7l
deleted file mode 100644
index cb4c3ec..0000000
--- a/cobalt/build/ninja/ninja-linux32.armv7l
+++ /dev/null
Binary files differ
diff --git a/cobalt/build/ninja/ninja-win.exe b/cobalt/build/ninja/ninja-win.exe
deleted file mode 100755
index 4a68328..0000000
--- a/cobalt/build/ninja/ninja-win.exe
+++ /dev/null
Binary files differ
diff --git a/cobalt/cache/BUILD.gn b/cobalt/cache/BUILD.gn
index 7fe8ddd..edc1daf 100644
--- a/cobalt/cache/BUILD.gn
+++ b/cobalt/cache/BUILD.gn
@@ -22,6 +22,7 @@
"//base",
"//cobalt/base",
"//cobalt/configuration",
+ "//cobalt/persistent_storage:persistent_settings",
"//net",
"//starboard:starboard_headers_only",
]
diff --git a/cobalt/cache/cache.cc b/cobalt/cache/cache.cc
index 0600895..e2c568d 100644
--- a/cobalt/cache/cache.cc
+++ b/cobalt/cache/cache.cc
@@ -24,6 +24,8 @@
#include "base/optional.h"
#include "cobalt/configuration/configuration.h"
#include "cobalt/extension/javascript_cache.h"
+#include "cobalt/persistent_storage/persistent_settings.h"
+#include "net/disk_cache/cobalt/cobalt_backend_impl.h"
#include "starboard/configuration_constants.h"
#include "starboard/system.h"
@@ -86,14 +88,6 @@
return nullptr;
}
-bool CanCache(disk_cache::ResourceType resource_type, uint32_t data_size) {
- return cobalt::configuration::Configuration::GetInstance()
- ->CobaltCanStoreCompiledJavascript() &&
- data_size > 0u &&
- data_size >= GetMinSizeToCacheInBytes(resource_type) &&
- data_size <= GetMaxCacheStorageInBytes(resource_type);
-}
-
} // namespace
namespace cobalt {
@@ -158,6 +152,19 @@
return data;
}
+void Cache::set_enabled(bool enabled) { enabled_ = enabled; }
+
+void Cache::set_persistent_settings(
+ persistent_storage::PersistentSettings* persistent_settings) {
+ persistent_settings_ = persistent_settings;
+
+ // Guaranteed to be called before any calls to Retrieve()
+ // since set_persistent_settings() is called from the Application()
+ // constructor before the NetworkModule is initialized.
+ set_enabled(persistent_settings_->GetPersistentSettingAsBool(
+ disk_cache::kCacheEnabledPersistentSettingsKey, true));
+}
+
MemoryCappedDirectory* Cache::GetMemoryCappedDirectory(
disk_cache::ResourceType resource_type) {
base::AutoLock auto_lock(lock_);
@@ -221,5 +228,15 @@
}
}
+bool Cache::CanCache(disk_cache::ResourceType resource_type,
+ uint32_t data_size) {
+ return enabled_ &&
+ cobalt::configuration::Configuration::GetInstance()
+ ->CobaltCanStoreCompiledJavascript() &&
+ data_size > 0u &&
+ data_size >= GetMinSizeToCacheInBytes(resource_type) &&
+ data_size <= GetMaxCacheStorageInBytes(resource_type);
+}
+
} // namespace cache
} // namespace cobalt
diff --git a/cobalt/cache/cache.h b/cobalt/cache/cache.h
index 790da73..4f9e4fe 100644
--- a/cobalt/cache/cache.h
+++ b/cobalt/cache/cache.h
@@ -27,6 +27,7 @@
#include "base/synchronization/lock.h"
#include "base/synchronization/waitable_event.h"
#include "cobalt/cache/memory_capped_directory.h"
+#include "cobalt/persistent_storage/persistent_settings.h"
#include "net/disk_cache/cobalt/resource_type.h"
namespace base {
@@ -45,6 +46,11 @@
disk_cache::ResourceType resource_type, uint32_t key,
std::function<std::unique_ptr<std::vector<uint8_t>>()> generate);
+ void set_enabled(bool enabled);
+
+ void set_persistent_settings(
+ persistent_storage::PersistentSettings* persistent_settings);
+
private:
friend struct base::DefaultSingletonTraits<Cache>;
Cache() {}
@@ -56,6 +62,7 @@
void Notify(disk_cache::ResourceType resource_type, uint32_t key);
void TryStore(disk_cache::ResourceType resource_type, uint32_t key,
const std::vector<uint8_t>& data);
+ bool CanCache(disk_cache::ResourceType resource_type, uint32_t data_size);
mutable base::Lock lock_;
// The following map is only used when the JavaScript cache extension is
@@ -65,6 +72,9 @@
std::map<disk_cache::ResourceType,
std::map<uint32_t, std::vector<base::WaitableEvent*>>>
pending_;
+ bool enabled_;
+
+ persistent_storage::PersistentSettings* persistent_settings_;
DISALLOW_COPY_AND_ASSIGN(Cache);
}; // class Cache
diff --git a/cobalt/evergreen_tests/evergreen_tests.py b/cobalt/evergreen_tests/evergreen_tests.py
index 74eafb0..00d23ae 100644
--- a/cobalt/evergreen_tests/evergreen_tests.py
+++ b/cobalt/evergreen_tests/evergreen_tests.py
@@ -31,6 +31,7 @@
def _Exec(cmd, env=None):
+ """Executes a command in a subprocess and returns the result."""
try:
msg = 'Executing:\n ' + ' '.join(cmd)
logging.info(msg)
@@ -46,31 +47,8 @@
return 1
-def main():
- arg_parser = argparse.ArgumentParser()
- arg_parser.add_argument(
- '--no-can_mount_tmpfs',
- dest='can_mount_tmpfs',
- action='store_false',
- help='A temporary filesystem cannot be mounted on the target device.')
- arg_parser.add_argument(
- '--platform_under_test',
- default=_DEFAULT_PLATFORM_UNDER_TEST,
- help='The platform to run the tests on (e.g., linux or raspi).')
- authentication_method = arg_parser.add_mutually_exclusive_group()
- authentication_method.add_argument(
- '--public-key-auth',
- help='Public key authentication should be used with the remote device.',
- action='store_true')
- authentication_method.add_argument(
- '--password-auth',
- help='Password authentication should be used with the remote device.',
- action='store_true')
- command_line.AddLauncherArguments(arg_parser)
- args = arg_parser.parse_args()
-
- log_level.InitializeLogging(args)
-
+def _RunTests(arg_parser, args, use_compressed_system_image):
+ """Runs an instance of the Evergreen tests for the provided configuration."""
launcher_params = command_line.CreateLauncherParams(arg_parser)
# Creating an instance of the Evergreen abstract launcher implementation
@@ -86,7 +64,8 @@
loader_platform=launcher_params.loader_platform,
loader_config=launcher_params.loader_config,
loader_target='loader_app',
- loader_out_directory=launcher_params.loader_out_directory)
+ loader_out_directory=launcher_params.loader_out_directory,
+ use_compressed_library=use_compressed_system_image)
# The automated tests use the |OUT| environment variable as the path to a
# known directory structure containing the desired binaries. This path is
@@ -118,10 +97,52 @@
command.append('-a')
command.append('password')
+ if use_compressed_system_image:
+ command.append('-c')
+
command.append(args.platform_under_test)
return _Exec(command, env)
+def main():
+ arg_parser = argparse.ArgumentParser()
+ arg_parser.add_argument(
+ '--no-can_mount_tmpfs',
+ dest='can_mount_tmpfs',
+ action='store_false',
+ help='A temporary filesystem cannot be mounted on the target device.')
+ arg_parser.add_argument(
+ '--platform_under_test',
+ default=_DEFAULT_PLATFORM_UNDER_TEST,
+ help='The platform to run the tests on (e.g., linux or raspi).')
+ authentication_method = arg_parser.add_mutually_exclusive_group()
+ authentication_method.add_argument(
+ '--public-key-auth',
+ help='Public key authentication should be used with the remote device.',
+ action='store_true')
+ authentication_method.add_argument(
+ '--password-auth',
+ help='Password authentication should be used with the remote device.',
+ action='store_true')
+ arg_parser.add_argument(
+ '--no-rerun_using_compressed_system_image',
+ dest='rerun_using_compressed_system_image',
+ action='store_false',
+ help='Do not run a second instance of the tests with a compressed system '
+ 'image.')
+ command_line.AddLauncherArguments(arg_parser)
+ args = arg_parser.parse_args()
+
+ log_level.InitializeLogging(args)
+
+ uncompressed_system_image_result = _RunTests(arg_parser, args, False)
+ if args.rerun_using_compressed_system_image:
+ compressed_system_image_result = _RunTests(arg_parser, args, True)
+ return uncompressed_system_image_result or compressed_system_image_result
+
+ return uncompressed_system_image_result
+
+
if __name__ == '__main__':
sys.exit(main())
diff --git a/cobalt/h5vcc/BUILD.gn b/cobalt/h5vcc/BUILD.gn
index 246c396..9c5a145 100644
--- a/cobalt/h5vcc/BUILD.gn
+++ b/cobalt/h5vcc/BUILD.gn
@@ -76,6 +76,7 @@
"//cobalt/base",
"//cobalt/browser:browser_switches",
"//cobalt/build:cobalt_build_id",
+ "//cobalt/cache",
"//cobalt/configuration",
"//cobalt/dom",
"//cobalt/media",
diff --git a/cobalt/h5vcc/h5vcc_storage.cc b/cobalt/h5vcc/h5vcc_storage.cc
index e9a9229..dbb6b3b 100644
--- a/cobalt/h5vcc/h5vcc_storage.cc
+++ b/cobalt/h5vcc/h5vcc_storage.cc
@@ -19,10 +19,14 @@
#include "base/files/file_util.h"
#include "base/values.h"
+#include "cobalt/cache/cache.h"
#include "cobalt/h5vcc/h5vcc_storage.h"
#include "cobalt/persistent_storage/persistent_settings.h"
#include "cobalt/storage/storage_manager.h"
+#include "net/disk_cache/cobalt/cobalt_backend_impl.h"
#include "net/disk_cache/cobalt/resource_type.h"
+#include "net/http/http_cache.h"
+#include "net/http/http_transaction_factory.h"
#include "starboard/common/file.h"
#include "starboard/common/string.h"
@@ -31,6 +35,7 @@
namespace h5vcc {
namespace {
+
const char kTestFileName[] = "cache_test_file.json";
const uint32 kWriteBufferSize = 1024 * 1024;
@@ -69,7 +74,16 @@
network::NetworkModule* network_module,
persistent_storage::PersistentSettings* persistent_settings)
: network_module_(network_module),
- persistent_settings_(persistent_settings) {}
+ persistent_settings_(persistent_settings) {
+ http_cache_ = nullptr;
+ if (network_module == nullptr) {
+ return;
+ }
+ auto url_request_context = network_module_->url_request_context();
+ if (url_request_context->using_http_cache()) {
+ http_cache_ = url_request_context->http_transaction_factory()->GetCache();
+ }
+}
void H5vccStorage::ClearCookies() {
net::CookieStore* cookie_store =
@@ -334,5 +348,29 @@
return quota;
}
+void H5vccStorage::EnableCache() {
+ persistent_settings_->SetPersistentSetting(
+ disk_cache::kCacheEnabledPersistentSettingsKey,
+ std::make_unique<base::Value>(true));
+
+ cobalt::cache::Cache::GetInstance()->set_enabled(true);
+
+ if (http_cache_) {
+ http_cache_->set_mode(net::HttpCache::Mode::NORMAL);
+ }
+}
+
+void H5vccStorage::DisableCache() {
+ persistent_settings_->SetPersistentSetting(
+ disk_cache::kCacheEnabledPersistentSettingsKey,
+ std::make_unique<base::Value>(false));
+
+ cobalt::cache::Cache::GetInstance()->set_enabled(false);
+
+ if (http_cache_) {
+ http_cache_->set_mode(net::HttpCache::Mode::DISABLE);
+ }
+}
+
} // namespace h5vcc
} // namespace cobalt
diff --git a/cobalt/h5vcc/h5vcc_storage.h b/cobalt/h5vcc/h5vcc_storage.h
index 7f6368b..ff96351 100644
--- a/cobalt/h5vcc/h5vcc_storage.h
+++ b/cobalt/h5vcc/h5vcc_storage.h
@@ -26,6 +26,7 @@
#include "cobalt/network/network_module.h"
#include "cobalt/persistent_storage/persistent_settings.h"
#include "cobalt/script/wrappable.h"
+#include "net/http/http_cache.h"
namespace cobalt {
namespace h5vcc {
@@ -56,6 +57,10 @@
H5vccStorageSetQuotaResponse SetQuota(
H5vccStorageResourceTypeQuotaBytesDictionary quota);
+ void EnableCache();
+
+ void DisableCache();
+
DEFINE_WRAPPABLE_TYPE(H5vccStorage);
private:
@@ -63,6 +68,8 @@
persistent_storage::PersistentSettings* persistent_settings_;
+ net::HttpCache* http_cache_;
+
DISALLOW_COPY_AND_ASSIGN(H5vccStorage);
};
diff --git a/cobalt/h5vcc/h5vcc_storage.idl b/cobalt/h5vcc/h5vcc_storage.idl
index 3a45910..93a6d37 100644
--- a/cobalt/h5vcc/h5vcc_storage.idl
+++ b/cobalt/h5vcc/h5vcc_storage.idl
@@ -24,4 +24,7 @@
H5vccStorageResourceTypeQuotaBytesDictionary getQuota();
H5vccStorageSetQuotaResponse setQuota(H5vccStorageResourceTypeQuotaBytesDictionary quota);
+
+ void enableCache();
+ void disableCache();
};
diff --git a/cobalt/network/BUILD.gn b/cobalt/network/BUILD.gn
index a68d213..53821e9 100644
--- a/cobalt/network/BUILD.gn
+++ b/cobalt/network/BUILD.gn
@@ -51,6 +51,7 @@
"//cobalt/build:cobalt_build_id",
"//cobalt/configuration",
"//cobalt/network_bridge",
+ "//cobalt/persistent_storage:persistent_settings",
"//cobalt/storage",
"//starboard/common",
"//third_party/protobuf:protobuf_lite",
diff --git a/cobalt/network/network_module.cc b/cobalt/network/network_module.cc
index 4eae9a8..f192961 100644
--- a/cobalt/network/network_module.cc
+++ b/cobalt/network/network_module.cc
@@ -178,7 +178,8 @@
#endif
url_request_context_.reset(
new URLRequestContext(storage_manager_, options_.custom_proxy, net_log,
- options_.ignore_certificate_errors, task_runner()));
+ options_.ignore_certificate_errors, task_runner(),
+ options_.persistent_settings));
network_delegate_.reset(
new NetworkDelegate(options_.cookie_policy, options_.https_requirement));
url_request_context_->set_http_user_agent_settings(
diff --git a/cobalt/network/network_module.h b/cobalt/network/network_module.h
index be655f9..ee04620 100644
--- a/cobalt/network/network_module.h
+++ b/cobalt/network/network_module.h
@@ -28,6 +28,7 @@
#include "cobalt/network/network_delegate.h"
#include "cobalt/network/url_request_context.h"
#include "cobalt/network/url_request_context_getter.h"
+#include "cobalt/persistent_storage/persistent_settings.h"
#include "net/base/static_cookie_policy.h"
#include "url/gurl.h"
#if defined(DIAL_SERVER)
@@ -60,13 +61,15 @@
ignore_certificate_errors(false),
https_requirement(network::kHTTPSRequired),
preferred_language("en-US"),
- max_network_delay(0) {}
+ max_network_delay(0),
+ persistent_settings(nullptr) {}
net::StaticCookiePolicy::Type cookie_policy;
bool ignore_certificate_errors;
HTTPSRequirement https_requirement;
std::string preferred_language;
std::string custom_proxy;
SbTime max_network_delay;
+ persistent_storage::PersistentSettings* persistent_settings;
};
// Simple constructor intended to be used only by tests.
diff --git a/cobalt/network/url_request_context.cc b/cobalt/network/url_request_context.cc
index 020410c..34cc482 100644
--- a/cobalt/network/url_request_context.cc
+++ b/cobalt/network/url_request_context.cc
@@ -26,12 +26,14 @@
#include "cobalt/network/persistent_cookie_store.h"
#include "cobalt/network/proxy_config_service.h"
#include "cobalt/network/switches.h"
+#include "cobalt/persistent_storage/persistent_settings.h"
#include "net/cert/cert_net_fetcher.h"
#include "net/cert/cert_verifier.h"
#include "net/cert/cert_verify_proc.h"
#include "net/cert/ct_policy_enforcer.h"
#include "net/cert/do_nothing_ct_verifier.h"
#include "net/cert_net/cert_net_fetcher_impl.h"
+#include "net/disk_cache/cobalt/cobalt_backend_impl.h"
#include "net/dns/host_cache.h"
#include "net/http/http_auth_handler_factory.h"
#include "net/http/http_cache.h"
@@ -68,7 +70,8 @@
URLRequestContext::URLRequestContext(
storage::StorageManager* storage_manager, const std::string& custom_proxy,
net::NetLog* net_log, bool ignore_certificate_errors,
- scoped_refptr<base::SingleThreadTaskRunner> network_task_runner)
+ scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
+ persistent_storage::PersistentSettings* persistent_settings)
: ALLOW_THIS_IN_INITIALIZER_LIST(storage_(this))
#if defined(ENABLE_DEBUGGER)
,
@@ -176,6 +179,8 @@
std::unique_ptr<net::HttpNetworkLayer>(
new net::HttpNetworkLayer(storage_.http_network_session())));
} else {
+ using_http_cache_ = true;
+
// TODO: Set max size of cache in Starboard.
const int cache_size_mb = 24;
auto http_cache = std::make_unique<net::HttpCache>(
@@ -185,6 +190,15 @@
base::FilePath(std::string(path.data())),
/* max_bytes */ 1024 * 1024 * cache_size_mb),
true);
+ if (persistent_settings != nullptr) {
+ auto cache_enabled = persistent_settings->GetPersistentSettingAsBool(
+ disk_cache::kCacheEnabledPersistentSettingsKey, true);
+
+ if (!cache_enabled) {
+ http_cache->set_mode(net::HttpCache::Mode::DISABLE);
+ }
+ }
+
storage_.set_http_transaction_factory(std::move(http_cache));
}
@@ -214,6 +228,8 @@
storage_.http_network_session()->SetEnableQuic(enable_quic);
}
+bool URLRequestContext::using_http_cache() { return using_http_cache_; }
+
#if defined(ENABLE_DEBUGGER)
void URLRequestContext::OnQuicToggle(const std::string& message) {
DCHECK(storage_.http_network_session());
diff --git a/cobalt/network/url_request_context.h b/cobalt/network/url_request_context.h
index 074fcdb..8f673c3 100644
--- a/cobalt/network/url_request_context.h
+++ b/cobalt/network/url_request_context.h
@@ -20,6 +20,7 @@
#include "base/basictypes.h"
#include "base/macros.h"
#include "base/threading/thread_checker.h"
+#include "cobalt/persistent_storage/persistent_settings.h"
#include "net/cookies/cookie_monster.h"
#include "net/log/net_log.h"
#include "net/url_request/url_request_context.h"
@@ -42,19 +43,24 @@
URLRequestContext(
storage::StorageManager* storage_manager, const std::string& custom_proxy,
net::NetLog* net_log, bool ignore_certificate_errors,
- scoped_refptr<base::SingleThreadTaskRunner> network_task_runner);
+ scoped_refptr<base::SingleThreadTaskRunner> network_task_runner,
+ persistent_storage::PersistentSettings* persistent_settings);
~URLRequestContext() override;
void SetProxy(const std::string& custom_proxy_rules);
void SetEnableQuic(bool enable_quic);
+ bool using_http_cache();
+
private:
THREAD_CHECKER(thread_checker_);
net::URLRequestContextStorage storage_;
scoped_refptr<net::CookieMonster::PersistentCookieStore>
persistent_cookie_store_;
+ bool using_http_cache_;
+
#if defined(ENABLE_DEBUGGER)
// Command handler object for toggling the input fuzzer on/off.
debug::console::ConsoleCommandManager::CommandHandler
diff --git a/cobalt/persistent_storage/persistent_settings.cc b/cobalt/persistent_storage/persistent_settings.cc
index d420c0e..ffebc2a 100644
--- a/cobalt/persistent_storage/persistent_settings.cc
+++ b/cobalt/persistent_storage/persistent_settings.cc
@@ -12,11 +12,12 @@
// See the License for the specific language governing permissions and
// limitations under the License.
+#include "cobalt/persistent_storage/persistent_settings.h"
+
#include <utility>
#include <vector>
#include "base/values.h"
-#include "cobalt/persistent_storage/persistent_settings.h"
#include "starboard/common/file.h"
#include "starboard/common/log.h"
#include "starboard/configuration_constants.h"
diff --git a/cobalt/script/promise.h b/cobalt/script/promise.h
index 6fa4b54..d9e1c17 100644
--- a/cobalt/script/promise.h
+++ b/cobalt/script/promise.h
@@ -15,6 +15,9 @@
#ifndef COBALT_SCRIPT_PROMISE_H_
#define COBALT_SCRIPT_PROMISE_H_
+#include <memory>
+
+#include "base/callback.h"
#include "base/memory/ref_counted.h"
#include "cobalt/script/exception_message.h"
#include "cobalt/script/script_exception.h"
@@ -42,21 +45,19 @@
public:
// Call the |resolve| function that was passed as an argument to the Promise's
// executor function supplying |result| as its argument.
- virtual void Resolve(const T& result) const { NOTREACHED(); }
+ virtual void Resolve(const T& result) const = 0;
// Call the |reject| function passed as an argument to the Promise's executor
// function.
- virtual void Reject() const { NOTREACHED(); }
- virtual void Reject(SimpleExceptionType exception) const { NOTREACHED(); }
- virtual void Reject(const scoped_refptr<ScriptException>& result) const {
- NOTREACHED();
- }
+ virtual void Reject() const = 0;
+ virtual void Reject(SimpleExceptionType exception) const = 0;
+ virtual void Reject(const scoped_refptr<ScriptException>& result) const = 0;
// Returns the value of the [[PromiseState]] field.
- virtual PromiseState State() const {
- NOTREACHED();
- return PromiseState::kRejected;
- }
+ virtual PromiseState State() const = 0;
+
+ virtual void AddStateChangeCallback(
+ std::unique_ptr<base::OnceCallback<void()>> callback) = 0;
virtual ~Promise() {}
};
diff --git a/cobalt/script/v8c/conversion_helpers.h b/cobalt/script/v8c/conversion_helpers.h
index 85aa597..81bf303 100644
--- a/cobalt/script/v8c/conversion_helpers.h
+++ b/cobalt/script/v8c/conversion_helpers.h
@@ -16,7 +16,6 @@
#define COBALT_SCRIPT_V8C_CONVERSION_HELPERS_H_
#include <cmath>
-
#include <limits>
#include <string>
#include <utility>
@@ -29,6 +28,7 @@
#include "cobalt/base/compiler.h"
#include "cobalt/base/enable_if.h"
#include "cobalt/base/token.h"
+#include "cobalt/script/promise.h"
#include "cobalt/script/sequence.h"
#include "cobalt/script/v8c/algorithm_helpers.h"
#include "cobalt/script/v8c/helpers.h"
@@ -713,11 +713,7 @@
template <typename T>
void FromJSValue(v8::Isolate* isolate, v8::Local<v8::Value> value,
int conversion_flags, ExceptionState* exception_state,
- script::Promise<T>* out_promise) {
- // TODO(b/228976500): Implement conversion from JS to native for Promise<T>.
- // https://webidl.spec.whatwg.org/#es-promise
- NOTIMPLEMENTED();
-}
+ script::Promise<T>* out_promise);
// script::Handle<T> -> JSValue
template <typename T>
diff --git a/cobalt/script/v8c/native_promise.h b/cobalt/script/v8c/native_promise.h
index 85069c7..ab8b323 100644
--- a/cobalt/script/v8c/native_promise.h
+++ b/cobalt/script/v8c/native_promise.h
@@ -15,12 +15,15 @@
#ifndef COBALT_SCRIPT_V8C_NATIVE_PROMISE_H_
#define COBALT_SCRIPT_V8C_NATIVE_PROMISE_H_
+#include <memory>
+
#include "base/logging.h"
#include "base/threading/thread_checker.h"
#include "cobalt/script/promise.h"
#include "cobalt/script/v8c/conversion_helpers.h"
#include "cobalt/script/v8c/entry_scope.h"
#include "cobalt/script/v8c/scoped_persistent.h"
+#include "cobalt/script/v8c/script_promise.h"
#include "cobalt/script/v8c/type_traits.h"
#include "cobalt/script/v8c/v8c_exception_state.h"
#include "cobalt/script/v8c/v8c_user_object_holder.h"
@@ -40,10 +43,9 @@
*out_value = v8::Undefined(isolate);
}
-// Shared functionality for NativePromise<T>. Does not implement the Resolve
-// function, since that needs to be specialized for Promise<T>.
+// Shared functionality for NativePromise<T>.
template <typename T>
-class NativePromise : public ScopedPersistent<v8::Value>, public Promise<T> {
+class NativePromise : public ScriptPromise<T> {
public:
// ScriptValue boilerplate.
typedef Promise<T> BaseType;
@@ -63,20 +65,20 @@
PromiseResultUndefined, T>::type;
NativePromise(v8::Isolate* isolate, v8::Local<v8::Value> resolver)
- : isolate_(isolate), ScopedPersistent(isolate, resolver) {
+ : ScriptPromise<T>(isolate, resolver) {
DCHECK(resolver->IsPromise());
}
void Resolve(const ResolveType& value) const override {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(!this->IsEmpty());
- DCHECK(State() == PromiseState::kPending);
- EntryScope entry_scope(isolate_);
- v8::Local<v8::Context> context = isolate_->GetCurrentContext();
+ DCHECK(this->State() == PromiseState::kPending);
+ EntryScope entry_scope(this->isolate());
+ v8::Local<v8::Context> context = this->isolate()->GetCurrentContext();
v8::Local<v8::Promise::Resolver> promise_resolver = this->resolver();
v8::Local<v8::Value> converted_value;
- ToJSValue(isolate_, value, &converted_value);
+ ToJSValue(this->isolate(), value, &converted_value);
v8::Maybe<bool> reject_result =
promise_resolver->Resolve(context, converted_value);
DCHECK(reject_result.FromJust());
@@ -85,25 +87,26 @@
void Reject() const override {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(!this->IsEmpty());
- DCHECK(State() == PromiseState::kPending);
- EntryScope entry_scope(isolate_);
- v8::Local<v8::Context> context = isolate_->GetCurrentContext();
+ DCHECK(this->State() == PromiseState::kPending);
+ EntryScope entry_scope(this->isolate());
+ v8::Local<v8::Context> context = this->isolate()->GetCurrentContext();
v8::Local<v8::Promise::Resolver> promise_resolver = this->resolver();
v8::Maybe<bool> reject_result =
- promise_resolver->Reject(context, v8::Undefined(isolate_));
+ promise_resolver->Reject(context, v8::Undefined(this->isolate()));
DCHECK(reject_result.FromJust());
}
void Reject(SimpleExceptionType exception) const override {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(!this->IsEmpty());
- DCHECK(State() == PromiseState::kPending);
- EntryScope entry_scope(isolate_);
- v8::Local<v8::Context> context = isolate_->GetCurrentContext();
+ DCHECK(this->State() == PromiseState::kPending);
+ EntryScope entry_scope(this->isolate());
+ v8::Local<v8::Context> context = this->isolate()->GetCurrentContext();
v8::Local<v8::Promise::Resolver> promise_resolver = this->resolver();
- v8::Local<v8::Value> error_result = CreateErrorObject(isolate_, exception);
+ v8::Local<v8::Value> error_result =
+ CreateErrorObject(this->isolate(), exception);
v8::Maybe<bool> reject_result =
promise_resolver->Reject(context, error_result);
DCHECK(reject_result.FromJust());
@@ -112,51 +115,22 @@
void Reject(const scoped_refptr<ScriptException>& result) const override {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
DCHECK(!this->IsEmpty());
- DCHECK(State() == PromiseState::kPending);
- EntryScope entry_scope(isolate_);
- v8::Local<v8::Context> context = isolate_->GetCurrentContext();
+ DCHECK(this->State() == PromiseState::kPending);
+ EntryScope entry_scope(this->isolate());
+ v8::Local<v8::Context> context = this->isolate()->GetCurrentContext();
v8::Local<v8::Promise::Resolver> promise_resolver = this->resolver();
v8::Local<v8::Value> converted_result;
- ToJSValue(isolate_, result, &converted_result);
+ ToJSValue(this->isolate(), result, &converted_result);
v8::Maybe<bool> reject_result =
promise_resolver->Reject(context, converted_result);
DCHECK(reject_result.FromJust());
}
- PromiseState State() const override {
- DCHECK(!this->IsEmpty());
- EntryScope entry_scope(isolate_);
-
- v8::Promise::PromiseState v8_promise_state = this->promise()->State();
- switch (v8_promise_state) {
- case v8::Promise::kPending:
- return PromiseState::kPending;
- case v8::Promise::kFulfilled:
- return PromiseState::kFulfilled;
- case v8::Promise::kRejected:
- return PromiseState::kRejected;
- }
- NOTREACHED();
- return PromiseState::kRejected;
- }
-
- v8::Local<v8::Promise> promise() const {
- DCHECK(!this->IsEmpty());
- return resolver()->GetPromise();
- }
-
private:
- v8::Isolate* isolate_;
-
// Thread checker ensures all calls to the Promise are made from the same
// thread that it is created in.
THREAD_CHECKER(thread_checker_);
-
- v8::Local<v8::Promise::Resolver> resolver() const {
- DCHECK(!this->IsEmpty());
- return this->Get().Get(isolate_).template As<v8::Promise::Resolver>();
- }
};
template <typename T>
diff --git a/cobalt/script/v8c/script_promise.h b/cobalt/script/v8c/script_promise.h
new file mode 100644
index 0000000..93c4561
--- /dev/null
+++ b/cobalt/script/v8c/script_promise.h
@@ -0,0 +1,148 @@
+// 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_SCRIPT_V8C_SCRIPT_PROMISE_H_
+#define COBALT_SCRIPT_V8C_SCRIPT_PROMISE_H_
+
+#include <memory>
+#include <utility>
+
+#include "base/logging.h"
+#include "base/threading/thread_checker.h"
+#include "cobalt/script/promise.h"
+#include "cobalt/script/v8c/conversion_helpers.h"
+#include "cobalt/script/v8c/entry_scope.h"
+#include "cobalt/script/v8c/scoped_persistent.h"
+#include "cobalt/script/v8c/type_traits.h"
+#include "cobalt/script/v8c/v8c_exception_state.h"
+#include "cobalt/script/v8c/v8c_user_object_holder.h"
+#include "v8/include/v8.h"
+
+namespace cobalt {
+namespace script {
+namespace v8c {
+
+// Shared functionality for ScriptPromise<T>. Does not implement the Resolve
+// function, since that needs to be specialized for Promise<T>.
+template <typename T>
+class ScriptPromise : public ScopedPersistent<v8::Value>, public Promise<T> {
+ public:
+ // ScriptValue boilerplate.
+ typedef Promise<T> BaseType;
+
+ // Handle special case T=void, by swapping the input parameter |T| for
+ // |PromiseResultUndefined|. Combined with how |Promise| handles this
+ // special case, we're left with something like:
+ //
+ // NativePromise<T> -> Promise<T>
+ // ^
+ // | (T=PromiseResultUndefined)
+ // /
+ // NativePromise<void> -> Promise<void>
+ //
+ using ResolveType =
+ typename std::conditional<std::is_same<T, void>::value,
+ PromiseResultUndefined, T>::type;
+
+ ScriptPromise(v8::Isolate* isolate, v8::Local<v8::Value> resolver)
+ : isolate_(isolate), ScopedPersistent(isolate, resolver) {
+ DCHECK(resolver->IsPromise());
+ }
+
+ void Resolve(const ResolveType& value) const override { NOTREACHED(); }
+
+ void Reject() const override { NOTREACHED(); }
+
+ void Reject(SimpleExceptionType exception) const override { NOTREACHED(); }
+
+ void Reject(const scoped_refptr<ScriptException>& result) const override {
+ NOTREACHED();
+ }
+
+ PromiseState State() const override {
+ DCHECK(!this->IsEmpty());
+ EntryScope entry_scope(isolate_);
+
+ v8::Promise::PromiseState v8_promise_state = this->promise()->State();
+ switch (v8_promise_state) {
+ case v8::Promise::kPending:
+ return PromiseState::kPending;
+ case v8::Promise::kFulfilled:
+ return PromiseState::kFulfilled;
+ case v8::Promise::kRejected:
+ return PromiseState::kRejected;
+ }
+ NOTREACHED();
+ return PromiseState::kRejected;
+ }
+
+ void AddStateChangeCallback(
+ std::unique_ptr<base::OnceCallback<void()>> callback) override {
+ v8::Local<v8::Context> context = context_.NewLocal(isolate_);
+
+ auto callback_lambda = [](const v8::FunctionCallbackInfo<v8::Value>& info) {
+ auto* callback = static_cast<base::OnceCallback<void()>*>(
+ info.Data().As<v8::External>()->Value());
+ DCHECK(callback);
+ std::move(*callback).Run();
+ delete callback;
+ };
+ v8::Local<v8::Function> function =
+ v8::Function::New(isolate_->GetCurrentContext(), callback_lambda,
+ v8::External::New(isolate_, callback.release()))
+ .ToLocalChecked();
+ v8::Local<v8::Promise> result_promise;
+ if (!promise()
+ ->Then(context, function, function)
+ .ToLocal(&result_promise)) {
+ DLOG(ERROR) << "Unable to add promise state change callback.";
+ NOTREACHED();
+ }
+ }
+
+ v8::Local<v8::Promise> promise() const {
+ DCHECK(!this->IsEmpty());
+ return resolver()->GetPromise();
+ }
+
+ protected:
+ v8::Local<v8::Promise::Resolver> resolver() const {
+ DCHECK(!this->IsEmpty());
+ return this->Get().Get(isolate_).template As<v8::Promise::Resolver>();
+ }
+
+ v8::Isolate* isolate() const { return isolate_; }
+
+ private:
+ v8::Isolate* isolate_;
+ ScopedPersistent<v8::Context> context_;
+};
+
+// JSValue -> Promise
+template <typename T>
+void FromJSValue(v8::Isolate* isolate, v8::Local<v8::Value> value,
+ int conversion_flags, ExceptionState* exception_state,
+ std::unique_ptr<script::Promise<T*>>* out_promise) {
+ if (!value->IsPromise()) {
+ exception_state->SetSimpleException(kNotSupportedType);
+ return;
+ }
+ out_promise->reset(new ScriptPromise<T*>(isolate, value));
+}
+
+} // namespace v8c
+} // namespace script
+} // namespace cobalt
+
+#endif // COBALT_SCRIPT_V8C_SCRIPT_PROMISE_H_
diff --git a/cobalt/worker/extendable_event.h b/cobalt/worker/extendable_event.h
index 4e5d4ff..1765ad2 100644
--- a/cobalt/worker/extendable_event.h
+++ b/cobalt/worker/extendable_event.h
@@ -15,15 +15,26 @@
#ifndef COBALT_WORKER_EXTENDABLE_EVENT_H_
#define COBALT_WORKER_EXTENDABLE_EVENT_H_
+#include <memory>
#include <string>
+#include <utility>
+#include "base/bind.h"
#include "cobalt/base/token.h"
#include "cobalt/script/promise.h"
#include "cobalt/script/v8c/native_promise.h"
#include "cobalt/script/value_handle.h"
#include "cobalt/script/wrappable.h"
+#include "cobalt/web/context.h"
+#include "cobalt/web/dom_exception.h"
+#include "cobalt/web/environment_settings.h"
#include "cobalt/web/event.h"
+#include "cobalt/web/window_or_worker_global_scope.h"
#include "cobalt/worker/extendable_event_init.h"
+#include "cobalt/worker/service_worker_global_scope.h"
+#include "cobalt/worker/service_worker_jobs.h"
+#include "cobalt/worker/service_worker_object.h"
+#include "cobalt/worker/service_worker_registration_object.h"
namespace cobalt {
namespace worker {
@@ -35,16 +46,87 @@
ExtendableEvent(const std::string& type, const ExtendableEventInit& init_dict)
: Event(type, init_dict) {}
- void WaitUntil(script::EnvironmentSettings* settings,
- const script::Promise<script::ValueHandle>& promise) {
- // TODO(b/228976500): Implement WaitUntil().
- NOTIMPLEMENTED();
+ void WaitUntil(
+ script::EnvironmentSettings* settings,
+ std::unique_ptr<script::Promise<script::ValueHandle*>>& promise,
+ script::ExceptionState* exception_state) {
+ // Algorithm for waitUntil(), to add lifetime promise to event.
+ // https://w3c.github.io/ServiceWorker/#dom-extendableevent-waituntil
+
+ // 1. If event’s isTrusted attribute is false, throw an "InvalidStateError"
+ // DOMException.
+ // 2. If event is not active, throw an "InvalidStateError" DOMException.
+ if (!IsActive()) {
+ web::DOMException::Raise(web::DOMException::kInvalidStateErr,
+ exception_state);
+ return;
+ }
+ // 3. Add promise to event’s extend lifetime promises.
+ // 4. Increment event’s pending promises count by one.
+ ++pending_promise_count_;
+ // 5. Upon fulfillment or rejection of promise, queue a microtask to run
+ // these substeps:
+ std::unique_ptr<base::OnceCallback<void()>> callback(
+ new base::OnceCallback<void()>(std::move(
+ base::BindOnce(&ExtendableEvent::StateChange,
+ base::Unretained(this), settings, promise.get()))));
+ promise->AddStateChangeCallback(std::move(callback));
+ promise.release();
+ }
+
+ void StateChange(script::EnvironmentSettings* settings,
+ const script::Promise<script::ValueHandle*>* promise) {
+ // Implement the microtask called upon fulfillment or rejection of a
+ // promise, as part of the algorithm for waitUntil().
+ // https://w3c.github.io/ServiceWorker/#dom-extendableevent-waituntil
+ DCHECK(promise);
+ has_rejected_promise_ |=
+ promise->State() == script::PromiseState::kRejected;
+ // 5.1. Decrement event’s pending promises count by one.
+ --pending_promise_count_;
+ // 5.2. If event’s pending promises count is 0, then:
+ if (0 == pending_promise_count_) {
+ web::Context* context =
+ base::polymorphic_downcast<web::EnvironmentSettings*>(settings)
+ ->context();
+ ServiceWorkerJobs* jobs = context->service_worker_jobs();
+ DCHECK(jobs);
+ // 5.2.1. Let registration be the current global object's associated
+ // service worker's containing service worker registration.
+ jobs->message_loop()->task_runner()->PostTask(
+ FROM_HERE,
+ base::BindOnce(&ServiceWorkerJobs::WaitUntilSubSteps,
+ base::Unretained(jobs),
+ base::Unretained(
+ context->GetWindowOrWorkerGlobalScope()
+ ->AsServiceWorker()
+ ->service_worker_object()
+ ->containing_service_worker_registration())));
+ }
+ delete promise;
+ }
+
+ bool IsActive() {
+ // An ExtendableEvent object is said to be active when its timed out flag
+ // is unset and either its pending promises count is greater than zero or
+ // its dispatch flag is set.
+ // https://w3c.github.io/ServiceWorker/#extendableevent-active
+ return !timed_out_flag_ &&
+ ((pending_promise_count_ > 0) || IsBeingDispatched());
}
DEFINE_WRAPPABLE_TYPE(ExtendableEvent);
protected:
~ExtendableEvent() override {}
+
+ private:
+ // https://w3c.github.io/ServiceWorker/#extendableevent-extend-lifetime-promises
+ // std::list<script::Promise<script::ValueHandle*>> extend_lifetime_promises_;
+ int pending_promise_count_ = 0;
+ bool has_rejected_promise_ = false;
+ // https://w3c.github.io/ServiceWorker/#extendableevent-timed-out-flag
+ bool timed_out_flag_ = false;
};
} // namespace worker
diff --git a/cobalt/worker/extendable_event.idl b/cobalt/worker/extendable_event.idl
index 2297cbc..8a12344 100644
--- a/cobalt/worker/extendable_event.idl
+++ b/cobalt/worker/extendable_event.idl
@@ -18,5 +18,5 @@
Exposed = ServiceWorker,
Constructor(DOMString type, optional ExtendableEventInit eventInitDict)
] interface ExtendableEvent : Event {
- [CallWith = EnvironmentSettings] void waitUntil(Promise<any> f);
+ [RaisesException, CallWith = EnvironmentSettings] void waitUntil(Promise<any> f);
};
diff --git a/cobalt/worker/service_worker_jobs.cc b/cobalt/worker/service_worker_jobs.cc
index f901854..9ba0101 100644
--- a/cobalt/worker/service_worker_jobs.cc
+++ b/cobalt/worker/service_worker_jobs.cc
@@ -44,6 +44,7 @@
#include "cobalt/worker/client.h"
#include "cobalt/worker/client_query_options.h"
#include "cobalt/worker/client_type.h"
+#include "cobalt/worker/extendable_event.h"
#include "cobalt/worker/frame_type.h"
#include "cobalt/worker/service_worker.h"
#include "cobalt/worker/service_worker_container.h"
@@ -891,7 +892,7 @@
// 11.3.1.2. Initialize e’s type attribute to install.
// 11.3.1.3. Dispatch e at installingWorker’s global object.
installing_worker->worker_global_scope()->DispatchEvent(
- new web::Event(base::Tokens::install()));
+ new ExtendableEvent(base::Tokens::install()));
// 11.3.1.4. WaitForAsynchronousExtensions: Run the
// following substeps in parallel:
// 11.3.1.4.1. Wait until e is not active.
@@ -1137,7 +1138,7 @@
// 11.1.1.2. Initialize e’s type attribute to activate.
// 11.1.1.3. Dispatch e at activeWorker’s global object.
active_worker->worker_global_scope()->DispatchEvent(
- new web::Event(base::Tokens::activate()));
+ new ExtendableEvent(base::Tokens::activate()));
// 11.1.1.4. WaitForAsynchronousExtensions: Wait, in
// parallel, until e is not active.
},
@@ -1837,6 +1838,23 @@
std::move(promise_reference)));
}
+void ServiceWorkerJobs::WaitUntilSubSteps(
+ ServiceWorkerRegistrationObject* registration) {
+ TRACE_EVENT0("cobalt::worker", "ServiceWorkerJobs::WaitUntilSubSteps()");
+ DCHECK_EQ(message_loop_, base::MessageLoop::current());
+ // Sub steps for WaitUntil.
+ // https://w3c.github.io/ServiceWorker/#dom-extendableevent-waituntil
+ // 5.2.2. If registration is unregistered, invoke Try Clear Registration
+ // with registration.
+ if (scope_to_registration_map_.IsUnregistered(registration)) {
+ TryClearRegistration(registration);
+ }
+ // 5.2.3. If registration is not null, invoke Try Activate with
+ // registration.
+ if (registration) {
+ TryActivate(registration);
+ }
+}
void ServiceWorkerJobs::ClientsGetSubSteps(
web::EnvironmentSettings* settings,
ServiceWorkerObject* associated_service_worker,
diff --git a/cobalt/worker/service_worker_jobs.h b/cobalt/worker/service_worker_jobs.h
index 89dd24a..8e09831 100644
--- a/cobalt/worker/service_worker_jobs.h
+++ b/cobalt/worker/service_worker_jobs.h
@@ -204,6 +204,10 @@
const base::WeakPtr<ServiceWorkerObject>& service_worker,
std::unique_ptr<script::ValuePromiseVoid::Reference> promise_reference);
+ // Sub steps for WaitUntil.
+ // https://w3c.github.io/ServiceWorker/#dom-extendableevent-waituntil
+ void WaitUntilSubSteps(ServiceWorkerRegistrationObject* registration);
+
// Parallel sub steps (2) for algorithm for Clients.get(id):
// https://w3c.github.io/ServiceWorker/#clients-get
void ClientsGetSubSteps(
diff --git a/net/disk_cache/cobalt/cobalt_backend_impl.h b/net/disk_cache/cobalt/cobalt_backend_impl.h
index c2b82f7..5a4443b 100644
--- a/net/disk_cache/cobalt/cobalt_backend_impl.h
+++ b/net/disk_cache/cobalt/cobalt_backend_impl.h
@@ -31,6 +31,8 @@
namespace disk_cache {
+const char kCacheEnabledPersistentSettingsKey[] = "cacheEnabled";
+
// This class implements the Backend interface. An object of this class handles
// the operations of the cache without writing to disk.
class NET_EXPORT_PRIVATE CobaltBackendImpl final : public Backend {
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/coat/CobaltActivity.java b/starboard/android/apk/app/src/main/java/dev/cobalt/coat/CobaltActivity.java
index a858ea3..4b05f41 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/coat/CobaltActivity.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/coat/CobaltActivity.java
@@ -29,6 +29,7 @@
import android.view.ViewGroup.LayoutParams;
import android.view.ViewParent;
import android.widget.FrameLayout;
+import dev.cobalt.media.AudioOutputManager;
import dev.cobalt.media.MediaCodecUtil;
import dev.cobalt.media.VideoSurfaceView;
import dev.cobalt.util.DisplayUtil;
@@ -37,6 +38,7 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.Locale;
/** Native activity that has the required JNI methods called by the Starboard implementation. */
public abstract class CobaltActivity extends NativeActivity {
@@ -130,6 +132,8 @@
}
DisplayUtil.cacheDefaultDisplay(this);
+ DisplayUtil.addDisplayListener(this);
+ AudioOutputManager.addAudioDeviceListener(this);
getStarboardBridge().onActivityStart(this, keyboardEditor);
super.onStart();
@@ -248,11 +252,12 @@
return;
}
- String customProxy = String.format("--proxy=\"http=http://%s:%d\"", config.first, port);
+ String customProxy =
+ String.format(Locale.US, "--proxy=\"http=http://%s:%d\"", config.first, port);
Log.i(TAG, "addCustomProxyArgs: " + customProxy);
args.add(customProxy);
} catch (NumberFormatException e) {
- Log.w(TAG, String.format("http.proxyPort: %s is not valid number", config.second), e);
+ Log.w(TAG, "http.proxyPort: %s is not valid number", config.second, e);
}
}
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/media/ArtworkLoader.java b/starboard/android/apk/app/src/main/java/dev/cobalt/media/ArtworkLoader.java
index f131da7..758030d 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/media/ArtworkLoader.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/media/ArtworkLoader.java
@@ -29,6 +29,7 @@
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
+import java.util.Locale;
/** Loads MediaImage artwork, and caches one image. */
public class ArtworkLoader {
@@ -97,7 +98,7 @@
private Size parseImageSize(MediaImage image) {
try {
String sizeStr = image.sizes.split("\\s+", -1)[0];
- return Size.parseSize(sizeStr.toLowerCase());
+ return Size.parseSize(sizeStr.toLowerCase(Locale.US));
} catch (NumberFormatException | NullPointerException e) {
return new Size(0, 0);
}
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioOutputManager.java b/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioOutputManager.java
index 5a13b01..ebd8967 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioOutputManager.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioOutputManager.java
@@ -30,6 +30,7 @@
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
+import java.util.Locale;
import java.util.concurrent.atomic.AtomicBoolean;
/** Creates and destroys AudioTrackBridge and handles the volume change. */
@@ -103,9 +104,9 @@
// AudioFormat.
Log.v(
TAG,
- String.format(
- "Setting |hasAudioDeviceChanged| to true for audio device %s, %s.",
- info.getProductName(), getDeviceTypeNameV23(info.getType())));
+ "Setting |hasAudioDeviceChanged| to true for audio device %s, %s.",
+ info.getProductName(),
+ getDeviceTypeNameV23(info.getType()));
hasAudioDeviceChanged.set(true);
break;
}
@@ -116,9 +117,8 @@
public void onAudioDevicesAdded(AudioDeviceInfo[] addedDevices) {
Log.v(
TAG,
- String.format(
- "onAudioDevicesAdded() called, |initialDevicesAdded| is: %b.",
- initialDevicesAdded));
+ "onAudioDevicesAdded() called, |initialDevicesAdded| is: %b.",
+ initialDevicesAdded);
if (initialDevicesAdded) {
handleConnectedDeviceChange(addedDevices);
return;
@@ -236,7 +236,7 @@
return "TYPE_WIRED_HEADSET";
default:
// This may include constants introduced after API 23.
- return String.format("TYPE_UNKNOWN (%d)", device_type);
+ return String.format(Locale.US, "TYPE_UNKNOWN (%d)", device_type);
}
}
@@ -278,7 +278,7 @@
break;
default:
// This may include constants introduced after API 23.
- encodings_in_string.append(String.format("UNKNOWN (%d)", encodings[i]));
+ encodings_in_string.append(String.format(Locale.US, "UNKNOWN (%d)", encodings[i]));
break;
}
if (i != encodings.length - 1) {
@@ -304,12 +304,11 @@
for (AudioDeviceInfo info : deviceInfos) {
Log.i(
TAG,
- String.format(
- " Audio Device: %s, channels: %s, sample rates: %s, encodings: %s",
- getDeviceTypeNameV23(info.getType()),
- Arrays.toString(info.getChannelCounts()),
- Arrays.toString(info.getSampleRates()),
- getEncodingNames(info.getEncodings())));
+ " Audio Device: %s, channels: %s, sample rates: %s, encodings: %s",
+ getDeviceTypeNameV23(info.getType()),
+ Arrays.toString(info.getChannelCounts()),
+ Arrays.toString(info.getSampleRates()),
+ getEncodingNames(info.getEncodings()));
}
}
@@ -348,10 +347,11 @@
if (AudioTrackBridge.AV_SYNC_HEADER_V1_SIZE % frameSizeInBytes != 0) {
Log.w(
TAG,
- String.format(
- "Disable tunnel mode due to sampleSizeInBytes (%d) * numberOfChannels (%d) isn't"
- + " aligned to AV_SYNC_HEADER_V1_SIZE (%d).",
- sampleSizeInBytes, numberOfChannels, AudioTrackBridge.AV_SYNC_HEADER_V1_SIZE));
+ "Disable tunnel mode due to sampleSizeInBytes (%d) * numberOfChannels (%d) isn't"
+ + " aligned to AV_SYNC_HEADER_V1_SIZE (%d).",
+ sampleSizeInBytes,
+ numberOfChannels,
+ AudioTrackBridge.AV_SYNC_HEADER_V1_SIZE);
return -1;
}
}
@@ -366,10 +366,10 @@
if (Build.VERSION.SDK_INT < 23) {
Log.i(
TAG,
- String.format(
- "Passthrough on encoding %d is rejected on api %d, as passthrough is only"
- + " supported on api 23 or later.",
- encoding, Build.VERSION.SDK_INT));
+ "Passthrough on encoding %d is rejected on api %d, as passthrough is only"
+ + " supported on api 23 or later.",
+ encoding,
+ Build.VERSION.SDK_INT);
return false;
}
@@ -382,10 +382,9 @@
if (info.getType() == AudioDeviceInfo.TYPE_BLUETOOTH_A2DP) {
Log.i(
TAG,
- String.format(
- "Passthrough on encoding %d is disabled because Bluetooth output device is"
- + " connected.",
- encoding));
+ "Passthrough on encoding %d is disabled because Bluetooth output device is"
+ + " connected.",
+ encoding);
return false;
}
}
@@ -396,34 +395,31 @@
if (hasPassthroughSupportForV23(deviceInfos, encoding)) {
Log.i(
TAG,
- String.format(
- "Passthrough on encoding %d is supported, as hasPassthroughSupportForV23() returns"
- + " true.",
- encoding));
+ "Passthrough on encoding %d is supported, as hasPassthroughSupportForV23() returns"
+ + " true.",
+ encoding);
} else {
if (Build.VERSION.SDK_INT < 29) {
Log.i(
TAG,
- String.format(
- "Passthrough on encoding %d is rejected, as"
- + " hasDirectSurroundPlaybackSupportForV29() is not called for api %d.",
- encoding, Build.VERSION.SDK_INT));
+ "Passthrough on encoding %d is rejected, as"
+ + " hasDirectSurroundPlaybackSupportForV29() is not called for api %d.",
+ encoding,
+ Build.VERSION.SDK_INT);
return false;
}
if (hasDirectSurroundPlaybackSupportForV29(encoding, DEFAULT_SURROUND_SAMPLE_RATE)) {
Log.i(
TAG,
- String.format(
- "Passthrough on encoding %d is supported, as"
- + " hasDirectSurroundPlaybackSupportForV29() returns true.",
- encoding));
+ "Passthrough on encoding %d is supported, as"
+ + " hasDirectSurroundPlaybackSupportForV29() returns true.",
+ encoding);
} else {
Log.i(
TAG,
- String.format(
- "Passthrough on encoding %d is not supported, as"
- + " hasDirectSurroundPlaybackSupportForV29() returns false.",
- encoding));
+ "Passthrough on encoding %d is not supported, as"
+ + " hasDirectSurroundPlaybackSupportForV29() returns false.",
+ encoding);
return false;
}
}
@@ -445,10 +441,9 @@
// HDMI and SPDIF are connected, where the output should fallback to AC3.
Log.w(
TAG,
- String.format(
- "Passthrough on encoding %d is disabled because creating AudioTrack raises"
- + " exception: ",
- encoding),
+ "Passthrough on encoding %d is disabled because creating AudioTrack raises"
+ + " exception: ",
+ encoding,
e);
return false;
}
@@ -475,31 +470,29 @@
// an empty array indicates that the device supports arbitrary encodings.
Log.i(
TAG,
- String.format(
- "Passthrough on encoding %d is supported on %s, because getEncodings() returns"
- + " an empty array.",
- encoding, getDeviceTypeNameV23(type)));
+ "Passthrough on encoding %d is supported on %s, because getEncodings() returns"
+ + " an empty array.",
+ encoding,
+ getDeviceTypeNameV23(type));
return true;
}
for (int i = 0; i < encodings.length; ++i) {
if (encodings[i] == encoding) {
Log.i(
TAG,
- String.format(
- "Passthrough on encoding %d is supported on %s.",
- encoding, getDeviceTypeNameV23(type)));
+ "Passthrough on encoding %d is supported on %s.",
+ encoding,
+ getDeviceTypeNameV23(type));
return true;
}
}
Log.i(
TAG,
- String.format(
- "Passthrough on encoding %d is not supported on %s.",
- encoding, getDeviceTypeNameV23(type)));
+ "Passthrough on encoding %d is not supported on %s.",
+ encoding,
+ getDeviceTypeNameV23(type));
}
- Log.i(
- TAG,
- String.format("Passthrough on encoding %d is not supported on any devices.", encoding));
+ Log.i(TAG, "Passthrough on encoding %d is not supported on any devices.", encoding);
return false;
}
@@ -511,19 +504,15 @@
&& encoding != AudioFormat.ENCODING_E_AC3_JOC) {
Log.w(
TAG,
- String.format(
- "hasDirectSurroundPlaybackSupportForV29() encountered unsupported encoding %d.",
- encoding));
+ "hasDirectSurroundPlaybackSupportForV29() encountered unsupported encoding %d.",
+ encoding);
return false;
}
boolean supported =
AudioTrack.isDirectPlaybackSupported(
getPassthroughAudioFormatFor(encoding, sampleRate), getDefaultAudioAttributes());
- Log.i(
- TAG,
- String.format(
- "isDirectPlaybackSupported() for encoding %d returned %b.", encoding, supported));
+ Log.i(TAG, "isDirectPlaybackSupported() for encoding %d returned %b.", encoding, supported);
return supported;
}
@@ -550,4 +539,31 @@
private boolean getAndResetHasAudioDeviceChanged() {
return hasAudioDeviceChanged.getAndSet(false);
}
+
+ private static AudioDeviceCallback audioDeviceCallback =
+ new AudioDeviceCallback() {
+ @Override
+ public void onAudioDevicesAdded(AudioDeviceInfo[] addedDevices) {
+ nativeOnAudioDeviceChanged();
+ }
+
+ @Override
+ public void onAudioDevicesRemoved(AudioDeviceInfo[] removedDevices) {
+ nativeOnAudioDeviceChanged();
+ }
+ };
+
+ private static boolean audioDeviceListenerAdded = false;
+
+ public static void addAudioDeviceListener(Context context) {
+ if (audioDeviceListenerAdded) {
+ return;
+ }
+
+ AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+ audioManager.registerAudioDeviceCallback(audioDeviceCallback, null);
+ audioDeviceListenerAdded = true;
+ }
+
+ private static native void nativeOnAudioDeviceChanged();
}
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioTrackBridge.java b/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioTrackBridge.java
index 4c11399..5050078 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioTrackBridge.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioTrackBridge.java
@@ -27,6 +27,7 @@
import dev.cobalt.util.UsedByNative;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
+import java.util.Locale;
/**
* A wrapper of the android AudioTrack class. Android AudioTrack would not start playing until the
@@ -96,9 +97,12 @@
audioTrack = null;
String errorMessage =
String.format(
+ Locale.US,
"Enable tunnel mode when frame size is unaligned, "
+ "sampleType: %d, channel: %d, sync header size: %d.",
- sampleType, channelCount, AV_SYNC_HEADER_V1_SIZE);
+ sampleType,
+ channelCount,
+ AV_SYNC_HEADER_V1_SIZE);
Log.e(TAG, errorMessage);
throw new RuntimeException(errorMessage);
}
@@ -160,12 +164,11 @@
}
Log.i(
TAG,
- String.format(
- "AudioTrack created with buffer size %d (preferred: %d). The minimum buffer size is"
- + " %d.",
- audioTrackBufferSize,
- preferredBufferSizeInBytes,
- AudioTrack.getMinBufferSize(sampleRate, channelConfig, sampleType)));
+ "AudioTrack created with buffer size %d (preferred: %d). The minimum buffer size is"
+ + " %d.",
+ audioTrackBufferSize,
+ preferredBufferSizeInBytes,
+ AudioTrack.getMinBufferSize(sampleRate, channelConfig, sampleType));
}
public Boolean isAudioTrackValid() {
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/media/CobaltMediaSession.java b/starboard/android/apk/app/src/main/java/dev/cobalt/media/CobaltMediaSession.java
index a310b15..f36dad3 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/media/CobaltMediaSession.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/media/CobaltMediaSession.java
@@ -515,9 +515,11 @@
Log.i(
TAG,
- String.format(
- "MediaSession state: %s, position: %d ms, speed: %f x, duration: %d ms",
- stateName, positionMs, speed, duration));
+ "MediaSession state: %s, position: %d ms, speed: %f x, duration: %d ms",
+ stateName,
+ positionMs,
+ speed,
+ duration);
playbackStateBuilder =
new PlaybackStateCompat.Builder()
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecBridge.java b/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecBridge.java
index c5c66cd..eeed7a7 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecBridge.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecBridge.java
@@ -37,6 +37,7 @@
import dev.cobalt.util.UsedByNative;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
+import java.util.Locale;
/** A wrapper of the MediaCodec class. */
@SuppressWarnings("unused")
@@ -141,7 +142,7 @@
return;
}
if (presentationTimeUs <= mLastFrameTimestampUs) {
- Log.v(TAG, String.format("Invalid output presentation timestamp."));
+ Log.v(TAG, "Invalid output presentation timestamp.");
return;
}
@@ -537,13 +538,10 @@
}
MediaCodec mediaCodec = null;
try {
- Log.i(TAG, String.format("Creating \"%s\" decoder.", decoderName));
+ Log.i(TAG, "Creating \"%s\" decoder.", decoderName);
mediaCodec = MediaCodec.createByCodecName(decoderName);
} catch (Exception e) {
- Log.e(
- TAG,
- String.format("Failed to create MediaCodec: %s, DecoderName: %s", mime, decoderName),
- e);
+ Log.e(TAG, "Failed to create MediaCodec: %s, DecoderName: %s", mime, decoderName, e);
return null;
}
if (mediaCodec == null) {
@@ -609,13 +607,16 @@
}
try {
- Log.i(TAG, String.format("Creating \"%s\" decoder.", decoderName));
+ Log.i(TAG, "Creating \"%s\" decoder.", decoderName);
mediaCodec = MediaCodec.createByCodecName(decoderName);
} catch (Exception e) {
String message =
String.format(
+ Locale.US,
"Failed to create MediaCodec: %s, mustSupportSecure: %s," + " DecoderName: %s",
- mime, crypto != null, decoderName);
+ mime,
+ crypto != null,
+ decoderName);
Log.e(TAG, message, e);
outCreateMediaCodecBridgeResult.mErrorMessage = message;
return;
@@ -1189,8 +1190,10 @@
+ (configurationData == null
? "|configurationData| is null."
: String.format(
+ Locale.US,
"Configuration data size (%d) is less than the required size (%d).",
- configurationData.length, MIN_OPUS_INITIALIZATION_DATA_BUFFER_SIZE)));
+ configurationData.length,
+ MIN_OPUS_INITIALIZATION_DATA_BUFFER_SIZE)));
return false;
}
// Both the number of samples to skip from the beginning of the stream and the amount of time
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecUtil.java b/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecUtil.java
index 2d023be..e2e9b43 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecUtil.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecUtil.java
@@ -436,7 +436,7 @@
// Filter blacklisted video decoders.
String name = codecInfo.getName();
if (!isVp9AllowListed && videoCodecDenyList.contains(name)) {
- Log.v(TAG, String.format("Rejecting %s, reason: codec is on deny list", name));
+ Log.v(TAG, "Rejecting %s, reason: codec is on deny list", name);
continue;
}
if (name.endsWith(SECURE_DECODER_SUFFIX)) {
@@ -446,7 +446,7 @@
name.substring(0, name.length() - SECURE_DECODER_SUFFIX.length());
if (!isVp9AllowListed && videoCodecDenyList.contains(nameWithoutSecureSuffix)) {
String format = "Rejecting %s, reason: offpsec denylisted secure decoder";
- Log.v(TAG, String.format(format, name));
+ Log.v(TAG, format, name);
continue;
}
}
@@ -537,6 +537,7 @@
int fps) {
String decoderInfo =
String.format(
+ Locale.US,
"Searching for video decoder with parameters mimeType: %s, secure: %b, frameWidth:"
+ " %d, frameHeight: %d, bitrate: %d, fps: %d, mustSupportHdr: %b,"
+ " mustSupportSoftwareCodec: %b, mustSupportTunnelMode: %b,"
@@ -554,6 +555,7 @@
Log.v(TAG, decoderInfo);
String deviceInfo =
String.format(
+ Locale.US,
"brand: %s, model: %s, version: %s, API level: %d, isVp9AllowListed: %b",
Build.BRAND,
Build.MODEL,
@@ -606,9 +608,13 @@
|| !mustSupportSecure && requiresSecurePlayback) {
String message =
String.format(
+ Locale.US,
"Rejecting %s, reason: secure decoder requested: %b, "
+ "codec FEATURE_SecurePlayback supported: %b, required: %b",
- name, mustSupportSecure, supportsSecurePlayback, requiresSecurePlayback);
+ name,
+ mustSupportSecure,
+ supportsSecurePlayback,
+ requiresSecurePlayback);
Log.v(TAG, message);
continue;
}
@@ -623,9 +629,13 @@
|| !mustSupportTunnelMode && requiresTunneledPlayback) {
String message =
String.format(
+ Locale.US,
"Rejecting %s, reason: tunneled playback requested: %b, "
+ "codec FEATURE_TunneledPlayback supported: %b, required: %b",
- name, mustSupportTunnelMode, supportsTunneledPlayback, requiresTunneledPlayback);
+ name,
+ mustSupportTunnelMode,
+ supportsTunneledPlayback,
+ requiresTunneledPlayback);
Log.v(TAG, message);
continue;
}
@@ -652,31 +662,31 @@
if (frameWidth != 0 && frameHeight != 0) {
if (!videoCapabilities.isSizeSupported(frameWidth, frameHeight)) {
String format = "Rejecting %s, reason: width %s is not compatible with height %d";
- Log.v(TAG, String.format(format, name, frameWidth, frameHeight));
+ Log.v(TAG, format, name, frameWidth, frameHeight);
continue;
}
} else if (frameWidth != 0) {
if (!supportedWidths.contains(frameWidth)) {
String format = "Rejecting %s, reason: supported widths %s does not contain %d";
- Log.v(TAG, String.format(format, name, supportedWidths.toString(), frameWidth));
+ Log.v(TAG, format, name, supportedWidths.toString(), frameWidth);
continue;
}
} else if (frameHeight != 0) {
if (!supportedHeights.contains(frameHeight)) {
String format = "Rejecting %s, reason: supported heights %s does not contain %d";
- Log.v(TAG, String.format(format, name, supportedHeights.toString(), frameHeight));
+ Log.v(TAG, format, name, supportedHeights.toString(), frameHeight);
continue;
}
}
} else {
if (frameWidth != 0 && !supportedWidths.contains(frameWidth)) {
String format = "Rejecting %s, reason: supported widths %s does not contain %d";
- Log.v(TAG, String.format(format, name, supportedWidths.toString(), frameWidth));
+ Log.v(TAG, format, name, supportedWidths.toString(), frameWidth);
continue;
}
if (frameHeight != 0 && !supportedHeights.contains(frameHeight)) {
String format = "Rejecting %s, reason: supported heights %s does not contain %d";
- Log.v(TAG, String.format(format, name, supportedHeights.toString(), frameHeight));
+ Log.v(TAG, format, name, supportedHeights.toString(), frameHeight);
continue;
}
}
@@ -684,7 +694,7 @@
Range<Integer> bitrates = videoCapabilities.getBitrateRange();
if (bitrate != 0 && !bitrates.contains(bitrate)) {
String format = "Rejecting %s, reason: bitrate range %s does not contain %d";
- Log.v(TAG, String.format(format, name, bitrates.toString(), bitrate));
+ Log.v(TAG, format, name, bitrates.toString(), bitrate);
continue;
}
@@ -694,14 +704,14 @@
if (frameHeight != 0 && frameWidth != 0) {
if (!videoCapabilities.areSizeAndRateSupported(frameWidth, frameHeight, fps)) {
String format = "Rejecting %s, reason: supported frame rates %s does not contain %d";
- Log.v(TAG, String.format(format, name, supportedFrameRates.toString(), fps));
+ Log.v(TAG, format, name, supportedFrameRates.toString(), fps);
continue;
}
} else {
// At least one of frameHeight or frameWidth is 0
if (!supportedFrameRates.contains(fps)) {
String format = "Rejecting %s, reason: supported frame rates %s does not contain %d";
- Log.v(TAG, String.format(format, name, supportedFrameRates.toString(), fps));
+ Log.v(TAG, format, name, supportedFrameRates.toString(), fps);
continue;
}
}
@@ -709,7 +719,7 @@
} else {
if (fps != 0 && !supportedFrameRates.contains(fps)) {
String format = "Rejecting %s, reason: supported frame rates %s does not contain %d";
- Log.v(TAG, String.format(format, name, supportedFrameRates.toString(), fps));
+ Log.v(TAG, format, name, supportedFrameRates.toString(), fps);
continue;
}
}
@@ -855,6 +865,7 @@
for (ResolutionAndFrameRate resolutionAndFrameRate : supported) {
frameRateAndResolutionString +=
String.format(
+ Locale.US,
"[%d x %d, %.3f fps], ",
resolutionAndFrameRate.width,
resolutionAndFrameRate.height,
@@ -878,6 +889,7 @@
String name = info.getName();
decoderDumpString +=
String.format(
+ Locale.US,
"name: %s (%s, %s): ",
name,
supportedType,
@@ -897,6 +909,7 @@
getSupportedResolutionsAndFrameRates(videoCapabilities, isHdrCapable);
decoderDumpString +=
String.format(
+ Locale.US,
"\n\t\t"
+ "widths: %s, "
+ "heights: %s, "
@@ -923,6 +936,7 @@
|| isTunneledPlaybackSupported) {
decoderDumpString +=
String.format(
+ Locale.US,
"(%s%s%s",
isAdaptivePlaybackSupported ? "AdaptivePlayback, " : "",
isSecurePlaybackSupported ? "SecurePlayback, " : "",
@@ -938,13 +952,12 @@
}
Log.v(
TAG,
- String.format(
- " \n"
- + "==================================================\n"
- + "Full list of decoder features: [AdaptivePlayback, SecurePlayback,"
- + " TunneledPlayback]\n"
- + "Unsupported features for each codec are not listed\n"
- + decoderDumpString
- + "=================================================="));
+ " \n"
+ + "==================================================\n"
+ + "Full list of decoder features: [AdaptivePlayback, SecurePlayback,"
+ + " TunneledPlayback]\n"
+ + "Unsupported features for each codec are not listed\n"
+ + decoderDumpString
+ + "==================================================");
}
}
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/util/DisplayUtil.java b/starboard/android/apk/app/src/main/java/dev/cobalt/util/DisplayUtil.java
index 29a2f80..b96bb87 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/util/DisplayUtil.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/util/DisplayUtil.java
@@ -16,6 +16,8 @@
import android.app.Activity;
import android.content.Context;
+import android.hardware.display.DisplayManager;
+import android.hardware.display.DisplayManager.DisplayListener;
import android.util.DisplayMetrics;
import android.util.Size;
import android.util.SizeF;
@@ -139,4 +141,40 @@
private static DisplayMetrics getDisplayMetrics() {
return cachedDisplayMetrics;
}
+
+ private static DisplayListener displayerListener =
+ new DisplayListener() {
+ @Override
+ public void onDisplayAdded(int displayId) {
+ nativeOnDisplayChanged();
+ }
+
+ @Override
+ public void onDisplayChanged(int displayId) {
+ nativeOnDisplayChanged();
+ }
+
+ @Override
+ public void onDisplayRemoved(int displayId) {
+ nativeOnDisplayChanged();
+ }
+ };
+
+ private static boolean displayerListenerAdded = false;
+
+ public static void addDisplayListener(Context context) {
+ if (displayerListenerAdded) {
+ return;
+ }
+
+ DisplayManager displayManager = context.getSystemService(DisplayManager.class);
+ displayManager.registerDisplayListener(displayerListener, null);
+ displayerListenerAdded = true;
+
+ // Call nativeOnDisplayChanged() to reload supported hdr types here after a default
+ // Display created.
+ nativeOnDisplayChanged();
+ }
+
+ private static native void nativeOnDisplayChanged();
}
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/util/Log.java b/starboard/android/apk/app/src/main/java/dev/cobalt/util/Log.java
index 0a75c79..cca7c02 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/util/Log.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/util/Log.java
@@ -15,6 +15,7 @@
package dev.cobalt.util;
import java.lang.reflect.Method;
+import java.util.Locale;
/**
* Logging wrapper to allow for better control of Proguard log stripping. Many dependent
@@ -59,9 +60,27 @@
}
}
- private static int logWithMethod(Method logMethod, String tag, String msg, Throwable tr) {
+ private static Throwable getThrowableToLog(Object[] args) {
+ if (args == null || args.length == 0) return null;
+ Object lastArg = args[args.length - 1];
+ if (!(lastArg instanceof Throwable)) return null;
+ return (Throwable) lastArg;
+ }
+
+ /** Returns a formatted log message, using the supplied format and arguments. */
+ private static String formatLog(String messageTemplate, Throwable tr, Object... params) {
+ if ((params != null) && ((tr == null && params.length > 0) || params.length > 1)) {
+ messageTemplate = String.format(Locale.US, messageTemplate, params);
+ }
+ return messageTemplate;
+ }
+
+ private static int logWithMethod(
+ Method logMethod, String tag, String messageTemplate, Object... args) {
try {
if (logMethod != null) {
+ Throwable tr = getThrowableToLog(args);
+ String msg = formatLog(messageTemplate, tr, args);
return (int) logMethod.invoke(null, tag, msg, tr);
}
} catch (Throwable e) {
@@ -70,47 +89,27 @@
return 0;
}
- public static int v(String tag, String msg) {
- return logWithMethod(logV, tag, msg, null);
+ public static int v(String tag, String messageTemplate, Object... args) {
+ return logWithMethod(logV, tag, messageTemplate, args);
}
- public static int v(String tag, String msg, Throwable tr) {
- return logWithMethod(logV, tag, msg, tr);
+ public static int d(String tag, String messageTemplate, Object... args) {
+ return logWithMethod(logD, tag, messageTemplate, args);
}
- public static int d(String tag, String msg) {
- return logWithMethod(logD, tag, msg, null);
+ public static int i(String tag, String messageTemplate, Object... args) {
+ return logWithMethod(logI, tag, messageTemplate, args);
}
- public static int d(String tag, String msg, Throwable tr) {
- return logWithMethod(logD, tag, msg, tr);
- }
-
- public static int i(String tag, String msg) {
- return logWithMethod(logI, tag, msg, null);
- }
-
- public static int i(String tag, String msg, Throwable tr) {
- return logWithMethod(logI, tag, msg, tr);
- }
-
- public static int w(String tag, String msg) {
- return logWithMethod(logW, tag, msg, null);
- }
-
- public static int w(String tag, String msg, Throwable tr) {
- return logWithMethod(logW, tag, msg, tr);
+ public static int w(String tag, String messageTemplate, Object... args) {
+ return logWithMethod(logW, tag, messageTemplate, args);
}
public static int w(String tag, Throwable tr) {
return logWithMethod(logW, tag, "", tr);
}
- public static int e(String tag, String msg) {
- return logWithMethod(logE, tag, msg, null);
- }
-
- public static int e(String tag, String msg, Throwable tr) {
- return logWithMethod(logE, tag, msg, tr);
+ public static int e(String tag, String messageTemplate, Object... args) {
+ return logWithMethod(logE, tag, messageTemplate, args);
}
}
diff --git a/starboard/android/shared/file_open.cc b/starboard/android/shared/file_open.cc
index 83d924a..0f398a4 100644
--- a/starboard/android/shared/file_open.cc
+++ b/starboard/android/shared/file_open.cc
@@ -30,7 +30,12 @@
// font file of the same name.
const std::string kFontsXml("fonts.xml");
const std::string kSystemFontsDir("/system/fonts/");
+
+#if SB_IS(EVERGREEN_COMPATIBLE)
+const std::string kCobaltFontsDir("/cobalt/assets/app/cobalt/content/fonts/");
+#else
const std::string kCobaltFontsDir("/cobalt/assets/fonts/");
+#endif
// Returns the fallback for the given asset path, or an empty string if none.
// NOTE: While Cobalt now provides a mechanism for loading system fonts through
@@ -67,8 +72,8 @@
bool* out_created,
SbFileError* out_error) {
if (!IsAndroidAssetPath(path)) {
- return ::starboard::shared::posix::impl::FileOpen(
- path, flags, out_created, out_error);
+ return ::starboard::shared::posix::impl::FileOpen(path, flags, out_created,
+ out_error);
}
// Assets are never created and are always read-only, whether it's actually an
diff --git a/starboard/android/shared/media_capabilities_cache.cc b/starboard/android/shared/media_capabilities_cache.cc
index 53360ea..e8090b5 100644
--- a/starboard/android/shared/media_capabilities_cache.cc
+++ b/starboard/android/shared/media_capabilities_cache.cc
@@ -20,12 +20,17 @@
#include "starboard/android/shared/media_common.h"
#include "starboard/common/log.h"
#include "starboard/once.h"
+#include "starboard/shared/starboard/media/key_system_supportability_cache.h"
+#include "starboard/shared/starboard/media/mime_supportability_cache.h"
namespace starboard {
namespace android {
namespace shared {
namespace {
+using ::starboard::shared::starboard::media::KeySystemSupportabilityCache;
+using ::starboard::shared::starboard::media::MimeSupportabilityCache;
+
// https://developer.android.com/reference/android/view/Display.HdrCapabilities.html#HDR_TYPE_HDR10
const jint HDR_TYPE_DOLBY_VISION = 1;
const jint HDR_TYPE_HDR10 = 2;
@@ -79,6 +84,13 @@
JniEnvExt* env = JniEnvExt::Get();
jintArray j_supported_hdr_types = static_cast<jintArray>(
env->CallStarboardObjectMethodOrAbort("getSupportedHdrTypes", "()[I"));
+
+ if (!j_supported_hdr_types) {
+ // Failed to get supported hdr types.
+ SB_LOG(ERROR) << "Failed to load supported hdr types.";
+ return std::set<SbMediaTransferId>();
+ }
+
jsize length = env->GetArrayLength(j_supported_hdr_types);
jint* numbers = env->GetIntArrayElements(j_supported_hdr_types, 0);
for (int i = 0; i < length; i++) {
@@ -461,6 +473,31 @@
max_audio_output_channels_ = -1;
}
+void MediaCapabilitiesCache::ReloadSupportedHdrTypes() {
+ ScopedLock scoped_lock(mutex_);
+ if (!is_initialized_) {
+ LazyInitialize_Locked();
+ return;
+ }
+ supported_transfer_ids_ = GetSupportedHdrTypes();
+}
+
+void MediaCapabilitiesCache::ReloadAudioOutputChannels() {
+ ScopedLock scoped_lock(mutex_);
+ if (!is_initialized_) {
+ LazyInitialize_Locked();
+ return;
+ }
+ max_audio_output_channels_ =
+ ::starboard::android::shared::GetMaxAudioOutputChannels();
+}
+
+MediaCapabilitiesCache::MediaCapabilitiesCache() {
+ // Enable mime and key system caches.
+ MimeSupportabilityCache::GetInstance()->SetCacheEnabled(true);
+ KeySystemSupportabilityCache::GetInstance()->SetCacheEnabled(true);
+}
+
void MediaCapabilitiesCache::LazyInitialize_Locked() {
mutex_.DCheckAcquired();
@@ -526,6 +563,20 @@
}
}
+extern "C" SB_EXPORT_PLATFORM void
+Java_dev_cobalt_util_DisplayUtil_nativeOnDisplayChanged() {
+ SB_DLOG(INFO) << "Display device has changed.";
+ MediaCapabilitiesCache::GetInstance()->ReloadSupportedHdrTypes();
+ MimeSupportabilityCache::GetInstance()->ClearCachedMimeSupportabilities();
+}
+
+extern "C" SB_EXPORT_PLATFORM void
+Java_dev_cobalt_media_AudioOutputManager_nativeOnAudioDeviceChanged() {
+ SB_DLOG(INFO) << "Audio device has changed.";
+ MediaCapabilitiesCache::GetInstance()->ReloadAudioOutputChannels();
+ MimeSupportabilityCache::GetInstance()->ClearCachedMimeSupportabilities();
+}
+
} // namespace shared
} // namespace android
} // namespace starboard
diff --git a/starboard/android/shared/media_capabilities_cache.h b/starboard/android/shared/media_capabilities_cache.h
index 46da91a..21d735b 100644
--- a/starboard/android/shared/media_capabilities_cache.h
+++ b/starboard/android/shared/media_capabilities_cache.h
@@ -160,8 +160,11 @@
void SetCacheEnabled(bool enabled) { is_enabled_ = enabled; }
void ClearCache();
+ void ReloadSupportedHdrTypes();
+ void ReloadAudioOutputChannels();
+
private:
- MediaCapabilitiesCache() {}
+ MediaCapabilitiesCache();
~MediaCapabilitiesCache() {}
MediaCapabilitiesCache(const MediaCapabilitiesCache&) = delete;
@@ -183,7 +186,7 @@
std::map<std::string, AudioCodecCapabilities> audio_codec_capabilities_map_;
std::map<std::string, VideoCodecCapabilities> video_codec_capabilities_map_;
- std::atomic_bool is_enabled_{false};
+ std::atomic_bool is_enabled_{true};
bool is_initialized_ = false;
bool is_widevine_supported_ = false;
bool is_cbcs_supported_ = false;
diff --git a/starboard/android/shared/media_is_video_supported.cc b/starboard/android/shared/media_is_video_supported.cc
index 1f5c851..9b8fcf5 100644
--- a/starboard/android/shared/media_is_video_supported.cc
+++ b/starboard/android/shared/media_is_video_supported.cc
@@ -80,6 +80,14 @@
decoder_cache_ttl_ms =
mime_type->GetParamIntValue("decoder_cache_ttl_ms", -1);
+
+ // Disable MediaCapabilitiesCache if "disablecache" option presented.
+ if (!mime_type->ValidateBoolParameter("disablecache")) {
+ return false;
+ }
+ if (mime_type->GetParamBoolValue("disablecache", false)) {
+ MediaCapabilitiesCache::GetInstance()->SetCacheEnabled(false);
+ }
}
if (must_support_tunnel_mode && decode_to_texture_required) {
diff --git a/starboard/android/shared/system_get_path.cc b/starboard/android/shared/system_get_path.cc
index 2ca0815..5e4610a 100644
--- a/starboard/android/shared/system_get_path.cc
+++ b/starboard/android/shared/system_get_path.cc
@@ -25,10 +25,35 @@
#include "starboard/common/string.h"
#include "starboard/directory.h"
+#if SB_IS(EVERGREEN_COMPATIBLE)
+#include "starboard/elf_loader/evergreen_config.h" // nogncheck
+#endif
+
using ::starboard::android::shared::g_app_assets_dir;
using ::starboard::android::shared::g_app_cache_dir;
+using ::starboard::android::shared::g_app_files_dir;
using ::starboard::android::shared::g_app_lib_dir;
+#if SB_IS(EVERGREEN_COMPATIBLE)
+bool GetEvergreenContentPathOverride(char* out_path, int path_size) {
+ const starboard::elf_loader::EvergreenConfig* evergreen_config =
+ starboard::elf_loader::EvergreenConfig::GetInstance();
+ if (!evergreen_config) {
+ return true;
+ }
+ if (evergreen_config->content_path_.empty()) {
+ return true;
+ }
+
+ if (starboard::strlcpy(out_path, evergreen_config->content_path_.c_str(),
+ path_size) >= path_size) {
+ return false;
+ }
+
+ return true;
+}
+#endif
+
bool SbSystemGetPath(SbSystemPathId path_id, char* out_path, int path_size) {
if (!out_path || !path_size) {
return false;
@@ -43,9 +68,25 @@
if (starboard::strlcat(path, g_app_assets_dir, kPathSize) >= kPathSize) {
return false;
}
+
+#if SB_IS(EVERGREEN_COMPATIBLE)
+ if (!GetEvergreenContentPathOverride(path, kPathSize)) {
+ return false;
+ }
+#endif
break;
}
+ case kSbSystemPathStorageDirectory: {
+ if (starboard::strlcpy(path, g_app_files_dir, kPathSize) >= kPathSize) {
+ return false;
+ }
+ if (starboard::strlcat(path, "/storage", kPathSize) >= kPathSize) {
+ return false;
+ }
+ SbDirectoryCreate(path);
+ break;
+ }
case kSbSystemPathCacheDirectory: {
if (!SbSystemGetPath(kSbSystemPathTempDirectory, path, kPathSize)) {
return false;
diff --git a/starboard/evergreen/shared/launcher.py b/starboard/evergreen/shared/launcher.py
index c8bf2d5..e6f331d 100644
--- a/starboard/evergreen/shared/launcher.py
+++ b/starboard/evergreen/shared/launcher.py
@@ -75,6 +75,8 @@
self.loader_out_directory = paths.BuildOutputDirectory(
self.loader_platform, self.loader_config)
+ self.use_compressed_library = kwargs.get('use_compressed_library')
+
# The relationship of loader platforms and configurations to evergreen
# platforms and configurations is many-to-many. We need a separate directory
# for each of them, i.e. linux-x64x11_debug__evergreen-x64_gold.
@@ -92,9 +94,18 @@
# Ensure the path, relative to the content of the ELF Loader, to the
# Evergreen target and its content are passed as command line switches.
+ library_path_param = '--evergreen_library=app/{}/lib/lib{}'.format(
+ self.target_name, self.target_name)
+ if self.use_compressed_library:
+ if self.target_name != 'cobalt':
+ raise ValueError(
+ '|use_compressed_library| only expected with |target_name| cobalt')
+ library_path_param += '.lz4'
+ else:
+ library_path_param += '.so'
+
target_command_line_params = [
- '--evergreen_library=app/{}/lib/lib{}.so'.format(
- self.target_name, self.target_name),
+ library_path_param,
'--evergreen_content=app/{}/content'.format(self.target_name)
]
@@ -171,6 +182,7 @@
self._StageTargetsAndContentsGyp()
def _StageTargetsAndContentsGnLinux(self):
+ """Stage targets and their contents for GN builds for Linux platforms."""
content_subdir = os.path.join('usr', 'share', 'cobalt')
# Copy loader content and binaries
@@ -199,13 +211,15 @@
target_content_dst = os.path.join(target_staging_dir, 'content')
shutil.copytree(target_content_src, target_content_dst)
- shlib_name = 'lib{}.so'.format(self.target_name)
+ shlib_name = 'lib{}'.format(self.target_name)
+ shlib_name += '.lz4' if self.use_compressed_library else '.so'
target_binary_src = os.path.join(target_install_path, 'lib', shlib_name)
target_binary_dst = os.path.join(target_staging_dir, 'lib', shlib_name)
os.makedirs(os.path.join(target_staging_dir, 'lib'))
shutil.copy(target_binary_src, target_binary_dst)
def _StageTargetsAndContentsGnRaspi(self):
+ """Stage targets and their contents for GN builds for Raspi platforms."""
# TODO(b/218889313): `content` is hardcoded on raspi and must be in the same
# directory as the binaries.
if 'raspi' in self.loader_platform:
@@ -251,13 +265,15 @@
target_content_dst = os.path.join(target_staging_dir, 'content')
shutil.copytree(target_content_src, target_content_dst)
- shlib_name = 'lib{}.so'.format(self.target_name)
+ shlib_name = 'lib{}'.format(self.target_name)
+ shlib_name += '.lz4' if self.use_compressed_library else '.so'
target_binary_src = os.path.join(target_install_path, 'lib', shlib_name)
target_binary_dst = os.path.join(target_staging_dir, 'lib', shlib_name)
os.makedirs(os.path.join(target_staging_dir, 'lib'))
shutil.copy(target_binary_src, target_binary_dst)
def _StageTargetsAndContentsGyp(self):
+ """Stage targets and their contents for GYP builds."""
# <outpath>/deploy/elf_loader_sandbox
staging_directory_loader = os.path.join(self.staging_directory, 'deploy',
self.loader_target)
diff --git a/starboard/evergreen/testing/README.md b/starboard/evergreen/testing/README.md
index bbd33fe..e401325 100644
--- a/starboard/evergreen/testing/README.md
+++ b/starboard/evergreen/testing/README.md
@@ -121,9 +121,9 @@
+-- content <-- loader content
+-- app
+-- cobalt
- +-- content <-- cobalt content
+ +-- content <-- cobalt content
+-- lib
- +-- libcobalt.so <-- cobalt binary
+ +-- libcobalt.{so,lz4} <-- cobalt binary
```
Note: This directory structure is the same as what would be generated by
diff --git a/starboard/evergreen/testing/linux/deploy_cobalt.sh b/starboard/evergreen/testing/linux/deploy_cobalt.sh
index 6dc6e59..a461fae 100755
--- a/starboard/evergreen/testing/linux/deploy_cobalt.sh
+++ b/starboard/evergreen/testing/linux/deploy_cobalt.sh
@@ -31,8 +31,8 @@
echo " Checking '${staging_dir}'"
- PATHS=("${staging_dir}/loader_app" \
- "${staging_dir}/content/app/cobalt/lib/libcobalt.so" \
+ PATHS=("${staging_dir}/loader_app" \
+ "${staging_dir}/content/app/cobalt/lib/libcobalt${SYSTEM_IMAGE_EXTENSION}" \
"${staging_dir}/content/app/cobalt/content/")
for file in "${PATHS[@]}"; do
diff --git a/starboard/evergreen/testing/raspi/deploy_cobalt.sh b/starboard/evergreen/testing/raspi/deploy_cobalt.sh
index 8fdbc22..9012f3c 100755
--- a/starboard/evergreen/testing/raspi/deploy_cobalt.sh
+++ b/starboard/evergreen/testing/raspi/deploy_cobalt.sh
@@ -31,8 +31,8 @@
echo " Checking '${staging_dir}'"
- PATHS=("${staging_dir}/loader_app" \
- "${staging_dir}/content/app/cobalt/lib/libcobalt.so" \
+ PATHS=("${staging_dir}/loader_app" \
+ "${staging_dir}/content/app/cobalt/lib/libcobalt${SYSTEM_IMAGE_EXTENSION}" \
"${staging_dir}/content/app/cobalt/content/")
for file in "${PATHS[@]}"; do
@@ -60,7 +60,7 @@
eval "${SSH} \"mkdir -p /home/pi/coeg/content/app/cobalt/lib\""
echo " Copying cobalt to system image directory"
- eval "${SCP} \"${staging_dir}/content/app/cobalt/lib/libcobalt.so pi@${RASPI_ADDR}:/home/pi/coeg/content/app/cobalt/lib/\""
+ eval "${SCP} \"${staging_dir}/content/app/cobalt/lib/libcobalt${SYSTEM_IMAGE_EXTENSION} pi@${RASPI_ADDR}:/home/pi/coeg/content/app/cobalt/lib/\""
echo " Copying content to system image directory"
eval "${SCP} \"-r ${staging_dir}/content/app/cobalt/content/ pi@${RASPI_ADDR}:/home/pi/coeg/content/app/cobalt/\""
diff --git a/starboard/evergreen/testing/run_all_tests.sh b/starboard/evergreen/testing/run_all_tests.sh
index efb9d0b..91c53fb 100755
--- a/starboard/evergreen/testing/run_all_tests.sh
+++ b/starboard/evergreen/testing/run_all_tests.sh
@@ -21,7 +21,9 @@
DIR="$(dirname "${0}")"
AUTH_METHOD="public-key"
-while getopts "d:a:" o; do
+USE_COMPRESSED_SYSTEM_IMAGE="false"
+SYSTEM_IMAGE_EXTENSION=".so"
+while getopts "d:a:c" o; do
case "${o}" in
d)
DEVICE_ID=${OPTARG}
@@ -29,6 +31,10 @@
a)
AUTH_METHOD=${OPTARG}
;;
+ c)
+ USE_COMPRESSED_SYSTEM_IMAGE="true"
+ SYSTEM_IMAGE_EXTENSION=".lz4"
+ ;;
esac
done
shift $((OPTIND-1))
@@ -40,8 +46,14 @@
source $DIR/setup.sh
-# Find all of the test files within the 'test' subdirectory.
-TESTS=($(eval "find ${DIR}/tests -maxdepth 1 -name '*_test.sh'"))
+if [[ "${USE_COMPRESSED_SYSTEM_IMAGE}" == "true" ]]; then
+ # It would be valid to run all test cases using a compressed system image but
+ # is probably excessive. Instead, just the Evergreen Lite case is run to test
+ # that the compressed system image can be successfully loaded.
+ TESTS=($(eval "find ${DIR}/tests -maxdepth 1 -name 'evergreen_lite_test.sh'"))
+else
+ TESTS=($(eval "find ${DIR}/tests -maxdepth 1 -name '*_test.sh'"))
+fi
COUNT=0
RETRIED=()
@@ -145,7 +157,7 @@
clean_up
-log "info" " [==========] Finished."
+log "info" " [==========] Finished testing with USE_COMPRESSED_SYSTEM_IMAGE=${USE_COMPRESSED_SYSTEM_IMAGE}."
if [[ "${#FAILED[@]}" -eq 0 ]]; then
exit 0
diff --git a/starboard/evergreen/testing/setup.sh b/starboard/evergreen/testing/setup.sh
index 57bdbc4..393ea6d 100755
--- a/starboard/evergreen/testing/setup.sh
+++ b/starboard/evergreen/testing/setup.sh
@@ -24,7 +24,7 @@
source $DIR/pprint.sh
-log "info" " [==========] Preparing Cobalt."
+log "info" " [==========] Preparing to test with USE_COMPRESSED_SYSTEM_IMAGE=${USE_COMPRESSED_SYSTEM_IMAGE}."
if [[ -z ${1} ]]; then
log "error" "A platform must be provided"
diff --git a/starboard/shared/starboard/media/BUILD.gn b/starboard/shared/starboard/media/BUILD.gn
index 28ba606..7baaf99 100644
--- a/starboard/shared/starboard/media/BUILD.gn
+++ b/starboard/shared/starboard/media/BUILD.gn
@@ -17,8 +17,6 @@
sources = [
"//starboard/shared/starboard/media/avc_util.cc",
"//starboard/shared/starboard/media/avc_util.h",
- "//starboard/shared/starboard/media/bitrate_supportability_cache.cc",
- "//starboard/shared/starboard/media/bitrate_supportability_cache.h",
"//starboard/shared/starboard/media/codec_util.cc",
"//starboard/shared/starboard/media/codec_util.h",
"//starboard/shared/starboard/media/key_system_supportability_cache.cc",
diff --git a/starboard/shared/starboard/media/bitrate_supportability_cache.cc b/starboard/shared/starboard/media/bitrate_supportability_cache.cc
deleted file mode 100644
index 01c2917..0000000
--- a/starboard/shared/starboard/media/bitrate_supportability_cache.cc
+++ /dev/null
@@ -1,150 +0,0 @@
-// 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 "starboard/shared/starboard/media/bitrate_supportability_cache.h"
-
-#include <map>
-
-#include "starboard/common/log.h"
-#include "starboard/common/mutex.h"
-#include "starboard/log.h"
-#include "starboard/media.h"
-#include "starboard/once.h"
-
-namespace starboard {
-namespace shared {
-namespace starboard {
-namespace media {
-
-namespace {
-
-template <typename T>
-class BitrateSupportabilityContainer {
- public:
- Supportability GetSupportability(T codec, int bitrate) {
- // Reject invalid parameters.
- if (bitrate < 0) {
- return kSupportabilityNotSupported;
- }
- // Bitrate 0 is always supported.
- if (bitrate == 0) {
- return kSupportabilitySupported;
- }
-
- ScopedLock scoped_lock(mutex_);
- auto iter = supported_bitrate_ranges_.find(codec);
- if (iter == supported_bitrate_ranges_.end()) {
- return kSupportabilityUnknown;
- }
- const Range& range = iter->second;
- if (bitrate < range.minimum || bitrate > range.maximum) {
- return kSupportabilityNotSupported;
- }
- return kSupportabilitySupported;
- }
-
- void SetSupportedBitrate(T codec, int min, int max) {
- SB_DCHECK(min >= 0 && max >= min);
-
- ScopedLock scoped_lock(mutex_);
- supported_bitrate_ranges_[codec] = Range(min, max);
- }
- void ClearContainer() {
- ScopedLock scoped_lock(mutex_);
- supported_bitrate_ranges_.clear();
- }
-
- private:
- struct Range {
- Range() : minimum(0), maximum(0) {}
- Range(int min, int max) : minimum(min), maximum(max) {}
- int minimum;
- int maximum;
- };
-
- Mutex mutex_;
- std::map<T, Range> supported_bitrate_ranges_;
-};
-
-template <typename T>
-SB_ONCE_INITIALIZE_FUNCTION(BitrateSupportabilityContainer<T>, GetContainer);
-
-} // namespace
-
-// static
-SB_ONCE_INITIALIZE_FUNCTION(BitrateSupportabilityCache,
- BitrateSupportabilityCache::GetInstance);
-
-Supportability BitrateSupportabilityCache::GetBitrateSupportability(
- const ParsedMimeInfo& mime_info) {
- SB_DCHECK(mime_info.is_valid());
-
- if (!is_enabled_) {
- return kSupportabilityUnknown;
- }
-
- Supportability audio_supportability = kSupportabilitySupported;
- if (mime_info.has_audio_info()) {
- audio_supportability = GetContainer<SbMediaAudioCodec>()->GetSupportability(
- mime_info.audio_info().codec, mime_info.audio_info().bitrate);
- }
-
- Supportability video_supportability = kSupportabilitySupported;
- if (mime_info.has_video_info()) {
- video_supportability = GetContainer<SbMediaVideoCodec>()->GetSupportability(
- mime_info.video_info().codec, mime_info.video_info().bitrate);
- }
-
- if (audio_supportability == kSupportabilityNotSupported ||
- video_supportability == kSupportabilityNotSupported) {
- return kSupportabilityNotSupported;
- }
- if (audio_supportability == kSupportabilityUnknown ||
- video_supportability == kSupportabilityUnknown) {
- return kSupportabilityUnknown;
- }
- return kSupportabilitySupported;
-}
-
-void BitrateSupportabilityCache::SetSupportedBitrate(SbMediaAudioCodec codec,
- int min,
- int max) {
- SB_DCHECK(min >= 0 && min <= max) << "Invalid bitrate range.";
-
- if (!is_enabled_) {
- return;
- }
- GetContainer<SbMediaAudioCodec>()->SetSupportedBitrate(codec, min, max);
-}
-
-void BitrateSupportabilityCache::SetSupportedBitrate(SbMediaVideoCodec codec,
- int min,
- int max) {
- SB_DCHECK(min >= 0 && min <= max) << "Invalid bitrate range.";
-
- if (!is_enabled_) {
- return;
- }
- GetContainer<SbMediaVideoCodec>()->SetSupportedBitrate(codec, min, max);
-}
-
-void BitrateSupportabilityCache::ClearCache() {
- GetContainer<SbMediaAudioCodec>()->ClearContainer();
- GetContainer<SbMediaVideoCodec>()->ClearContainer();
-}
-
-} // namespace media
-} // namespace starboard
-} // namespace shared
-} // namespace starboard
diff --git a/starboard/shared/starboard/media/bitrate_supportability_cache.h b/starboard/shared/starboard/media/bitrate_supportability_cache.h
deleted file mode 100644
index fc1f553..0000000
--- a/starboard/shared/starboard/media/bitrate_supportability_cache.h
+++ /dev/null
@@ -1,66 +0,0 @@
-// 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 STARBOARD_SHARED_STARBOARD_MEDIA_BITRATE_SUPPORTABILITY_CACHE_H_
-#define STARBOARD_SHARED_STARBOARD_MEDIA_BITRATE_SUPPORTABILITY_CACHE_H_
-
-#include "starboard/media.h"
-#include "starboard/shared/internal_only.h"
-#include "starboard/shared/starboard/media/mime_supportability_cache.h"
-#include "starboard/shared/starboard/media/parsed_mime_info.h"
-
-namespace starboard {
-namespace shared {
-namespace starboard {
-namespace media {
-
-// TODO: add unit tests for BitrateSupportabilityCache
-class BitrateSupportabilityCache {
- public:
- static BitrateSupportabilityCache* GetInstance();
-
- // When cache is not enabled, GetBitrateSupportability() will always return
- // kSupportabilityUnknown, and SetSupportedBitrate() will do nothing.
- bool IsEnabled() const { return is_enabled_; }
- void SetCacheEnabled(bool enabled) { is_enabled_ = enabled; }
-
- // Get bitrate supportability.
- Supportability GetBitrateSupportability(const ParsedMimeInfo& mime_info);
- // Set supported bitrate range for the |codec|. Note that if supported bitrate
- // range is not set, MimeSupportabilityCache::GetMimeSupportability() will
- // always return kSupportabilityUnknown.
- void SetSupportedBitrate(SbMediaAudioCodec codec, int min, int max);
- void SetSupportedBitrate(SbMediaVideoCodec codec, int min, int max);
-
- // Clear all cached supported bitrate ranges.
- void ClearCache();
-
- private:
- // Class can only be instanced via the singleton
- BitrateSupportabilityCache() {}
- ~BitrateSupportabilityCache() {}
-
- BitrateSupportabilityCache(const BitrateSupportabilityCache&) = delete;
- BitrateSupportabilityCache& operator=(const BitrateSupportabilityCache&) =
- delete;
-
- std::atomic_bool is_enabled_{false};
-};
-
-} // namespace media
-} // namespace starboard
-} // namespace shared
-} // namespace starboard
-
-#endif // STARBOARD_SHARED_STARBOARD_MEDIA_BITRATE_SUPPORTABILITY_CACHE_H_
diff --git a/starboard/shared/starboard/media/key_system_supportability_cache.h b/starboard/shared/starboard/media/key_system_supportability_cache.h
index a1f2f68..e9ad962 100644
--- a/starboard/shared/starboard/media/key_system_supportability_cache.h
+++ b/starboard/shared/starboard/media/key_system_supportability_cache.h
@@ -25,7 +25,14 @@
namespace starboard {
namespace media {
-// TODO: add unit tests for KeySystemSupportabilityCache
+// KeySystemSupportabilityCache caches the supportabilities of the combinations
+// of codec and key system.
+//
+// Note: anytime the platform key system capabilities have changed, please
+// call KeySystemSupportabilityCache::ClearCache() to clear the outdated
+// results.
+//
+// TODO: add unit tests for KeySystemSupportabilityCache.
class KeySystemSupportabilityCache {
public:
static KeySystemSupportabilityCache* GetInstance();
diff --git a/starboard/shared/starboard/media/mime_supportability_cache.cc b/starboard/shared/starboard/media/mime_supportability_cache.cc
index 34024f3..d52761c 100644
--- a/starboard/shared/starboard/media/mime_supportability_cache.cc
+++ b/starboard/shared/starboard/media/mime_supportability_cache.cc
@@ -14,6 +14,7 @@
#include "starboard/shared/starboard/media/mime_supportability_cache.h"
+#include <cstring>
#include <queue>
#include <sstream>
#include <string>
@@ -34,147 +35,116 @@
namespace {
-const size_t kDefaultCacheMaxSize = 2000;
-
-class MimeSupportabilityContainer {
- public:
- struct Entry {
- ParsedMimeInfo mime_info;
- Supportability supportability = kSupportabilityUnknown;
-
- explicit Entry(const std::string& mime_string) : mime_info(mime_string) {}
- };
-
- // GetParsedMimeAndSupportability() will first try to find a cached Entry for
- // the mime string. If no cached entry, a new Entry will be created with
- // parsed mime information and supportability kSupportabilityUnknown.
- // Ideally, we should decouple mime parsing and cache functionality, but
- // considering that the cache is only for internal use, to avoid repeated
- // lookups, we do parsing in this function.
- const Entry& GetParsedMimeAndSupportability(const std::string& mime_string) {
- ScopedLock scoped_lock(mutex_);
- auto entry_iter = entries_.find(mime_string);
- if (entry_iter != entries_.end()) {
- return entry_iter->second;
- }
-
- // We can't find anything from the cache. Parse mime string and cache
- // parsed MimeType and ParsedMimeInfo.
- auto insert_result = entries_.insert({mime_string, Entry(mime_string)});
-
- fifo_queue_.push(insert_result.first);
- while (fifo_queue_.size() > max_size_) {
- entries_.erase(fifo_queue_.front());
- fifo_queue_.pop();
- }
- SB_DCHECK(entries_.size() == fifo_queue_.size());
-
- return insert_result.first->second;
+// RemoveAttributeFromMime() will return a new mime string with the specified
+// attribute removed. If |attribute_string| is not null, the removed attribute
+// string will be returned via |attribute_string|. Following are some examples:
+// mime: "video/webm; codecs=\"vp9\"; bitrate=300000"
+// attribute_name: "bitrate"
+// return: "video/webm; codecs=\"vp9\""
+// attribute_string: "bitrate=300000"
+//
+// mime: "video/webm; codecs=\"vp9\"; bitrate=300000; eotf=bt709"
+// attribute_name: "bitrate"
+// return: "video/webm; codecs=\"vp9\"; eotf=bt709"
+// attribute_string: "bitrate=300000"
+//
+// mime: "bitrate=300000"
+// attribute_name: "bitrate"
+// return: ""
+// attribute_string: "bitrate=300000"
+std::string RemoveAttributeFromMime(const char* mime,
+ const char* attribute_name,
+ std::string* attribute_string) {
+ size_t name_length = strlen(attribute_name);
+ if (name_length == 0) {
+ return mime;
}
- // CacheSupportability() will find the target entry and update the
- // supportability. If there's no existing entry, it will parse the mime
- // string and create one.
- void CacheSupportability(const std::string& mime_string,
- Supportability supportability) {
- SB_DCHECK(!mime_string.empty());
- SB_DCHECK(supportability != kSupportabilityUnknown);
+ std::string mime_without_attribute;
+ const char* start_pos = strstr(mime, attribute_name);
+ while (start_pos) {
+ if ((start_pos == mime || start_pos[-1] == ';' || isspace(start_pos[-1])) &&
+ (start_pos[name_length] &&
+ (start_pos[name_length] == '=' || isspace(start_pos[name_length])))) {
+ break;
+ }
+ start_pos += name_length;
+ start_pos = strstr(start_pos, attribute_name);
+ }
- {
- ScopedLock scoped_lock(mutex_);
- auto entry_iter = entries_.find(mime_string);
- if (entry_iter != entries_.end()) {
- entry_iter->second.supportability = supportability;
- return;
+ if (!start_pos) {
+ // Target attribute is not found.
+ return std::string(mime);
+ }
+ const char* end_pos = strstr(start_pos, ";");
+ if (end_pos) {
+ // There may be other attribute after target attribute.
+ if (attribute_string) {
+ // Returned |attribute_string| will not have a trailing ';'.
+ attribute_string->assign(start_pos, end_pos - start_pos);
+ }
+
+ end_pos++;
+ // Remove leading spaces.
+ while (*end_pos && isspace(*end_pos)) {
+ end_pos++;
+ }
+ if (*end_pos) {
+ // Append the string after target attribute.
+ mime_without_attribute = std::string(mime, start_pos - mime);
+ mime_without_attribute.append(end_pos);
+ } else {
+ // Target attribute is the last one. Remove trailing spaces.
+ size_t mime_length = start_pos - mime;
+ while (mime_length > 0 && (isspace(mime[mime_length - 1]))) {
+ mime_length--;
}
+ mime_without_attribute = std::string(mime, mime_length);
}
-
- // Parse the mime string and create an entry.
- GetParsedMimeAndSupportability(mime_string);
- // Update the supportability again.
- CacheSupportability(mime_string, supportability);
- }
-
- // ClearCachedSupportabilities() will reset all cached |supportability|, but
- // will not remove parsed mime infos.
- void ClearCachedSupportabilities() {
- ScopedLock scoped_lock(mutex_);
- for (auto& iter : entries_) {
- iter.second.supportability = kSupportabilityUnknown;
+ } else {
+ // It can't find a trailing ';'. The target attribute must be the last one.
+ size_t mime_length = start_pos - mime;
+ // Remove trailing spaces.
+ while (mime_length > 0 && (isspace(mime[mime_length - 1]))) {
+ mime_length--;
+ }
+ // Remove the trailing ';'.
+ if (mime_length > 0 && mime[mime_length - 1] == ';') {
+ mime_length--;
+ }
+ mime_without_attribute = std::string(mime, mime_length);
+ if (attribute_string) {
+ *attribute_string = std::string(start_pos);
}
}
+ return mime_without_attribute;
+}
- void SetCacheMaxSize(int size) { max_size_ = size; }
+// Note that if bitrate parsing failed, |bitrate| will be set to -1.
+void StripAndParseBitrate(const char* mime,
+ std::string* mime_without_bitrate,
+ int* bitrate) {
+ SB_DCHECK(mime_without_bitrate);
+ SB_DCHECK(bitrate);
- void DumpCache() {
- ScopedLock scoped_lock(mutex_);
- std::stringstream ss;
- ss << "\n========Dumping MimeInfoCache========";
- for (const auto& entry_iter : entries_) {
- const ParsedMimeInfo& mime_info = entry_iter.second.mime_info;
- ss << "\nMime: " << entry_iter.first;
- ss << "\n ParsedMimeInfo:";
- ss << "\n MimeType : " << mime_info.mime_type().ToString();
- if (mime_info.is_valid()) {
- if (mime_info.has_audio_info()) {
- const ParsedMimeInfo::AudioCodecInfo& audio_info =
- mime_info.audio_info();
- ss << "\n Audio Codec : "
- << GetMediaAudioCodecName(audio_info.codec);
- ss << "\n Channels : " << audio_info.channels;
- }
- if (mime_info.has_video_info()) {
- const ParsedMimeInfo::VideoCodecInfo& video_info =
- mime_info.video_info();
- ss << "\n Video Codec : "
- << GetMediaVideoCodecName(video_info.codec);
- ss << "\n Profile : " << video_info.profile;
- ss << "\n Level : " << video_info.level;
- ss << "\n BitDepth : " << video_info.bit_depth;
- ss << "\n PrimaryId : "
- << GetMediaPrimaryIdName(video_info.primary_id);
- ss << "\n TransferId : "
- << GetMediaTransferIdName(video_info.transfer_id);
- ss << "\n MatrixId : "
- << GetMediaMatrixIdName(video_info.matrix_id);
- ss << "\n Width : " << video_info.frame_width;
- ss << "\n Height : " << video_info.frame_height;
- ss << "\n Fps : " << video_info.fps;
- ss << "\n DecodeToTexture : "
- << (video_info.decode_to_texture_required ? "true" : "false");
- }
- } else {
- ss << "\n Mime info is not valid";
- }
+ std::string bitrate_string;
+ *mime_without_bitrate =
+ RemoveAttributeFromMime(mime, "bitrate", &bitrate_string);
- ss << "\n Supportability: ";
- switch (entry_iter.second.supportability) {
- case kSupportabilityUnknown:
- ss << "Unknown";
- break;
- case kSupportabilitySupported:
- ss << "Supported";
- break;
- case kSupportabilityNotSupported:
- ss << "NotSupported";
- break;
- }
- }
- ss << "\n========End of Dumping========";
-
- SB_DLOG(INFO) << ss.str();
+ if (bitrate_string.empty()) {
+ *bitrate = 0;
+ return;
}
- private:
- typedef std::unordered_map<std::string, Entry> Entries;
-
- Mutex mutex_;
- Entries entries_;
- std::queue<Entries::iterator> fifo_queue_;
- std::atomic_int max_size_{kDefaultCacheMaxSize};
-};
-
-SB_ONCE_INITIALIZE_FUNCTION(MimeSupportabilityContainer, GetContainer);
+ MimeType::Param param;
+ if (!MimeType::ParseParamString(bitrate_string, ¶m) ||
+ param.type != MimeType::kParamTypeInteger) {
+ *bitrate = -1;
+ return;
+ }
+ SB_DCHECK(param.name == "bitrate");
+ *bitrate = param.int_value;
+}
} // namespace
@@ -182,43 +152,182 @@
SB_ONCE_INITIALIZE_FUNCTION(MimeSupportabilityCache,
MimeSupportabilityCache::GetInstance);
-void MimeSupportabilityCache::SetCacheMaxSize(size_t size) {
- GetContainer()->SetCacheMaxSize(size);
-}
-
Supportability MimeSupportabilityCache::GetMimeSupportability(
- const std::string& mime,
+ const char* mime,
ParsedMimeInfo* mime_info) {
- // Get cached parsed mime infos and supportability. If no cache is found,
- // MimeSupportabilityContainer will parse the mime string, and return a parsed
- // MimeType and its parsed audio/video information.
- const MimeSupportabilityContainer::Entry& entry =
- GetContainer()->GetParsedMimeAndSupportability(mime);
+ SB_DCHECK(mime);
+ SB_DCHECK(mime_info);
- if (mime_info) {
- // Return cached ParsedMimeInfo.
- *mime_info = entry.mime_info;
+ // Strip the bitrate from mime string and check it separately.
+ std::string mime_without_bitrate;
+ int bitrate;
+ StripAndParseBitrate(mime, &mime_without_bitrate, &bitrate);
+
+ if (bitrate < 0) {
+ // The mime string contains an invalid bitrate attribute. In that case, we
+ // return an invalid ParsedMimeInfo with kSbMediaSupportTypeNotSupported.
+ *mime_info = ParsedMimeInfo(mime);
+ return kSupportabilityNotSupported;
}
- return is_enabled_ ? entry.supportability : kSupportabilityUnknown;
+ ScopedLock scoped_lock(mutex_);
+ Entry& entry = GetEntry_Locked(mime_without_bitrate);
+
+ // Return cached ParsedMimeInfo with real bitrate.
+ *mime_info = entry.mime_info;
+ mime_info->SetBitrate(bitrate);
+
+ if (!mime_info->is_valid()) {
+ // Return kSupportabilityNotSupported if we can't get a valid
+ // ParsedMimeInfo.
+ return kSupportabilityNotSupported;
+ }
+
+ return is_enabled_ ? IsBitrateSupported_Locked(entry, bitrate)
+ : kSupportabilityUnknown;
}
void MimeSupportabilityCache::CacheMimeSupportability(
- const std::string& mime,
+ const char* mime,
Supportability supportability) {
+ SB_DCHECK(mime);
+ SB_DCHECK(supportability != kSupportabilityUnknown);
+
if (!is_enabled_) {
return;
}
- if (supportability == kSupportabilityUnknown) {
- SB_LOG(WARNING) << "Rejected unknown supportability.";
+
+ // Strip bitrate as what we do in GetMimeSupportability().
+ std::string mime_without_bitrate;
+ int bitrate;
+ StripAndParseBitrate(mime, &mime_without_bitrate, &bitrate);
+
+ if (bitrate < 0) {
+ // The mime string contains an invalid bitrate attribute.
return;
}
- GetContainer()->CacheSupportability(mime, supportability);
+ ScopedLock scoped_lock(mutex_);
+ Entry& entry = GetEntry_Locked(mime_without_bitrate);
+
+ if (entry.mime_info.is_valid()) {
+ UpdateBitrateSupportability_Locked(&entry, bitrate, supportability);
+ }
}
void MimeSupportabilityCache::ClearCachedMimeSupportabilities() {
- GetContainer()->ClearCachedSupportabilities();
+ ScopedLock scoped_lock(mutex_);
+ for (auto& iter : entries_) {
+ iter.second.max_supported_bitrate = -1;
+ iter.second.min_unsupported_bitrate = INT_MAX;
+ }
+}
+
+void MimeSupportabilityCache::DumpCache() {
+ ScopedLock scoped_lock(mutex_);
+ std::stringstream ss;
+ ss << "\n========Dumping MimeSupportabilityCache========";
+ for (const auto& entry_iter : entries_) {
+ const ParsedMimeInfo& mime_info = entry_iter.second.mime_info;
+ ss << "\nMime: " << entry_iter.first;
+ ss << "\n ParsedMimeInfo:";
+ ss << "\n MimeType : " << mime_info.mime_type().ToString();
+ if (mime_info.is_valid()) {
+ if (mime_info.has_audio_info()) {
+ const ParsedMimeInfo::AudioCodecInfo& audio_info =
+ mime_info.audio_info();
+ ss << "\n Audio Codec : "
+ << GetMediaAudioCodecName(audio_info.codec);
+ ss << "\n Channels : " << audio_info.channels;
+ }
+ if (mime_info.has_video_info()) {
+ const ParsedMimeInfo::VideoCodecInfo& video_info =
+ mime_info.video_info();
+ ss << "\n Video Codec : "
+ << GetMediaVideoCodecName(video_info.codec);
+ ss << "\n Profile : " << video_info.profile;
+ ss << "\n Level : " << video_info.level;
+ ss << "\n BitDepth : " << video_info.bit_depth;
+ ss << "\n PrimaryId : "
+ << GetMediaPrimaryIdName(video_info.primary_id);
+ ss << "\n TransferId : "
+ << GetMediaTransferIdName(video_info.transfer_id);
+ ss << "\n MatrixId : " << GetMediaMatrixIdName(video_info.matrix_id);
+ ss << "\n Width : " << video_info.frame_width;
+ ss << "\n Height : " << video_info.frame_height;
+ ss << "\n Fps : " << video_info.fps;
+ ss << "\n DecodeToTexture : "
+ << (video_info.decode_to_texture_required ? "true" : "false");
+ }
+ } else {
+ ss << "\n Mime info is not valid";
+ }
+
+ ss << "\n MaxSupportedBitrate: "
+ << entry_iter.second.max_supported_bitrate;
+ ss << "\n MinUnsupportedBitrate: "
+ << entry_iter.second.min_unsupported_bitrate;
+ }
+ ss << "\n========End of Dumping========";
+
+ SB_DLOG(INFO) << ss.str();
+}
+
+MimeSupportabilityCache::Entry& MimeSupportabilityCache::GetEntry_Locked(
+ const std::string& mime_string) {
+ auto entry_iter = entries_.find(mime_string);
+ if (entry_iter != entries_.end()) {
+ return entry_iter->second;
+ }
+
+ // We can't find anything from the cache. Parse mime string and cache
+ // parsed ParsedMimeInfo.
+ auto insert_result = entries_.insert({mime_string, Entry(mime_string)});
+
+ // Keep cached items not exceeding max size.
+ fifo_queue_.push(insert_result.first);
+ while (fifo_queue_.size() > max_size_) {
+ entries_.erase(fifo_queue_.front());
+ fifo_queue_.pop();
+ }
+ SB_DCHECK(entries_.size() == fifo_queue_.size());
+
+ return insert_result.first->second;
+}
+
+Supportability MimeSupportabilityCache::IsBitrateSupported_Locked(
+ const Entry& entry,
+ int bitrate) const {
+ SB_DCHECK(bitrate >= 0);
+
+ if (bitrate <= entry.max_supported_bitrate) {
+ return kSupportabilitySupported;
+ }
+ if (bitrate >= entry.min_unsupported_bitrate) {
+ return kSupportabilityNotSupported;
+ }
+ return kSupportabilityUnknown;
+}
+
+void MimeSupportabilityCache::UpdateBitrateSupportability_Locked(
+ Entry* entry,
+ int bitrate,
+ Supportability supportability) {
+ SB_DCHECK(entry);
+ SB_DCHECK(bitrate >= 0);
+ SB_DCHECK(supportability != kSupportabilityUnknown);
+
+ if (supportability == kSupportabilitySupported) {
+ SB_DCHECK(bitrate < entry->min_unsupported_bitrate);
+ if (bitrate > entry->max_supported_bitrate) {
+ entry->max_supported_bitrate = bitrate;
+ }
+ } else if (supportability == kSupportabilityNotSupported) {
+ SB_DCHECK(bitrate > entry->max_supported_bitrate);
+ if (bitrate < entry->min_unsupported_bitrate) {
+ entry->min_unsupported_bitrate = bitrate;
+ }
+ }
}
} // namespace media
diff --git a/starboard/shared/starboard/media/mime_supportability_cache.h b/starboard/shared/starboard/media/mime_supportability_cache.h
index 7eb3d4f..c1e560b 100644
--- a/starboard/shared/starboard/media/mime_supportability_cache.h
+++ b/starboard/shared/starboard/media/mime_supportability_cache.h
@@ -16,8 +16,11 @@
#define STARBOARD_SHARED_STARBOARD_MEDIA_MIME_SUPPORTABILITY_CACHE_H_
#include <atomic>
+#include <queue>
#include <string>
+#include <unordered_map>
+#include "starboard/common/mutex.h"
#include "starboard/shared/internal_only.h"
#include "starboard/shared/starboard/media/parsed_mime_info.h"
@@ -32,34 +35,68 @@
kSupportabilityNotSupported,
} Supportability;
-// TODO: add unit tests for MimeSupportabilityCache
+// MimeSupportabilityCache caches the supportabilities of raw mime strings.
+// To increase cache hit rate, it strips bitrate from the raw mime string, and
+// stores a supported bitrate range for mime strings with same other attributes.
+//
+// Note: MimeSupportabilityCache leverage the assumption that if the
+// platform can support a codec with bitrate of n, the codec should also support
+// any bitrate less than n. If that assumption is not true, please do NOT enable
+// MimeSupportabilityCache.
+//
+// Note: anytime the platform codec capabilities have changed, please call
+// MimeSupportabilityCache::ClearCachedMimeSupportabilities() to clear the
+// outdated results.
+//
+// TODO: add unit tests for MimeSupportabilityCache.
class MimeSupportabilityCache {
public:
static MimeSupportabilityCache* GetInstance();
- // When cache is not enabled, GetMimeSupportability() will always return
- // kSupportabilityUnknown, and CacheMimeSupportability() will do nothing,
- // but GetMimeSupportability() will still return parsed ParsedMimeInfo.
+ // When cache is not enabled, GetMimeSupportability() will return cached
+ // ParsedMimeInfo with kSupportabilityUnknown, and CacheMimeSupportability()
+ // will do nothing.
bool IsEnabled() const { return is_enabled_; }
void SetCacheEnabled(bool enabled) { is_enabled_ = enabled; }
- void SetCacheMaxSize(size_t size);
+ // Set the max number of the cached ParsedMimeInfos and its supportabilities.
+ void SetCacheMaxSize(size_t size) { max_size_ = size; }
- // Get cached mime supportability. The parsed mime information would be
- // returned via |mime_info| if it is not NULL.
- Supportability GetMimeSupportability(const std::string& mime,
+ // Get cached ParsedMimeInfo and mime supportability. If there's no cached
+ // ParsedMimeInfo, it will parse the mime string and cache the result.
+ // If we cannot get a valid ParsedMimeInfo from |mime|,
+ // GetMimeSupportability() will return kSupportabilityNotSupported with an
+ // invalid ParsedMimeInfo. Ideally, we should decouple mime parsing and
+ // supportability cache, but considering that the cache is only for internal
+ // use, to avoid repeated lookups, we do parsing in this function for now.
+ // Note that |mime| and |mime_info| cannot be null.
+ Supportability GetMimeSupportability(const char* mime,
ParsedMimeInfo* mime_info);
- // Cache mime supportability. If there's no cached parsed mime info and
- // supportability for the mime, the function will parse the mime first and
- // then update its supportability.
- void CacheMimeSupportability(const std::string& mime,
- Supportability supportability);
- // Clear all cached supportabilities. Note that it will not remove cached
- // parsed mime infos.
+ // Update cached supportability of the mime string.
+ // Note that if |supportability| is kSupportabilityUnknown or we cannot
+ // get a valid ParsedMimeInfo from |mime|, CacheMimeSupportability()
+ // will not cache the supportability.
+ void CacheMimeSupportability(const char* mime, Supportability supportability);
+
+ // Clear all cached supportabilities. But it will not remove cached
+ // ParsedMimeInfos, as for the same mime string, the parsed results should be
+ // always the same.
void ClearCachedMimeSupportabilities();
+ void DumpCache();
+
private:
+ const int kDefaultCacheMaxSize = 2000;
+
+ struct Entry {
+ ParsedMimeInfo mime_info;
+ int max_supported_bitrate = -1;
+ int min_unsupported_bitrate = INT_MAX;
+
+ explicit Entry(const std::string& mime) : mime_info(mime) {}
+ };
+
// Class can only be instanced via the singleton
MimeSupportabilityCache() {}
~MimeSupportabilityCache() {}
@@ -67,6 +104,19 @@
MimeSupportabilityCache(const MimeSupportabilityCache&) = delete;
MimeSupportabilityCache& operator=(const MimeSupportabilityCache&) = delete;
+ Entry& GetEntry_Locked(const std::string& mime_string);
+ Supportability IsBitrateSupported_Locked(const Entry& entry,
+ int bitrate) const;
+ void UpdateBitrateSupportability_Locked(Entry* entry,
+ int bitrate,
+ Supportability supportability);
+
+ typedef std::unordered_map<std::string, Entry> Entries;
+
+ Mutex mutex_;
+ Entries entries_;
+ std::queue<Entries::iterator> fifo_queue_;
+ std::atomic_int max_size_{kDefaultCacheMaxSize};
std::atomic_bool is_enabled_{false};
};
diff --git a/starboard/shared/starboard/media/mime_util.cc b/starboard/shared/starboard/media/mime_util.cc
index 518338f..6c53aa7 100644
--- a/starboard/shared/starboard/media/mime_util.cc
+++ b/starboard/shared/starboard/media/mime_util.cc
@@ -21,7 +21,6 @@
#include "starboard/common/log.h"
#include "starboard/common/media.h"
#include "starboard/log.h"
-#include "starboard/shared/starboard/media/bitrate_supportability_cache.h"
#include "starboard/shared/starboard/media/key_system_supportability_cache.h"
#include "starboard/shared/starboard/media/media_support_internal.h"
#include "starboard/shared/starboard/media/mime_supportability_cache.h"
@@ -35,91 +34,6 @@
namespace {
-// RemoveAttributeFromMime() will return a new mime string with the specified
-// attribute removed. If |attribute_string| is not null, the removed attribute
-// string will be returned via |attribute_string|. Following are some examples:
-// mime: "video/webm; codecs=\"vp9\"; bitrate=300000"
-// attribute_name: "bitrate"
-// return: "video/webm; codecs=\"vp9\""
-// attribute_string: "bitrate=300000"
-//
-// mime: "video/webm; codecs=\"vp9\"; bitrate=300000; eotf=bt709"
-// attribute_name: "bitrate"
-// return: "video/webm; codecs=\"vp9\"; eotf=bt709"
-// attribute_string: "bitrate=300000"
-//
-// mime: "bitrate=300000"
-// attribute_name: "bitrate"
-// return: ""
-// attribute_string: "bitrate=300000"
-std::string RemoveAttributeFromMime(const char* mime,
- const char* attribute_name,
- std::string* attribute_string) {
- size_t name_length = strlen(attribute_name);
- if (name_length == 0) {
- return mime;
- }
-
- std::string mime_without_attribute;
- const char* start_pos = strstr(mime, attribute_name);
- while (start_pos) {
- if ((start_pos == mime || start_pos[-1] == ';' || isspace(start_pos[-1])) &&
- (start_pos[name_length] &&
- (start_pos[name_length] == '=' || isspace(start_pos[name_length])))) {
- break;
- }
- start_pos += name_length;
- start_pos = strstr(start_pos, attribute_name);
- }
-
- if (!start_pos) {
- // Target attribute is not found.
- return std::string(mime);
- }
- const char* end_pos = strstr(start_pos, ";");
- if (end_pos) {
- // There may be other attribute after target attribute.
- if (attribute_string) {
- // Returned |attribute_string| will not have a trailing ';'.
- attribute_string->assign(start_pos, end_pos - start_pos);
- }
-
- end_pos++;
- // Remove leading spaces.
- while (*end_pos && isspace(*end_pos)) {
- end_pos++;
- }
- if (*end_pos) {
- // Append the string after target attribute.
- mime_without_attribute = std::string(mime, start_pos - mime);
- mime_without_attribute.append(end_pos);
- } else {
- // Target attribute is the last one. Remove trailing spaces.
- size_t mime_length = start_pos - mime;
- while (mime_length > 0 && (isspace(mime[mime_length - 1]))) {
- mime_length--;
- }
- mime_without_attribute = std::string(mime, mime_length);
- }
- } else {
- // It can't find a trailing ';'. The target attribute must be the last one.
- size_t mime_length = start_pos - mime;
- // Remove trailing spaces.
- while (mime_length > 0 && (isspace(mime[mime_length - 1]))) {
- mime_length--;
- }
- // Remove the trailing ';'.
- if (mime_length > 0 && mime[mime_length - 1] == ';') {
- mime_length--;
- }
- mime_without_attribute = std::string(mime, mime_length);
- if (attribute_string) {
- *attribute_string = std::string(start_pos);
- }
- }
- return mime_without_attribute;
-}
-
// Use SbMediaGetAudioConfiguration() to check if the platform can support
// |channels|.
bool IsAudioOutputSupported(SbMediaAudioCodingType coding_type, int channels) {
@@ -255,22 +169,6 @@
video_info.decode_to_texture_required);
}
-bool ValidateAndParseBitrate(const std::string& bitrate_string, int* bitrate) {
- SB_DCHECK(!bitrate_string.empty());
-
- MimeType::Param param;
- if (!MimeType::ParseParamString(bitrate_string, ¶m)) {
- return false;
- }
- if (param.type != MimeType::kParamTypeInteger) {
- return false;
- }
- if (bitrate) {
- *bitrate = param.int_value;
- }
- return true;
-}
-
} // namespace
SbMediaSupportType CanPlayMimeAndKeySystem(const char* mime,
@@ -278,38 +176,19 @@
SB_DCHECK(mime);
SB_DCHECK(key_system);
- // Remove bitrate from mime string and read bitrate if presents.
- std::string bitrate_string;
- std::string mime_without_bitrate =
- RemoveAttributeFromMime(mime, "bitrate", &bitrate_string);
- int bitrate = 0;
- if (!bitrate_string.empty()) {
- if (!ValidateAndParseBitrate(bitrate_string, &bitrate)) {
- return kSbMediaSupportTypeNotSupported;
- }
- }
-
- if (bitrate < 0) {
- // Reject invalid bitrate.
- return kSbMediaSupportTypeNotSupported;
- }
-
- // Get cached parsed mime infos and supportability. If it is not found in the
- // cache, MimeSupportabilityCache would parse the mime string and return a
- // ParsedMimeInfo.
+ // Get cached ParsedMimeInfo with its supportability. If it is not found in
+ // the cache, MimeSupportabilityCache would parse the mime string and return
+ // the ParsedMimeInfo with kSupportabilityUnknown.
ParsedMimeInfo mime_info;
Supportability mime_supportability =
- MimeSupportabilityCache::GetInstance()->GetMimeSupportability(
- mime_without_bitrate, &mime_info);
- // Overwrite the bitrate.
- mime_info.SetBitrate(bitrate);
+ MimeSupportabilityCache::GetInstance()->GetMimeSupportability(mime,
+ &mime_info);
if (mime_info.disable_cache()) {
// Disable all caches if required.
mime_supportability = kSupportabilityUnknown;
MimeSupportabilityCache::GetInstance()->SetCacheEnabled(false);
KeySystemSupportabilityCache::GetInstance()->SetCacheEnabled(false);
- BitrateSupportabilityCache::GetInstance()->SetCacheEnabled(false);
}
// Reject mime if cached result is not supported.
@@ -317,10 +196,10 @@
return kSbMediaSupportTypeNotSupported;
}
- // Reject mime if parsed mime info is invalid.
- if (!mime_info.is_valid()) {
- return kSbMediaSupportTypeNotSupported;
- }
+ // MimeSupportabilityCache::GetMimeSupportability() returns
+ // kSupportabilityNotSupported if ParsedMimeInfo is not valid, so |mime_info|
+ // must be valid here.
+ SB_DCHECK(mime_info.is_valid());
const MimeType& mime_type = mime_info.mime_type();
const std::vector<std::string>& codecs = mime_type.GetCodecs();
@@ -379,26 +258,14 @@
}
}
- // Get cached bitrate supportability.
- Supportability bitrate_supportability =
- BitrateSupportabilityCache::GetInstance()->GetBitrateSupportability(
- mime_info);
-
- // Reject mime if bitrate is not supported.
- if (bitrate_supportability == kSupportabilityNotSupported) {
- return kSbMediaSupportTypeNotSupported;
- }
-
- // Return supported if mime and bitrate are all supported.
- if (mime_supportability == kSupportabilitySupported &&
- bitrate_supportability == kSupportabilitySupported) {
+ // At this point, |key_system| is supported. Return supported here if
+ // mime is also supported. Otherwise, |mime_supportability| must be unknown.
+ if (mime_supportability == kSupportabilitySupported) {
return kSbMediaSupportTypeProbably;
}
+ SB_DCHECK(mime_supportability == kSupportabilityUnknown);
- // At this point, either mime or bitrate supportability must be unknown.
- // Call platform functions to check if they are supported.
- SB_DCHECK(mime_supportability == kSupportabilityUnknown ||
- bitrate_supportability == kSupportabilityUnknown);
+ // Call platform functions to check if it's supported.
if (mime_info.has_audio_info() && !IsSupportedAudioCodec(mime_info)) {
mime_supportability = kSupportabilityNotSupported;
} else if (mime_info.has_video_info() && !IsSupportedVideoCodec(mime_info)) {
@@ -407,13 +274,10 @@
mime_supportability = kSupportabilitySupported;
}
- // Cache mime supportability when bitrate supportability is known.
- if (bitrate_supportability == kSupportabilitySupported) {
- MimeSupportabilityCache::GetInstance()->CacheMimeSupportability(
- mime_without_bitrate, mime_supportability);
- }
+ // Cache mime supportability.
+ MimeSupportabilityCache::GetInstance()->CacheMimeSupportability(
+ mime, mime_supportability);
- SB_DCHECK(mime_supportability != kSupportabilityUnknown);
return mime_supportability == kSupportabilitySupported
? kSbMediaSupportTypeProbably
: kSbMediaSupportTypeNotSupported;
diff --git a/starboard/shared/starboard/player/player_create.cc b/starboard/shared/starboard/player/player_create.cc
index 16bc57f..7ffb717 100644
--- a/starboard/shared/starboard/player/player_create.cc
+++ b/starboard/shared/starboard/player/player_create.cc
@@ -138,8 +138,9 @@
const int64_t kDefaultBitRate = 0;
if (audio_codec != kSbMediaAudioCodecNone) {
const MimeType audio_mime_type(audio_mime);
- if (!SbMediaIsAudioSupported(audio_codec, &audio_mime_type,
- kDefaultBitRate)) {
+ if (!SbMediaIsAudioSupported(
+ audio_codec, strlen(audio_mime) > 0 ? &audio_mime_type : nullptr,
+ kDefaultBitRate)) {
SB_LOG(ERROR) << "Unsupported audio codec "
<< starboard::GetMediaAudioCodecName(audio_codec) << ".";
player_error_func(kSbPlayerInvalid, context, kSbPlayerErrorDecode,
@@ -160,11 +161,11 @@
if (video_codec != kSbMediaVideoCodecNone) {
const MimeType video_mime_type(video_mime);
if (!SbMediaIsVideoSupported(
- video_codec, &video_mime_type, kDefaultProfile, kDefaultLevel,
- kDefaultColorDepth, kSbMediaPrimaryIdUnspecified,
- kSbMediaTransferIdUnspecified, kSbMediaMatrixIdUnspecified,
- kDefaultFrameWidth, kDefaultFrameHeight, kDefaultBitRate,
- kDefaultFrameRate,
+ video_codec, strlen(video_mime) > 0 ? &video_mime_type : nullptr,
+ kDefaultProfile, kDefaultLevel, kDefaultColorDepth,
+ kSbMediaPrimaryIdUnspecified, kSbMediaTransferIdUnspecified,
+ kSbMediaMatrixIdUnspecified, kDefaultFrameWidth,
+ kDefaultFrameHeight, kDefaultBitRate, kDefaultFrameRate,
output_mode == kSbPlayerOutputModeDecodeToTexture)) {
SB_LOG(ERROR) << "Unsupported video codec "
<< starboard::GetMediaVideoCodecName(video_codec) << ".";
