Import Cobalt 23.master.0.309337
diff --git a/cobalt/bindings/templates/dictionary.h.template b/cobalt/bindings/templates/dictionary.h.template
index b31fb2c..d178bd6 100644
--- a/cobalt/bindings/templates/dictionary.h.template
+++ b/cobalt/bindings/templates/dictionary.h.template
@@ -60,7 +60,7 @@
{% if used_class.conditional %}
#if defined({{used_class.conditional}})
{% endif %}
-using {{used_class.fully_qualified_name}};
+using ::{{used_class.fully_qualified_name}};
{% if used_class.conditional %}
#endif // defined({{used_class.conditional}})
{% endif %}
diff --git a/cobalt/black_box_tests/black_box_tests.py b/cobalt/black_box_tests/black_box_tests.py
index 7ac37d0..34b2ffe 100644
--- a/cobalt/black_box_tests/black_box_tests.py
+++ b/cobalt/black_box_tests/black_box_tests.py
@@ -63,8 +63,6 @@
'allow_eval',
'compression_test',
'disable_eval_with_csp',
- # http_cache is disabled due to flakiness. Planned update to make use of
- # transferSize rather than load timings to make it more consistent.
'http_cache',
'persistent_cookie',
'soft_mic_platform_service_test',
@@ -72,6 +70,8 @@
'web_debugger',
'web_platform_tests',
'web_worker_test',
+ 'worker_csp_test',
+ 'service_worker_message_test',
'service_worker_test',
]
# These tests can only be run on platforms whose app launcher can send deep
diff --git a/cobalt/black_box_tests/testdata/http_cache.html b/cobalt/black_box_tests/testdata/http_cache.html
index cad147f..e1f2e48 100644
--- a/cobalt/black_box_tests/testdata/http_cache.html
+++ b/cobalt/black_box_tests/testdata/http_cache.html
@@ -1,10 +1,34 @@
<!DOCTYPE html>
+<!--
+ To add a new check to this test:
+ 1. Create the test file to be loaded and place it in
+ /testdata/http_cache_test_resources/. The server delays responses when
+ serving files from that directory, to make a clear distinction of what's
+ being loaded from the cache.
+ 2. Add the file name to either CACHED_ELEMENT_LOCATIONS if you expect that
+ file's mime type to be cached or UNCACHED_ELEMENT_LOCATIONS if you
+ expect the file to be excluded from the cache.
+ 3. Add a call to the window.onload function to fetch your file, making a
+ call to measureLoadTime after the file has been loaded.
+-->
<head>
<title>Cobalt HTTP Cache Test</title>
<script src="black_box_js_test_utils.js"></script>
<script>
- var NUMBER_OF_CACHE_ELEMENTS = Number.MAX_SAFE_INTEGER;
+ var TESTDATA_LOCATION = window.location.protocol + '//'
+ + window.location.host
+ + '/testdata/http_cache_test_resources/';
+ var CACHED_ELEMENT_LOCATIONS = {
+ 'js': TESTDATA_LOCATION + 'http_cache.js',
+ 'img': TESTDATA_LOCATION + 'cobalt_logo.png',
+ 'css': TESTDATA_LOCATION + 'http_cache.css',
+ };
+ var UNCACHED_ELEMENT_LOCATIONS = {
+ 'txt': TESTDATA_LOCATION + 'http_cache.txt',
+ };
+ var EXPECTED_NUMBER_OF_ELEMENTS = Object.keys(CACHED_ELEMENT_LOCATIONS).length
+ + Object.keys(UNCACHED_ELEMENT_LOCATIONS).length;
var loadTimes = new Map();
var cacheSize = 0;
@@ -20,50 +44,90 @@
var initialLoadTime = loadTimes.has('initialLoadTime') ?
loadTimes.get('initialLoadTime') : new Date().getTime();
var reloadUrl = 'http_cache.html?initialLoadTime=' + initialLoadTime;
+ // Append the timestamp string to each resource url to force reload the
+ // files the first time the page is accessed each test run. The load time
+ // is recorded on the first run and passed to the second run to ensure
+ // the same url is used both times.
+ var timestampString = '?t=' + initialLoadTime;
+ // Validate the tranferSize attribute of each performance entry specified
+ // in CACHED_ELEMENT_LOCATIONS and UNCACHED_ELEMENT_LOCATIONS.
+ function checkTransferSizes() {
+ let elementsChecked = 0;
+ // https://www.w3.org/TR/resource-timing-2/#dom-performanceresourcetiming-transfersize
+ // Verify that the transferSize attribute for each resource is less than
+ // 300. If greater than 300, it wasn't fetched from the cache.
+ for (let location in CACHED_ELEMENT_LOCATIONS) {
+ elementsChecked++;
+ let tranferSize = performance.getEntriesByName(CACHED_ELEMENT_LOCATIONS[location] + timestampString)[0].transferSize;
+ if (tranferSize > 300) {
+ console.log('Element at ' + CACHED_ELEMENT_LOCATIONS[location]
+ + ' was expected to be cached, but was loaded from the server instead.');
+ notReached();
+ }
+ }
+
+ for (let location in UNCACHED_ELEMENT_LOCATIONS) {
+ elementsChecked++;
+ let tranferSize = performance.getEntriesByName(UNCACHED_ELEMENT_LOCATIONS[location] + timestampString)[0].transferSize;
+ if (tranferSize <= 300) {
+ console.log('Element at ' + UNCACHED_ELEMENT_LOCATIONS[location]
+ + ' was not expected to be cached, but was loaded from the cache.');
+ notReached();
+ }
+ }
+
+ if (elementsChecked == (EXPECTED_NUMBER_OF_ELEMENTS)) {
+ onEndTest();
+ } else {
+ console.log(elementsChecked + ' elements were checked, but '
+ + EXPECTED_NUMBER_OF_ELEMENTS
+ + ' elements were expected. Verify that EXPECTED_NUMBER_OF_ELEMENTS is correctly set.');
+ notReached();
+ }
+ }
+
+ // On first page load, measure the load time of the specified element and
+ // update the reloadUrl to record the load time. Once the expected number of
+ // elements is reached, reload the page.
+ // On second load, measure the load time of the specified element and
+ // compare it to the first load time to validate if the cache was used,
+ // failing the test if the second load took longer.
function measureLoadTime(element, initialTime) {
cacheSize++;
onLoadTime = new Date().getTime() - initialTime;
if (loadTimes.has(element)) {
- // TODO: change to using transferSize once its implemented (b/231475964)
- // Load times might give false positives, but should rarely give false
- // negatives (i.e. this may pass when caching didn't actually occur,
- // but will likely never fail when caching does occur).
console.log(element + ' first load time: ' + loadTimes.get(element));
console.log(element + ' second load time: ' + onLoadTime);
- assertTrue(onLoadTime <= loadTimes.get(element));
- if (cacheSize == NUMBER_OF_CACHE_ELEMENTS) {
- onEndTest();
+ if (cacheSize == EXPECTED_NUMBER_OF_ELEMENTS) {
+ setTimeout(() => { checkTransferSizes(); }, 500);
}
} else {
reloadUrl += '&' + element + '=' + onLoadTime;
- if (cacheSize == NUMBER_OF_CACHE_ELEMENTS) {
+ if (cacheSize == EXPECTED_NUMBER_OF_ELEMENTS) {
setTimeout(() => { window.location.href = reloadUrl; }, 100);
}
}
}
+
+
// Add elements after window loads. In Cobalt, adding the onload property
// directly to an html tag doesn't execute.
window.onload = function () {
- NUMBER_OF_CACHE_ELEMENTS = document.getElementsByTagName('div').length;
- // Append the timestamp string to each resource url to force reload the
- // files the first time the page is accessed each test run. The load time
- // is recorded on the first run and passed to the second run to ensure
- // the same url is used both times.
- let timestampString = '?t=' + initialLoadTime;
-
+ // text/javascript
let initialJsTime = new Date().getTime();
let script = document.createElement('script');
- script.onload = () => {
+ script.onload = (event) => {
measureLoadTime('javascript', initialJsTime);
};
script.onerror = () => {
notReached();
};
- script.src = 'http_cache_test_resources/http_cache.js' + timestampString;
+ script.src = CACHED_ELEMENT_LOCATIONS['js'] + timestampString;
document.getElementById('js_div').appendChild(script);
+ // image/png
let initialImgTime = new Date().getTime();
let image = document.createElement('img');
image.onload = () => {
@@ -72,10 +136,11 @@
image.onerror = (e) => {
notReached();
};
- image.src = 'http_cache_test_resources/cobalt_logo.png' + timestampString;
+ image.src = CACHED_ELEMENT_LOCATIONS['img'] + timestampString;
image.alt = 'falied to load image';
document.getElementById('image_div').appendChild(image);
+ // text/css
let initialCssTime = new Date().getTime();
let css = document.createElement('link');
css.onload = () => {
@@ -85,8 +150,19 @@
notReached();
};
css.rel = 'stylesheet';
- css.href = 'http_cache_test_resources/http_cache.css' + timestampString;
+ css.href = CACHED_ELEMENT_LOCATIONS['css'] + timestampString;
document.getElementById('css_div').appendChild(css);
+
+ // text/plain
+ let initialTxtTime = new Date().getTime();
+ let txt = document.createElement('p');
+ fetch(UNCACHED_ELEMENT_LOCATIONS['txt'] + timestampString)
+ .then(response => response.text())
+ .then(text => {
+ txt.innerHTML = text;
+ document.getElementById('txt_div').appendChild(txt);
+ measureLoadTime('txt', initialTxtTime);
+ });
}
</script>
@@ -103,4 +179,7 @@
<div id="css_div">
<h2>Loading CSS file</h2>
</div>
+ <div id="txt_div">
+ <h2>Loading txt file</h2>
+ </div>
</body>
diff --git a/cobalt/black_box_tests/testdata/http_cache_test_resources/http_cache.txt b/cobalt/black_box_tests/testdata/http_cache_test_resources/http_cache.txt
new file mode 100644
index 0000000..ad4f0dc
--- /dev/null
+++ b/cobalt/black_box_tests/testdata/http_cache_test_resources/http_cache.txt
@@ -0,0 +1 @@
+Cobalt does not cache text/plain files. This is NOT expected to be cached.
diff --git a/cobalt/black_box_tests/testdata/service_worker_message_test.html b/cobalt/black_box_tests/testdata/service_worker_message_test.html
new file mode 100644
index 0000000..ac8f3f4
--- /dev/null
+++ b/cobalt/black_box_tests/testdata/service_worker_message_test.html
@@ -0,0 +1,129 @@
+<!DOCTYPE html>
+<!--
+ 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.
+-->
+<!--
+ This is a basic test of the message event for service workers.
+-->
+
+<html>
+
+<head>
+ <title>Cobalt Service Worker Message Test</title>
+ <script src='black_box_js_test_utils.js'></script>
+</head>
+
+<body>
+ <script>
+ var expected_event_count = 0;
+
+ function count_event(expected_value) {
+ expected_event_count += 1;
+ console.log('Expected events counted:', expected_event_count)
+ if (expected_value) {
+ assertEqual(expected_value, expected_event_count)
+ }
+ return expected_event_count;
+ }
+
+ navigator.serviceWorker.onmessage = function (event) {
+ console.log('Got onmessage event ', JSON.stringify(event.data));;
+ assertTrue(event instanceof MessageEvent);
+ assertEqual('[object MessageEvent]', `${event}`);
+ assertEqual('[object ServiceWorkerContainer]', `${event.target}`);
+ assertEqual('[object Object]', `${event.data}`);
+ switch (count_event()) {
+ case 3:
+ assertEqual('Foo', event.data.text);
+ assertEqual('BarString', event.data.bar);
+ break;
+ case 4:
+ assertEqual('Service Worker received a message',
+ event.data.text);
+ assertEqual('{"message":"Registration ready resolved."}',
+ JSON.stringify(event.data.data));
+ assertEqual('[object ExtendableMessageEvent]',
+ event.data.event_type);
+ break;
+ case 5:
+ assertEqual('Foo', event.data.text);
+ assertEqual('BarString', event.data.bar);
+ break;
+ case 6:
+ assertEqual('Service Worker received a message',
+ event.data.text);
+ assertEqual('"Controllerchange event received."',
+ JSON.stringify(event.data.data));
+ assertEqual('[object ExtendableMessageEvent]',
+ event.data.event_type);
+ break;
+ default:
+ notReached();
+ break;
+ }
+
+ }
+
+ navigator.serviceWorker.oncontrollerchange = function (event) {
+ console.log('Got oncontrollerchange event', event.target);
+ count_event(2);
+ navigator.serviceWorker.controller.postMessage(
+ 'Controllerchange event received.');
+ }
+
+ navigator.serviceWorker.ready.then(function (
+ registration) {
+ assertNotEqual(null, registration);
+ assertNotEqual(null, registration.active);
+ registration.active.postMessage({ message:
+ 'Registration ready resolved.'});
+ count_event(1);
+ window.setTimeout(
+ () => {
+ registration.unregister()
+ .then(function (success) {
+ console.log('(Expected) unregister success :',
+ success);
+ count_event(7);
+ }, function (error) {
+ console.log('(Unexpected) unregister ' +
+ `${error}`, error);
+ assertIncludes('SecurityError: ', `${error}`);
+ notReached();
+ });
+ }, 1000);
+ });
+
+ navigator.serviceWorker.register('service_worker_message_test.js', {
+ scope: './',
+ }).catch(function (error) {
+ console.log('(Unexpected) :', error);
+ notReached();
+ });
+
+ setupFinished();
+ // This delay has to be long enough to guarantee that the test has
+ // finished.
+ window.setTimeout(
+ () => {
+ console.log('Events:', expected_event_count)
+ assertEqual(7, expected_event_count);
+ onEndTest();
+ }, 2000);
+
+ </script>
+</body>
+
+</html>
diff --git a/cobalt/black_box_tests/testdata/service_worker_message_test.js b/cobalt/black_box_tests/testdata/service_worker_message_test.js
new file mode 100644
index 0000000..20a3334
--- /dev/null
+++ b/cobalt/black_box_tests/testdata/service_worker_message_test.js
@@ -0,0 +1,49 @@
+// 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.
+
+console.log('Service Worker Script Started');
+self.onmessage = function (event) {
+ console.log('Got onmessage event', event, JSON.stringify(event.data), event.source, event.target);
+ if (event instanceof ExtendableMessageEvent) {
+ var options = {
+ includeUncontrolled: false, type: 'window'
+ };
+ event.waitUntil(self.clients.matchAll(options).then(function (clients) {
+ for (var i = 0; i < clients.length; i++) {
+ message = { text: 'Foo', bar: 'BarString' };
+ console.log('Posting to client:', JSON.stringify(message));
+ clients[i].postMessage(message);
+ }
+ }));
+ event.waitUntil(self.clients.matchAll(options).then(function (clients) {
+ for (var i = 0; i < clients.length; i++) {
+ message = {
+ text: 'Service Worker received a message',
+ data: event.data,
+ event_type: `${event}`
+ }
+ console.log('Posting to client:', JSON.stringify(message));
+ clients[i].postMessage(message);
+ }
+ }));
+ }
+}
+
+self.onactivate = function (e) {
+ e.waitUntil(self.clients.claim().then(function (result) {
+ console.log('(Expected) self.clients.claim():', result);
+ }, function (error) {
+ console.log(`(Unexpected) self.clients.claim(): ${error}`, error);
+ }));
+}
diff --git a/cobalt/black_box_tests/testdata/web_worker_test.html b/cobalt/black_box_tests/testdata/web_worker_test.html
index 2976cdf..9be8f5b 100644
--- a/cobalt/black_box_tests/testdata/web_worker_test.html
+++ b/cobalt/black_box_tests/testdata/web_worker_test.html
@@ -37,9 +37,10 @@
console.log('running');
// This is expected trigger a an error event on window.
- var worker_with_error = new Worker('web_worker_test_with_syntax_error.js');
+ var worker_with_error = new Worker('web_worker_test_with_syntax_error.js',
+ { name : 'worker_with_error'});
- var worker = new Worker('web_worker_test.js');
+ var worker = new Worker('web_worker_test.js', { name : 'test_worker'});
console.log(worker);
worker.onmessage = function (event) {
message_event_count += 1;
diff --git a/cobalt/black_box_tests/testdata/worker_csp_test.html b/cobalt/black_box_tests/testdata/worker_csp_test.html
new file mode 100644
index 0000000..fdb1cea
--- /dev/null
+++ b/cobalt/black_box_tests/testdata/worker_csp_test.html
@@ -0,0 +1,39 @@
+<!DOCTYPE html>
+<!--
+ 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.
+-->
+
+<head>
+ <title>Verify that XHR on workers correctly follows CSP</title>
+ <script src='black_box_js_test_utils.js'></script>
+</head>
+
+<body style="background-color: white;">
+ <h1>
+ <span>ID element</span>
+ </h1>
+ <script>
+ var worker = new Worker('worker_csp_test.js');
+ worker.onmessage = function (event) {
+ notReached();
+ };
+
+ window.setTimeout(
+ () => {
+ worker.terminate();
+ onEndTest();
+ }, 250);
+ </script>
+</body>
diff --git a/cobalt/black_box_tests/testdata/worker_csp_test.js b/cobalt/black_box_tests/testdata/worker_csp_test.js
new file mode 100644
index 0000000..58874aa
--- /dev/null
+++ b/cobalt/black_box_tests/testdata/worker_csp_test.js
@@ -0,0 +1,6 @@
+const xhr = new XMLHttpRequest();
+// Script should fail and stop execution at this step due to SecurityViolation.
+xhr.open("GET", "http://www.google.com");
+xhr.send();
+
+self.postMessage("Should not be reached!");
diff --git a/cobalt/black_box_tests/tests/http_cache.py b/cobalt/black_box_tests/tests/http_cache.py
index 3b24fc5..63719ff 100644
--- a/cobalt/black_box_tests/tests/http_cache.py
+++ b/cobalt/black_box_tests/tests/http_cache.py
@@ -35,7 +35,7 @@
parsed_path = urlparse(self.path)
if parsed_path.path.startswith('/testdata/http_cache_test_resources/'):
- time.sleep(10)
+ time.sleep(3)
return SimpleHTTPServer.SimpleHTTPRequestHandler.do_GET(self)
diff --git a/cobalt/black_box_tests/tests/service_worker_message_test.py b/cobalt/black_box_tests/tests/service_worker_message_test.py
new file mode 100644
index 0000000..9e92654
--- /dev/null
+++ b/cobalt/black_box_tests/tests/service_worker_message_test.py
@@ -0,0 +1,30 @@
+# 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.
+"""Tests Service Worker Messaging functionality."""
+
+from cobalt.black_box_tests import black_box_tests
+from cobalt.black_box_tests.threaded_web_server import ThreadedWebServer
+
+
+class ServiceWorkerMessageTest(black_box_tests.BlackBoxTestCase):
+ """Test basic Service Worker functionality."""
+
+ def test_simple(self):
+
+ with ThreadedWebServer(binding_address=self.GetBindingAddress()) as server:
+ url = server.GetURL(file_name='testdata/service_worker_message_test.html')
+
+ with self.CreateCobaltRunner(url=url) as runner:
+ runner.WaitForJSTestsSetup()
+ self.assertTrue(runner.JSTestsSucceeded())
diff --git a/cobalt/black_box_tests/tests/worker_csp_test.py b/cobalt/black_box_tests/tests/worker_csp_test.py
new file mode 100644
index 0000000..1af8735
--- /dev/null
+++ b/cobalt/black_box_tests/tests/worker_csp_test.py
@@ -0,0 +1,44 @@
+# 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.
+"""Tests workers handling CSP Violations."""
+
+import os
+
+from cobalt.black_box_tests import black_box_tests
+from cobalt.black_box_tests.threaded_web_server import ThreadedWebServer, MakeCustomHeaderRequestHandlerClass
+
+paths_to_headers = {
+ 'worker_csp_test.html': {
+ 'Content-Security-Policy':
+ "script-src 'unsafe-inline' 'self'; connect-src 'self';"
+ },
+ 'worker_csp_test.js': {
+ 'Content-Security-Policy': "connect-src 'self';"
+ }
+}
+
+
+class WorkerCspTest(black_box_tests.BlackBoxTestCase):
+ """Verify correct correct CSP behavior."""
+
+ def test_simple(self):
+ path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+ with ThreadedWebServer(
+ binding_address=self.GetBindingAddress(),
+ handler=MakeCustomHeaderRequestHandlerClass(
+ path, paths_to_headers)) as server:
+ url = server.GetURL(file_name='testdata/worker_csp_test.html')
+
+ with self.CreateCobaltRunner(url=url) as runner:
+ self.assertTrue(runner.JSTestsSucceeded())
diff --git a/cobalt/black_box_tests/threaded_web_server.py b/cobalt/black_box_tests/threaded_web_server.py
index 1064355..1e173e3 100644
--- a/cobalt/black_box_tests/threaded_web_server.py
+++ b/cobalt/black_box_tests/threaded_web_server.py
@@ -60,6 +60,87 @@
return TestDataHTTPRequestHandler
+def MakeCustomHeaderRequestHandlerClass(base_path, paths_to_headers):
+ """RequestHandler that serves files that reside relative to base_path.
+
+ Args:
+ base_path: A path considered to be the root directory.
+ paths_to_headers: A dictionary with keys partial paths and values of header
+ dicts. Key is expected to be a substring of a file being served.
+
+ E.g. if you have a test with files foo.html and foo.js, you can serve them
+ separate headers with the following:
+ paths_to_headers = {
+ 'foo.html': {
+ 'Content-Security-Policy', "script-src 'unsafe-inline';"
+ },
+ 'foo.js': {'Content-Security-Policy', "default-src 'self';"}
+ }
+
+ Returns:
+ A RequestHandler class.
+ """
+
+ class TestDataHTTPRequestHandler(SimpleHTTPServer.SimpleHTTPRequestHandler):
+ """Handles HTTP requests and serves responses with specified headers.
+
+ For testing purposes only.
+ """
+
+ _current_working_directory = os.getcwd()
+ _base_path = base_path
+ _paths_to_headers = paths_to_headers
+
+ def do_GET(self): # pylint: disable=invalid-name
+ content = self.get_content()
+ self.wfile.write(content)
+
+ def do_HEAD(self): # pylint: disable=invalid-name
+ # Run get_content to send the headers, but ignore the returned results
+ self.get_content()
+
+ def translate_path(self, path):
+ """Translate the request path to the file in the testdata directory."""
+
+ potential_path = SimpleHTTPServer.SimpleHTTPRequestHandler.translate_path(
+ self, path)
+ potential_path = potential_path.replace(self._current_working_directory,
+ self._base_path)
+ return potential_path
+
+ def get_content(self):
+ """Returns the contents of the file at path with added headers."""
+ path = self.translate_path(self.path)
+ modified_date_time = None
+ raw_content = None
+ try:
+ with open(path, 'rb') as f:
+ filestream = os.fstat(f.fileno())
+ modified_date_time = self.date_time_string(filestream.st_mtime)
+ raw_content = f.read()
+ except IOError:
+ self.send_error(404, 'File not found')
+ return None
+
+ content_type = self.guess_type(path)
+ self.send_response(200)
+ self.send_header('Content-type', content_type)
+ for partial_path, headers in self._paths_to_headers.items():
+ if partial_path in path:
+ for header_key, header_value in headers.items():
+ self.send_header(header_key, header_value)
+
+ content_length = len(raw_content)
+
+ self.send_header('Content-Length', content_length)
+ self.send_header('Last-Modified', modified_date_time)
+ self.end_headers()
+
+ return raw_content
+
+ return TestDataHTTPRequestHandler
+
+
class ThreadedWebServer(object):
"""A HTTP WebServer that serves requests in a separate thread."""
diff --git a/cobalt/browser/application.cc b/cobalt/browser/application.cc
index b6a691f..855b484 100644
--- a/cobalt/browser/application.cc
+++ b/cobalt/browser/application.cc
@@ -100,6 +100,15 @@
const char kPersistentSettingsJson[] = "settings.json";
+// The watchdog client name used to represent Stats.
+const char kWatchdogName[] = "stats";
+// The watchdog time interval in microseconds allowed between pings before
+// triggering violations.
+const int64_t kWatchdogTimeInterval = 10000000;
+// The watchdog time wait in microseconds to initially wait before triggering
+// violations.
+const int64_t kWatchdogTimeWait = 2000000;
+
bool IsStringNone(const std::string& str) {
return !base::strcasecmp(str.c_str(), "none");
}
@@ -512,12 +521,13 @@
"available trackers.";
#endif // defined(ENABLE_DEBUGGER) && defined(STARBOARD_ALLOWS_MEMORY_TRACKING)
-bool AddCrashHandlerAnnotations() {
+void AddCrashHandlerAnnotations() {
auto crash_handler_extension =
- SbSystemGetExtension(kCobaltExtensionCrashHandlerName);
+ static_cast<const CobaltExtensionCrashHandlerApi*>(
+ SbSystemGetExtension(kCobaltExtensionCrashHandlerName));
if (!crash_handler_extension) {
LOG(INFO) << "No crash handler extension, not sending annotations.";
- return false;
+ return;
}
auto platform_info = cobalt::browser::GetUserAgentPlatformInfoFromSystem();
@@ -541,23 +551,41 @@
product.push_back('\0');
version.push_back('\0');
- CrashpadAnnotations crashpad_annotations;
- memset(&crashpad_annotations, 0, sizeof(CrashpadAnnotations));
- strncpy(crashpad_annotations.user_agent_string, user_agent.c_str(),
- USER_AGENT_STRING_MAX_SIZE);
- strncpy(crashpad_annotations.product, product.c_str(),
- CRASHPAD_ANNOTATION_DEFAULT_LENGTH);
- strncpy(crashpad_annotations.version, version.c_str(),
- CRASHPAD_ANNOTATION_DEFAULT_LENGTH);
- bool result = static_cast<const CobaltExtensionCrashHandlerApi*>(
- crash_handler_extension)
- ->OverrideCrashpadAnnotations(&crashpad_annotations);
+ bool result = true;
+ if (crash_handler_extension->version == 1) {
+ CrashpadAnnotations crashpad_annotations;
+ memset(&crashpad_annotations, 0, sizeof(CrashpadAnnotations));
+ strncpy(crashpad_annotations.user_agent_string, user_agent.c_str(),
+ USER_AGENT_STRING_MAX_SIZE);
+ strncpy(crashpad_annotations.product, product.c_str(),
+ CRASHPAD_ANNOTATION_DEFAULT_LENGTH);
+ strncpy(crashpad_annotations.version, version.c_str(),
+ CRASHPAD_ANNOTATION_DEFAULT_LENGTH);
+ result = crash_handler_extension->OverrideCrashpadAnnotations(
+ &crashpad_annotations);
+ } else if (crash_handler_extension->version > 1) {
+ // These particular annotation key names (e.g., ver) are expected by
+ // Crashpad.
+ // TODO(b/201538792): figure out a clean way to define these constants once
+ // and use them everywhere.
+ if (!crash_handler_extension->SetString("user_agent_string",
+ user_agent.c_str())) {
+ result = false;
+ }
+ if (!crash_handler_extension->SetString("prod", product.c_str())) {
+ result = false;
+ }
+ if (!crash_handler_extension->SetString("ver", version.c_str())) {
+ result = false;
+ }
+ } else {
+ result = false;
+ } // Invalid extension version
if (result) {
LOG(INFO) << "Sent annotations to crash handler";
} else {
- LOG(ERROR) << "Could not send annotations to crash handler.";
+ LOG(ERROR) << "Could not send some annotation(s) to crash handler.";
}
- return result;
}
} // namespace
@@ -650,6 +678,12 @@
watchdog::Watchdog::CreateInstance(persistent_settings_.get());
DCHECK(watchdog);
+ // Registers Stats as a watchdog client.
+ if (watchdog)
+ watchdog->Register(kWatchdogName, kWatchdogName,
+ base::kApplicationStateStarted, kWatchdogTimeInterval,
+ kWatchdogTimeWait, watchdog::NONE);
+
cobalt::cache::Cache::GetInstance()->set_persistent_settings(
persistent_settings_.get());
@@ -660,11 +694,10 @@
unconsumed_deep_link_ = GetInitialDeepLink();
DLOG(INFO) << "Initial deep link: " << unconsumed_deep_link_;
- WebModule::Options web_options("MainWebModule");
storage::StorageManager::Options storage_manager_options;
network::NetworkModule::Options network_module_options;
// Create the main components of our browser.
- BrowserModule::Options options(web_options);
+ BrowserModule::Options options;
network_module_options.preferred_language = language;
network_module_options.persistent_settings = persistent_settings_.get();
options.persistent_settings = persistent_settings_.get();
@@ -749,7 +782,7 @@
// Set callback to be notified when a navigation occurs that destroys the
// underlying WebModule.
options.web_module_created_callback =
- base::Bind(&Application::WebModuleCreated, base::Unretained(this));
+ base::Bind(&Application::MainWebModuleCreated, base::Unretained(this));
// The main web module's stat tracker tracks event stats.
options.web_module_options.track_event_stats = true;
@@ -1370,8 +1403,9 @@
}
#endif
-void Application::WebModuleCreated(WebModule* web_module) {
- TRACE_EVENT0("cobalt::browser", "Application::WebModuleCreated()");
+void Application::MainWebModuleCreated(WebModule* web_module) {
+ TRACE_EVENT0("cobalt::browser", "Application::MainWebModuleCreated()");
+ // Note: This is a callback function that runs in the MainWebModule thread.
DCHECK(web_module);
if (preload_timestamp_.has_value()) {
web_module->SetApplicationStartOrPreloadTimestamp(
@@ -1431,6 +1465,16 @@
TRACE_EVENT0("cobalt::browser", "Application::UpdatePeriodicStats()");
c_val_stats_.app_lifetime = base::StartupTimer::TimeElapsed();
+ // Pings watchdog.
+ watchdog::Watchdog* watchdog = watchdog::Watchdog::GetInstance();
+ if (watchdog) {
+#if defined(_DEBUG)
+ // Injects delay for watchdog debugging.
+ watchdog->MaybeInjectDebugDelay(kWatchdogName);
+#endif // defined(_DEBUG)
+ watchdog->Ping(kWatchdogName);
+ }
+
int64_t used_cpu_memory = SbSystemGetUsedCPUMemory();
base::Optional<int64_t> used_gpu_memory;
if (SbSystemHasCapability(kSbSystemCapabilityCanQueryGPUMemoryStats)) {
@@ -1499,10 +1543,9 @@
// again after the next WebModule is created.
unconsumed_deep_link_ = link;
deep_link = unconsumed_deep_link_;
+ deep_link_timestamp_ = timestamp;
}
- deep_link_timestamp_ = timestamp;
-
LOG(INFO) << "Dispatching deep link: " << deep_link;
DispatchEventInternal(new base::DeepLinkEvent(
deep_link, base::Bind(&Application::OnDeepLinkConsumedCallback,
@@ -1516,11 +1559,17 @@
void Application::DispatchDeepLinkIfNotConsumed() {
std::string deep_link;
+#if SB_API_VERSION >= 13
+ SbTimeMonotonic timestamp;
+#endif // SB_API_VERSION >= 13
// This block exists to ensure that the lock is held while accessing
// unconsumed_deep_link_.
{
base::AutoLock auto_lock(unconsumed_deep_link_lock_);
deep_link = unconsumed_deep_link_;
+#if SB_API_VERSION >= 13
+ timestamp = deep_link_timestamp_;
+#endif // SB_API_VERSION >= 13
}
if (!deep_link.empty()) {
@@ -1531,7 +1580,7 @@
}
#if SB_API_VERSION >= 13
if (browser_module_) {
- browser_module_->SetDeepLinkTimestamp(deep_link_timestamp_);
+ browser_module_->SetDeepLinkTimestamp(timestamp);
}
#endif // SB_API_VERSION >= 13
}
diff --git a/cobalt/browser/application.h b/cobalt/browser/application.h
index d2ad7ca..96480b7 100644
--- a/cobalt/browser/application.h
+++ b/cobalt/browser/application.h
@@ -90,7 +90,7 @@
#endif
// Called when a navigation occurs in the BrowserModule.
- void WebModuleCreated(WebModule* web_module);
+ void MainWebModuleCreated(WebModule* web_module);
void CollectUnloadEventTimingInfo(base::TimeTicks start_time,
base::TimeTicks end_time);
diff --git a/cobalt/browser/browser_module.cc b/cobalt/browser/browser_module.cc
index b80da96..780f86d 100644
--- a/cobalt/browser/browser_module.cc
+++ b/cobalt/browser/browser_module.cc
@@ -341,11 +341,12 @@
// Setup our main web module to have the H5VCC API injected into it.
DCHECK(!ContainsKey(
+ options_.web_module_options.injected_global_object_attributes, "h5vcc"));
+ DCHECK(!ContainsKey(
options_.web_module_options.web_options.injected_global_object_attributes,
"h5vcc"));
- options_.web_module_options.web_options
- .injected_global_object_attributes["h5vcc"] =
- base::Bind(&BrowserModule::CreateH5vcc, base::Unretained(this));
+ options_.web_module_options.injected_global_object_attributes["h5vcc"] =
+ base::Bind(&BrowserModule::CreateH5vccCallback, base::Unretained(this));
if (command_line->HasSwitch(switches::kDisableTimerResolutionLimit)) {
options_.web_module_options.limit_performance_timer_resolution = false;
@@ -515,7 +516,7 @@
if (web_module_) {
lifecycle_observers_.RemoveObserver(web_module_.get());
}
- web_module_.reset(NULL);
+ web_module_.reset();
// Increment the navigation generation so that we can attach it to event
// callbacks as a way of identifying the new web module from the old ones.
@@ -608,7 +609,8 @@
options.web_options.service_worker_jobs =
service_worker_registry_.service_worker_jobs();
options.web_options.platform_info = platform_info_.get();
- web_module_.reset(new WebModule(
+ web_module_.reset(new WebModule("MainWebModule"));
+ web_module_->Run(
url, application_state_,
base::Bind(&BrowserModule::QueueOnRenderTreeProduced,
base::Unretained(this), main_web_module_generation_),
@@ -616,7 +618,7 @@
base::Bind(&BrowserModule::OnWindowClose, base::Unretained(this)),
base::Bind(&BrowserModule::OnWindowMinimize, base::Unretained(this)),
can_play_type_handler_.get(), media_module_.get(), viewport_size,
- GetResourceProvider(), kLayoutMaxRefreshFrequencyInHz, options));
+ GetResourceProvider(), kLayoutMaxRefreshFrequencyInHz, options);
lifecycle_observers_.AddObserver(web_module_.get());
if (system_window_) {
@@ -686,6 +688,7 @@
const base::Optional<math::Rect>& clip_rect,
const base::Closure& done_callback) {
TRACE_EVENT0("cobalt::browser", "BrowserModule::RequestScreenshotToFile()");
+ DCHECK_EQ(base::MessageLoop::current(), self_message_loop_);
DCHECK(screen_shot_writer_);
scoped_refptr<render_tree::Node> render_tree;
@@ -704,6 +707,7 @@
const base::Optional<math::Rect>& clip_rect,
const ScreenShotWriter::ImageEncodeCompleteCallback& screenshot_ready) {
TRACE_EVENT0("cobalt::browser", "BrowserModule::RequestScreenshotToMemory()");
+ DCHECK_EQ(base::MessageLoop::current(), self_message_loop_);
DCHECK(screen_shot_writer_);
scoped_refptr<render_tree::Node> render_tree;
@@ -898,6 +902,7 @@
}
void BrowserModule::OnWindowSizeChanged(const ViewportSize& viewport_size) {
+ DCHECK_EQ(base::MessageLoop::current(), self_message_loop_);
if (web_module_) {
web_module_->SetSize(viewport_size);
}
@@ -964,6 +969,7 @@
void BrowserModule::OnCaptionSettingsChanged(
const base::AccessibilityCaptionSettingsChangedEvent* event) {
+ DCHECK_EQ(base::MessageLoop::current(), self_message_loop_);
if (web_module_) {
web_module_->InjectCaptionSettingsChangedEvent();
}
@@ -972,6 +978,7 @@
#if SB_API_VERSION >= 13
void BrowserModule::OnDateTimeConfigurationChanged(
const base::DateTimeConfigurationChangedEvent* event) {
+ DCHECK_EQ(base::MessageLoop::current(), self_message_loop_);
icu::TimeZone::adoptDefault(icu::TimeZone::detectHostTimeZone());
if (web_module_) {
web_module_->UpdateDateTimeConfiguration();
@@ -1122,12 +1129,14 @@
}
void BrowserModule::OnWindowOnOnlineEvent(const base::Event* event) {
+ DCHECK_EQ(base::MessageLoop::current(), self_message_loop_);
if (web_module_) {
web_module_->InjectWindowOnOnlineEvent(event);
}
}
void BrowserModule::OnWindowOnOfflineEvent(const base::Event* event) {
+ DCHECK_EQ(base::MessageLoop::current(), self_message_loop_);
if (web_module_) {
web_module_->InjectWindowOnOfflineEvent(event);
}
@@ -2021,13 +2030,15 @@
}
}
-scoped_refptr<script::Wrappable> BrowserModule::CreateH5vcc(
- script::EnvironmentSettings* settings) {
- DCHECK(web_module_);
+scoped_refptr<script::Wrappable> BrowserModule::CreateH5vccCallback(
+ WebModule* web_module, web::EnvironmentSettings* settings) {
+ DCHECK_NE(base::MessageLoop::current(), self_message_loop_);
+ // Note: This is a callback function that runs in the MainWebModule thread.
+ // The web_module_ member can not be safely used in this function.
h5vcc::H5vcc::Settings h5vcc_settings;
h5vcc_settings.set_media_source_setting_func = base::Bind(
- &WebModule::SetMediaSourceSetting, base::Unretained(web_module_.get()));
+ &WebModule::SetMediaSourceSetting, base::Unretained(web_module));
h5vcc_settings.network_module = network_module_;
#if SB_IS(EVERGREEN)
h5vcc_settings.updater_module = updater_module_;
@@ -2035,22 +2046,27 @@
h5vcc_settings.account_manager = account_manager_;
h5vcc_settings.event_dispatcher = event_dispatcher_;
- auto* dom_settings = base::polymorphic_downcast<dom::DOMSettings*>(settings);
-
- h5vcc_settings.user_agent_data =
- dom_settings->window()->navigator()->user_agent_data();
- h5vcc_settings.global_environment =
- dom_settings->context()->global_environment();
+ h5vcc_settings.user_agent_data = settings->context()
+ ->GetWindowOrWorkerGlobalScope()
+ ->navigator_base()
+ ->user_agent_data();
+ h5vcc_settings.global_environment = settings->context()->global_environment();
h5vcc_settings.persistent_settings = options_.persistent_settings;
auto* h5vcc_object = new h5vcc::H5vcc(h5vcc_settings);
if (!web_module_created_callback_.is_null()) {
- web_module_created_callback_.Run(web_module_.get());
+ web_module_created_callback_.Run(web_module);
}
return scoped_refptr<script::Wrappable>(h5vcc_object);
}
void BrowserModule::SetDeepLinkTimestamp(SbTimeMonotonic timestamp) {
+ if (base::MessageLoop::current() != self_message_loop_) {
+ self_message_loop_->task_runner()->PostTask(
+ FROM_HERE, base::Bind(&BrowserModule::SetDeepLinkTimestamp,
+ base::Unretained(this), timestamp));
+ return;
+ }
DCHECK(web_module_);
web_module_->SetDeepLinkTimestamp(timestamp);
}
diff --git a/cobalt/browser/browser_module.h b/cobalt/browser/browser_module.h
index 6730fa2..646b750 100644
--- a/cobalt/browser/browser_module.h
+++ b/cobalt/browser/browser_module.h
@@ -99,9 +99,8 @@
// All browser subcomponent options should have default constructors that
// setup reasonable default options.
struct Options {
- explicit Options(const WebModule::Options& web_options)
- : web_module_options(web_options),
- command_line_auto_mem_settings(
+ Options()
+ : command_line_auto_mem_settings(
memory_settings::AutoMemSettings::kTypeCommandLine),
build_auto_mem_settings(memory_settings::AutoMemSettings::kTypeBuild),
enable_splash_screen_on_reloads(true) {}
@@ -465,9 +464,10 @@
// Returns the topic used, or an empty Optional if a topic isn't found.
base::Optional<std::string> SetSplashScreenTopicFallback(const GURL& url);
- // Function that creates the H5vcc object that will be injected into WebModule
- scoped_refptr<script::Wrappable> CreateH5vcc(
- script::EnvironmentSettings* settings);
+ // Callback function that creates the H5vcc object that will be injected into
+ // the MainWebModule.
+ scoped_refptr<script::Wrappable> CreateH5vccCallback(
+ WebModule* web_module, web::EnvironmentSettings* settings);
// Validates the PersistentSettings for cache backend, if in use.
void ValidateCacheBackendSettings();
diff --git a/cobalt/browser/debug_console.cc b/cobalt/browser/debug_console.cc
index 72069e3..1f0bba5 100644
--- a/cobalt/browser/debug_console.cc
+++ b/cobalt/browser/debug_console.cc
@@ -97,7 +97,7 @@
scoped_refptr<script::Wrappable> CreateDebugHub(
const debug::console::DebugHub::GetHudModeCallback& get_hud_mode_function,
const debug::CreateDebugClientCallback& create_debug_client_callback,
- script::EnvironmentSettings* settings) {
+ web::EnvironmentSettings* settings) {
return new debug::console::DebugHub(get_hud_mode_function,
create_debug_client_callback);
}
@@ -116,7 +116,7 @@
const base::Closure& maybe_freeze_callback) {
mode_ = GetInitialMode();
- WebModule::Options web_module_options("DebugConsoleWebModule");
+ WebModule::Options web_module_options;
// The debug console does not load any image assets.
web_module_options.image_cache_capacity = 0;
// Disable CSP for the Debugger's WebModule. This will also allow eval() in
@@ -143,15 +143,15 @@
web_module_options.web_options.network_module = network_module;
web_module_options.web_options.platform_info = platform_info;
- web_module_.reset(
- new WebModule(GURL(kInitialDebugConsoleUrl), initial_application_state,
- render_tree_produced_callback,
- base::Bind(&DebugConsole::OnError, base::Unretained(this)),
- WebModule::CloseCallback(), /* window_close_callback */
- base::Closure(), /* window_minimize_callback */
- NULL /* can_play_type_handler */, NULL /* media_module */,
- window_dimensions, resource_provider, layout_refresh_rate,
- web_module_options));
+ web_module_.reset(new WebModule("DebugConsoleWebModule"));
+ web_module_->Run(GURL(kInitialDebugConsoleUrl), initial_application_state,
+ render_tree_produced_callback,
+ base::Bind(&DebugConsole::OnError, base::Unretained(this)),
+ WebModule::CloseCallback(), /* window_close_callback */
+ base::Closure(), /* window_minimize_callback */
+ NULL /* can_play_type_handler */, NULL /* media_module */,
+ window_dimensions, resource_provider, layout_refresh_rate,
+ web_module_options);
}
DebugConsole::~DebugConsole() {}
diff --git a/cobalt/browser/on_screen_keyboard_starboard_bridge.cc b/cobalt/browser/on_screen_keyboard_starboard_bridge.cc
index 969f822..ccd818e 100644
--- a/cobalt/browser/on_screen_keyboard_starboard_bridge.cc
+++ b/cobalt/browser/on_screen_keyboard_starboard_bridge.cc
@@ -97,8 +97,8 @@
keep_focus);
}
-void OnScreenKeyboardStarboardBridge::SetBackgroundColor(
- const char* background_color) {
+void OnScreenKeyboardStarboardBridge::SetBackgroundColor(uint8 r, uint8 g,
+ uint8 b) {
const CobaltExtensionOnScreenKeyboardApi* on_screen_keyboard_extension =
static_cast<const CobaltExtensionOnScreenKeyboardApi*>(
SbSystemGetExtension(kCobaltExtensionOnScreenKeyboardName));
@@ -108,11 +108,11 @@
kCobaltExtensionOnScreenKeyboardName) == 0 &&
on_screen_keyboard_extension->version >= 1) {
on_screen_keyboard_extension->SetBackgroundColor(sb_window_provider_.Run(),
- background_color);
+ r, g, b);
}
}
-void OnScreenKeyboardStarboardBridge::SetDarkTheme(bool dark_theme) {
+void OnScreenKeyboardStarboardBridge::SetLightTheme(bool light_theme) {
const CobaltExtensionOnScreenKeyboardApi* on_screen_keyboard_extension =
static_cast<const CobaltExtensionOnScreenKeyboardApi*>(
SbSystemGetExtension(kCobaltExtensionOnScreenKeyboardName));
@@ -121,8 +121,8 @@
strcmp(on_screen_keyboard_extension->name,
kCobaltExtensionOnScreenKeyboardName) == 0 &&
on_screen_keyboard_extension->version >= 1) {
- on_screen_keyboard_extension->SetDarkTheme(sb_window_provider_.Run(),
- dark_theme);
+ on_screen_keyboard_extension->SetLightTheme(sb_window_provider_.Run(),
+ light_theme);
}
}
} // namespace browser
diff --git a/cobalt/browser/on_screen_keyboard_starboard_bridge.h b/cobalt/browser/on_screen_keyboard_starboard_bridge.h
index 6ee9a70..682f2f4 100644
--- a/cobalt/browser/on_screen_keyboard_starboard_bridge.h
+++ b/cobalt/browser/on_screen_keyboard_starboard_bridge.h
@@ -59,9 +59,9 @@
void SetKeepFocus(bool keep_focus) override;
- void SetBackgroundColor(const char* background_color) override;
+ void SetBackgroundColor(uint8 r, uint8 g, uint8 b) override;
- void SetDarkTheme(bool dark_theme) override;
+ void SetLightTheme(bool light_theme) override;
private:
base::Callback<SbWindow()> sb_window_provider_;
diff --git a/cobalt/browser/splash_screen.cc b/cobalt/browser/splash_screen.cc
index 2739ec0..952f790 100644
--- a/cobalt/browser/splash_screen.cc
+++ b/cobalt/browser/splash_screen.cc
@@ -67,7 +67,7 @@
self_message_loop_(base::MessageLoop::current()),
on_splash_screen_shutdown_complete_(on_splash_screen_shutdown_complete),
shutdown_signaled_(false) {
- WebModule::Options web_module_options("SplashScreenWebModule");
+ WebModule::Options web_module_options;
// We want the splash screen to load and appear as quickly as possible, so
// we set it and its image decoding thread to be high priority.
@@ -106,13 +106,14 @@
web_module_options.web_options.platform_info = platform_info;
DCHECK(url_to_pass);
- web_module_.reset(new WebModule(
- *url_to_pass, initial_application_state, render_tree_produced_callback_,
- base::Bind(&OnError), on_window_close,
- base::Closure(), // window_minimize_callback
- NULL /* can_play_type_handler */, NULL /* media_module */,
- window_dimensions, resource_provider, layout_refresh_rate,
- web_module_options));
+ web_module_.reset(new WebModule("SplashScreenWebModule"));
+ web_module_->Run(*url_to_pass, initial_application_state,
+ render_tree_produced_callback_, base::Bind(&OnError),
+ on_window_close,
+ base::Closure(), // window_minimize_callback
+ NULL /* can_play_type_handler */, NULL /* media_module */,
+ window_dimensions, resource_provider, layout_refresh_rate,
+ web_module_options);
}
SplashScreen::~SplashScreen() {
diff --git a/cobalt/browser/web_module.cc b/cobalt/browser/web_module.cc
index ecc0f56..a7cfd00 100644
--- a/cobalt/browser/web_module.cc
+++ b/cobalt/browser/web_module.cc
@@ -1320,15 +1320,32 @@
} while (event && !layout_manager_->IsRenderTreePending());
}
-WebModule::Options::Options(const std::string& name)
- : web_options(name),
- layout_trigger(layout::LayoutManager::kOnDocumentMutation),
+WebModule::Options::Options()
+ : layout_trigger(layout::LayoutManager::kOnDocumentMutation),
mesh_cache_capacity(configuration::Configuration::GetInstance()
->CobaltMeshCacheSizeInBytes()) {
web_options.stack_size = cobalt::browser::kWebModuleStackSize;
}
-WebModule::WebModule(
+WebModule::WebModule(const std::string& name)
+ : ui_nav_root_(new ui_navigation::NavItem(
+ ui_navigation::kNativeItemTypeContainer,
+ // Currently, events do not need to be processed for the root item.
+ base::Closure(), base::Closure(), base::Closure())) {
+ web_agent_.reset(new web::Agent(name));
+}
+
+WebModule::~WebModule() {
+ DCHECK(message_loop());
+ DCHECK(web_agent_);
+ // This will cancel the timers for tasks, which help the thread exit
+ ClearAllIntervalsAndTimeouts();
+ web_agent_->WaitUntilDone();
+ web_agent_->Stop();
+ web_agent_.reset();
+}
+
+void WebModule::Run(
const GURL& initial_url, base::ApplicationState initial_application_state,
const OnRenderTreeProducedCallback& render_tree_produced_callback,
OnErrorCallback error_callback, const CloseCallback& window_close_callback,
@@ -1336,11 +1353,7 @@
media::CanPlayTypeHandler* can_play_type_handler,
media::MediaModule* media_module, const ViewportSize& window_dimensions,
render_tree::ResourceProvider* resource_provider, float layout_refresh_rate,
- const Options& options)
- : ui_nav_root_(new ui_navigation::NavItem(
- ui_navigation::kNativeItemTypeContainer,
- // Currently, events do not need to be processed for the root item.
- base::Closure(), base::Closure(), base::Closure())) {
+ const Options& options) {
ConstructionData construction_data(
initial_url, initial_application_state, render_tree_produced_callback,
error_callback, window_close_callback, window_minimize_callback,
@@ -1351,24 +1364,27 @@
#endif // defined(ENABLE_DEBUGGER)
&synchronous_loader_interrupt_, options);
- web_agent_.reset(
- new web::Agent(options.web_options,
- base::Bind(&WebModule::Initialize, base::Unretained(this),
- construction_data),
- this));
+ web::Agent::Options web_options(options.web_options);
+ if (!options.injected_global_object_attributes.empty()) {
+ for (Options::InjectedGlobalObjectAttributes::const_iterator iter =
+ options.injected_global_object_attributes.begin();
+ iter != options.injected_global_object_attributes.end(); ++iter) {
+ DCHECK(!ContainsKey(web_options.injected_global_object_attributes,
+ iter->first));
+ // Trampoline to the given callback, adding a pointer to this WebModule.
+ web_options.injected_global_object_attributes[iter->first] =
+ base::Bind(iter->second, base::Unretained(this));
+ }
+ }
+
+ web_agent_->Run(web_options,
+ base::Bind(&WebModule::InitializeTaskInThread,
+ base::Unretained(this), construction_data),
+ this);
}
-WebModule::~WebModule() {
- DCHECK(message_loop());
- DCHECK(web_agent_);
- // This will cancel the timers for tasks, which help the thread exit
- ClearAllIntervalsAndTimeouts();
- web_agent_->WaitUntilDone();
- web_agent_.reset();
-}
-
-void WebModule::Initialize(const ConstructionData& data,
- web::Context* context) {
+void WebModule::InitializeTaskInThread(const ConstructionData& data,
+ web::Context* context) {
DCHECK_EQ(base::MessageLoop::current(), message_loop());
impl_.reset(new Impl(context, data));
}
diff --git a/cobalt/browser/web_module.h b/cobalt/browser/web_module.h
index 3e442c8..a29c1bd 100644
--- a/cobalt/browser/web_module.h
+++ b/cobalt/browser/web_module.h
@@ -55,6 +55,7 @@
#include "cobalt/web/blob.h"
#include "cobalt/web/context.h"
#include "cobalt/web/csp_delegate.h"
+#include "cobalt/web/environment_settings.h"
#include "cobalt/web/user_agent_platform_info.h"
#include "cobalt/webdriver/session_driver.h"
#include "starboard/atomic.h"
@@ -90,9 +91,15 @@
public LifecycleObserver {
public:
struct Options {
+ typedef base::Callback<scoped_refptr<script::Wrappable>(
+ WebModule*, web::EnvironmentSettings*)>
+ CreateObjectFunction;
+ typedef base::hash_map<std::string, CreateObjectFunction>
+ InjectedGlobalObjectAttributes;
+
// All optional parameters defined in this structure should have their
// values initialized in the default constructor to useful defaults.
- explicit Options(const std::string& name);
+ Options();
web::Agent::Options web_options;
@@ -240,6 +247,11 @@
// time.
base::Callback<void(base::TimeTicks, base::TimeTicks)>
collect_unload_event_time_callback;
+
+ // injected_global_attributes contains a map of attributes to be injected
+ // into the Web Agent's window object upon construction. This provides
+ // a mechanism to inject custom APIs into the Web Agent object.
+ InjectedGlobalObjectAttributes injected_global_object_attributes;
};
typedef layout::LayoutManager::LayoutResults LayoutResults;
@@ -248,18 +260,19 @@
typedef base::Callback<void(const GURL&, const std::string&)> OnErrorCallback;
typedef dom::Window::CloseCallback CloseCallback;
- WebModule(const GURL& initial_url,
- base::ApplicationState initial_application_state,
- const OnRenderTreeProducedCallback& render_tree_produced_callback,
- OnErrorCallback error_callback,
- const CloseCallback& window_close_callback,
- const base::Closure& window_minimize_callback,
- media::CanPlayTypeHandler* can_play_type_handler,
- media::MediaModule* media_module,
- const cssom::ViewportSize& window_dimensions,
- render_tree::ResourceProvider* resource_provider,
- float layout_refresh_rate, const Options& options);
+ explicit WebModule(const std::string& name);
~WebModule();
+ void Run(const GURL& initial_url,
+ base::ApplicationState initial_application_state,
+ const OnRenderTreeProducedCallback& render_tree_produced_callback,
+ OnErrorCallback error_callback,
+ const CloseCallback& window_close_callback,
+ const base::Closure& window_minimize_callback,
+ media::CanPlayTypeHandler* can_play_type_handler,
+ media::MediaModule* media_module,
+ const cssom::ViewportSize& window_dimensions,
+ render_tree::ResourceProvider* resource_provider,
+ float layout_refresh_rate, const Options& options);
// Injects an on screen keyboard input event into the web module. The value
// for type represents beforeinput or input.
@@ -391,7 +404,7 @@
private:
// Data required to construct a WebModule, initialized in the constructor and
- // passed to |Initialize|.
+ // passed to |InitializeTaskInThread|.
struct ConstructionData {
ConstructionData(const GURL& initial_url,
base::ApplicationState initial_application_state,
@@ -453,9 +466,10 @@
// Forward declaration of the private implementation class.
class Impl;
- // Called by the constructor to create the private implementation object and
+ // Called by |Run| to create the private implementation object and
// perform any other initialization required on the dedicated thread.
- void Initialize(const ConstructionData& data, web::Context* context);
+ void InitializeTaskInThread(const ConstructionData& data,
+ web::Context* context);
void ClearAllIntervalsAndTimeouts();
@@ -467,7 +481,7 @@
// The message loop this object is running on.
base::MessageLoop* message_loop() const {
DCHECK(web_agent_);
- return web_agent_->message_loop();
+ return web_agent_ ? web_agent_->message_loop() : nullptr;
}
// Private implementation object.
diff --git a/cobalt/demos/content/watchdog-demo/index.html b/cobalt/demos/content/watchdog-demo/index.html
index c5f17f8..d23e7d4 100644
--- a/cobalt/demos/content/watchdog-demo/index.html
+++ b/cobalt/demos/content/watchdog-demo/index.html
@@ -63,7 +63,7 @@
} else if (watchdogFunction == 'unregister') {
ret = h5vcc.crashLog.unregister('test-name');
} else if (watchdogFunction == 'ping') {
- ret = h5vcc.crashLog.ping('test-name', `test-ping`);
+ ret = h5vcc.crashLog.ping('test-name', 'test-ping');
} else if (watchdogFunction == 'getWatchdogViolations') {
ret = h5vcc.crashLog.getWatchdogViolations();
} else if (watchdogFunction == 'getPersistentSettingWatchdogEnable') {
diff --git a/cobalt/dom/event_queue.cc b/cobalt/dom/event_queue.cc
index ca851e8..1bd5282 100644
--- a/cobalt/dom/event_queue.cc
+++ b/cobalt/dom/event_queue.cc
@@ -44,23 +44,6 @@
events_.push_back(event);
}
-void EventQueue::EnqueueAndMaybeDispatchImmediately(
- const scoped_refptr<web::Event>& event) {
- DCHECK(message_loop_->BelongsToCurrentThread());
-
- bool was_empty = events_.empty();
-
- Enqueue(event);
-
- if (was_empty) {
- // We can only dispatch the event immediately if there aren't any existing
- // events in the queue, because dom activities (including events) have to
- // happen in order, and any existing events in the queue may mean that these
- // events have to be dispatched after other activities not tracked here.
- DispatchEvents();
- }
-}
-
void EventQueue::CancelAllEvents() {
DCHECK(message_loop_->BelongsToCurrentThread());
diff --git a/cobalt/dom/event_queue.h b/cobalt/dom/event_queue.h
index 6aad863..a81e482 100644
--- a/cobalt/dom/event_queue.h
+++ b/cobalt/dom/event_queue.h
@@ -44,11 +44,6 @@
explicit EventQueue(web::EventTarget* event_target);
void Enqueue(const scoped_refptr<web::Event>& event);
- // Try to dispatch the event immediately if there are no existing events in
- // the queue, otherwise it has the same behavior as Enqueue(), which enqueues
- // the event and the event will be dispatched after the existing events.
- void EnqueueAndMaybeDispatchImmediately(
- const scoped_refptr<web::Event>& event);
void CancelAllEvents();
void TraceMembers(script::Tracer* tracer) override;
diff --git a/cobalt/dom/event_queue_test.cc b/cobalt/dom/event_queue_test.cc
index be4a970..e8fc35f 100644
--- a/cobalt/dom/event_queue_test.cc
+++ b/cobalt/dom/event_queue_test.cc
@@ -90,42 +90,6 @@
base::RunLoop().RunUntilIdle();
}
-TEST_F(EventQueueTest, EnqueueAndMaybeDispatchImmediatelyTest) {
- scoped_refptr<web::EventTarget> event_target =
- new web::EventTarget(&environment_settings_);
- scoped_refptr<web::Event> event = new web::Event(base::Token("event"));
- std::unique_ptr<MockEventListener> event_listener =
- MockEventListener::Create();
- EventQueue event_queue(event_target.get());
-
- event->set_target(event_target);
- event_target->AddEventListener(
- "event", FakeScriptValue<web::EventListener>(event_listener.get()),
- false);
-
- {
- ::testing::InSequence s;
- ExpectHandleEventCallWithEventAndTarget(event_listener.get(), event,
- event_target);
- // The event should be dispatched immediately as the queue is empty, so the
- // expectation should be set before being enqueued.
- event_queue.EnqueueAndMaybeDispatchImmediately(event);
- }
-
- {
- ::testing::InSequence s;
- event_queue.Enqueue(event);
- // The event won't be dispatched immediately as the queue isn't empty, so
- // the expectations can be set after being enqueued.
- event_queue.EnqueueAndMaybeDispatchImmediately(event);
- ExpectHandleEventCallWithEventAndTarget(event_listener.get(), event,
- event_target);
- ExpectHandleEventCallWithEventAndTarget(event_listener.get(), event,
- event_target);
- base::RunLoop().RunUntilIdle();
- }
-}
-
TEST_F(EventQueueTest, CancelAllEventsTest) {
scoped_refptr<web::EventTarget> event_target =
new web::EventTarget(&environment_settings_);
diff --git a/cobalt/dom/html_script_element.cc b/cobalt/dom/html_script_element.cc
index 42f7997..236cd3e 100644
--- a/cobalt/dom/html_script_element.cc
+++ b/cobalt/dom/html_script_element.cc
@@ -351,6 +351,7 @@
base::Bind(&loader::TextDecoder::Create,
base::Bind(&HTMLScriptElement::OnSyncContentProduced,
base::Unretained(this)),
+ loader::TextDecoder::ResponseStartedCallback(),
loader::Decoder::OnCompleteFunction()),
base::Bind(&HTMLScriptElement::OnSyncLoadingComplete,
base::Unretained(this)));
diff --git a/cobalt/dom/media_source.cc b/cobalt/dom/media_source.cc
index 1dcc7d3..22f6bc5 100644
--- a/cobalt/dom/media_source.cc
+++ b/cobalt/dom/media_source.cc
@@ -243,9 +243,8 @@
ChunkDemuxer::Status status = chunk_demuxer_->AddId(guid, type);
switch (status) {
case ChunkDemuxer::kOk:
- source_buffer = new SourceBuffer(settings, guid, this,
- asynchronous_reduction_enabled_,
- chunk_demuxer_, &event_queue_);
+ source_buffer =
+ new SourceBuffer(settings, guid, this, chunk_demuxer_, &event_queue_);
break;
case ChunkDemuxer::kNotSupported:
web::DOMException::Raise(web::DOMException::kNotSupportedErr,
diff --git a/cobalt/dom/media_source_settings.cc b/cobalt/dom/media_source_settings.cc
index a330f83..84ac0f9 100644
--- a/cobalt/dom/media_source_settings.cc
+++ b/cobalt/dom/media_source_settings.cc
@@ -52,6 +52,12 @@
LOG(INFO) << name << ": set to " << value;
return true;
}
+ } else if (name == "MediaSource.MaxSourceBufferAppendSizeInBytes") {
+ if (value > 0) {
+ max_source_buffer_append_size_in_bytes_ = value;
+ LOG(INFO) << name << ": set to " << value;
+ return true;
+ }
} else {
LOG(WARNING) << "Ignore unknown setting with name \"" << name << "\"";
return false;
diff --git a/cobalt/dom/media_source_settings.h b/cobalt/dom/media_source_settings.h
index 8d1b0be..61641b1 100644
--- a/cobalt/dom/media_source_settings.h
+++ b/cobalt/dom/media_source_settings.h
@@ -36,6 +36,7 @@
const = 0;
virtual base::Optional<bool> IsAsynchronousReductionEnabled() const = 0;
virtual base::Optional<int> GetMinSizeForImmediateJob() const = 0;
+ virtual base::Optional<int> GetMaxSourceBufferAppendSizeInBytes() const = 0;
protected:
MediaSourceSettings() = default;
@@ -67,6 +68,10 @@
base::AutoLock auto_lock(lock_);
return min_size_for_immediate_job_;
}
+ base::Optional<int> GetMaxSourceBufferAppendSizeInBytes() const override {
+ base::AutoLock auto_lock(lock_);
+ return max_source_buffer_append_size_in_bytes_;
+ }
// Returns true when the setting associated with `name` is set to `value`.
// Returns false when `name` is not associated with any settings, or if
@@ -79,6 +84,7 @@
base::Optional<int> minimum_processor_count_to_offload_algorithm_;
base::Optional<bool> is_asynchronous_reduction_enabled_;
base::Optional<int> min_size_for_immediate_job_;
+ base::Optional<int> max_source_buffer_append_size_in_bytes_;
};
} // namespace dom
diff --git a/cobalt/dom/media_source_settings_test.cc b/cobalt/dom/media_source_settings_test.cc
index 27d9e9e..25d7878 100644
--- a/cobalt/dom/media_source_settings_test.cc
+++ b/cobalt/dom/media_source_settings_test.cc
@@ -27,6 +27,7 @@
EXPECT_FALSE(impl.GetMinimumProcessorCountToOffloadAlgorithm());
EXPECT_FALSE(impl.IsAsynchronousReductionEnabled());
EXPECT_FALSE(impl.GetMinSizeForImmediateJob());
+ EXPECT_FALSE(impl.GetMaxSourceBufferAppendSizeInBytes());
}
TEST(MediaSourceSettingsImplTest, SunnyDay) {
@@ -37,11 +38,13 @@
impl.Set("MediaSource.MinimumProcessorCountToOffloadAlgorithm", 101));
ASSERT_TRUE(impl.Set("MediaSource.EnableAsynchronousReduction", 1));
ASSERT_TRUE(impl.Set("MediaSource.MinSizeForImmediateJob", 103));
+ ASSERT_TRUE(impl.Set("MediaSource.MaxSourceBufferAppendSizeInBytes", 100000));
EXPECT_EQ(impl.GetSourceBufferEvictExtraInBytes().value(), 100);
EXPECT_EQ(impl.GetMinimumProcessorCountToOffloadAlgorithm().value(), 101);
EXPECT_TRUE(impl.IsAsynchronousReductionEnabled().value());
EXPECT_EQ(impl.GetMinSizeForImmediateJob().value(), 103);
+ EXPECT_EQ(impl.GetMaxSourceBufferAppendSizeInBytes().value(), 100000);
}
TEST(MediaSourceSettingsImplTest, RainyDay) {
@@ -52,11 +55,13 @@
impl.Set("MediaSource.MinimumProcessorCountToOffloadAlgorithm", -101));
ASSERT_FALSE(impl.Set("MediaSource.EnableAsynchronousReduction", 2));
ASSERT_FALSE(impl.Set("MediaSource.MinSizeForImmediateJob", -103));
+ ASSERT_FALSE(impl.Set("MediaSource.MaxSourceBufferAppendSizeInBytes", 0));
EXPECT_FALSE(impl.GetSourceBufferEvictExtraInBytes());
EXPECT_FALSE(impl.GetMinimumProcessorCountToOffloadAlgorithm());
EXPECT_FALSE(impl.IsAsynchronousReductionEnabled());
EXPECT_FALSE(impl.GetMinSizeForImmediateJob());
+ EXPECT_FALSE(impl.GetMaxSourceBufferAppendSizeInBytes());
}
TEST(MediaSourceSettingsImplTest, ZeroValuesWork) {
@@ -67,6 +72,7 @@
impl.Set("MediaSource.MinimumProcessorCountToOffloadAlgorithm", 0));
ASSERT_TRUE(impl.Set("MediaSource.EnableAsynchronousReduction", 0));
ASSERT_TRUE(impl.Set("MediaSource.MinSizeForImmediateJob", 0));
+ // O is an invalid value for "MediaSource.MaxSourceBufferAppendSizeInBytes".
EXPECT_EQ(impl.GetSourceBufferEvictExtraInBytes().value(), 0);
EXPECT_EQ(impl.GetMinimumProcessorCountToOffloadAlgorithm().value(), 0);
@@ -82,17 +88,20 @@
impl.Set("MediaSource.MinimumProcessorCountToOffloadAlgorithm", 0));
ASSERT_TRUE(impl.Set("MediaSource.EnableAsynchronousReduction", 0));
ASSERT_TRUE(impl.Set("MediaSource.MinSizeForImmediateJob", 0));
+ ASSERT_TRUE(impl.Set("MediaSource.MaxSourceBufferAppendSizeInBytes", 1));
ASSERT_TRUE(impl.Set("MediaSource.SourceBufferEvictExtraInBytes", 1));
ASSERT_TRUE(
impl.Set("MediaSource.MinimumProcessorCountToOffloadAlgorithm", 1));
ASSERT_TRUE(impl.Set("MediaSource.EnableAsynchronousReduction", 1));
ASSERT_TRUE(impl.Set("MediaSource.MinSizeForImmediateJob", 1));
+ ASSERT_TRUE(impl.Set("MediaSource.MaxSourceBufferAppendSizeInBytes", 2));
EXPECT_EQ(impl.GetSourceBufferEvictExtraInBytes().value(), 1);
EXPECT_EQ(impl.GetMinimumProcessorCountToOffloadAlgorithm().value(), 1);
EXPECT_TRUE(impl.IsAsynchronousReductionEnabled().value());
EXPECT_EQ(impl.GetMinSizeForImmediateJob().value(), 1);
+ EXPECT_EQ(impl.GetMaxSourceBufferAppendSizeInBytes().value(), 2);
}
TEST(MediaSourceSettingsImplTest, InvalidSettingNames) {
diff --git a/cobalt/dom/on_screen_keyboard.cc b/cobalt/dom/on_screen_keyboard.cc
index 188aa1e..6f8da1b 100644
--- a/cobalt/dom/on_screen_keyboard.cc
+++ b/cobalt/dom/on_screen_keyboard.cc
@@ -23,6 +23,63 @@
namespace cobalt {
namespace dom {
+namespace {
+bool IsValidRGB(int r, int g, int b) {
+ if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
+ return false;
+ } else {
+ return true;
+ }
+}
+
+bool ParseColor(const char* color_str, int& r, int& g, int& b) {
+ size_t len = strlen(color_str);
+ if (len == 0) {
+ return false;
+ }
+
+ // Handle hexadecimal color notation #RRGGBB
+ int r_tmp, g_tmp, b_tmp;
+ bool is_hex =
+ SbStringScanF(color_str, "#%02x%02x%02x", &r_tmp, &g_tmp, &b_tmp) == 3;
+ if (is_hex && IsValidRGB(r_tmp, g_tmp, b_tmp)) {
+ r = r_tmp;
+ g = g_tmp;
+ b = b_tmp;
+ return true;
+ }
+
+ // Handle rgb color notation rgb(R, G, B)
+ if (!is_hex && len >= 10 &&
+ SbStringCompareNoCaseN("rgb(", color_str, 4) == 0) {
+ int rgb_tmp[3] = {-1, -1, -1};
+ const char* ptr = color_str + 4;
+ int i = 0;
+ while (*ptr) {
+ if (isdigit(*ptr)) {
+ char* end;
+ rgb_tmp[i++] = static_cast<int>(strtol(ptr, &end, 10));
+ if (i == 3) {
+ break;
+ }
+ ptr = (const char*)end;
+ } else if (isspace(*ptr) || *ptr == ',') {
+ ptr++;
+ } else {
+ return false;
+ }
+ }
+
+ if (IsValidRGB(rgb_tmp[0], rgb_tmp[1], rgb_tmp[2])) {
+ r = rgb_tmp[0];
+ g = rgb_tmp[1];
+ b = rgb_tmp[2];
+ return true;
+ }
+ }
+ return false;
+}
+} // namespace
OnScreenKeyboard::OnScreenKeyboard(
script::EnvironmentSettings* settings, OnScreenKeyboardBridge* bridge,
@@ -48,10 +105,17 @@
bridge_->Show(data_.c_str(), ticket);
if (background_color_.has_value()) {
- bridge_->SetBackgroundColor(background_color_.value().c_str());
+ int r, g, b;
+ if (ParseColor(background_color_.value().c_str(), r, g, b)) {
+ bridge_->SetBackgroundColor(static_cast<uint8>(r), static_cast<uint8>(g),
+ static_cast<uint8>(b));
+ } else {
+ LOG(WARNING) << "Invalid on-screen keyboard background color: "
+ << background_color_.value();
+ }
}
- if (dark_theme_.has_value()) {
- bridge_->SetDarkTheme(dark_theme_.value());
+ if (light_theme_.has_value()) {
+ bridge_->SetLightTheme(light_theme_.value());
}
return promise;
diff --git a/cobalt/dom/on_screen_keyboard.h b/cobalt/dom/on_screen_keyboard.h
index ce7d0fa..ecad6bf 100644
--- a/cobalt/dom/on_screen_keyboard.h
+++ b/cobalt/dom/on_screen_keyboard.h
@@ -106,10 +106,10 @@
return background_color_;
}
- void set_dark_theme(base::Optional<bool> dark_theme) {
- dark_theme_ = dark_theme;
+ void set_light_theme(base::Optional<bool> light_theme) {
+ light_theme_ = light_theme;
}
- base::Optional<bool> dark_theme() const { return dark_theme_; }
+ base::Optional<bool> light_theme() const { return light_theme_; }
// Called by the WebModule to dispatch DOM show, hide, focus, blur and
// suggestions updated events.
@@ -149,7 +149,7 @@
base::Optional<std::string> background_color_;
- base::Optional<bool> dark_theme_;
+ base::Optional<bool> light_theme_;
DISALLOW_COPY_AND_ASSIGN(OnScreenKeyboard);
};
diff --git a/cobalt/dom/on_screen_keyboard.idl b/cobalt/dom/on_screen_keyboard.idl
index fe13887..9487eec 100644
--- a/cobalt/dom/on_screen_keyboard.idl
+++ b/cobalt/dom/on_screen_keyboard.idl
@@ -51,7 +51,7 @@
// 2. rgb color notation rgb(R, G, B), e.g. "rgb(0, 0, 255)".
attribute DOMString? backgroundColor;
- // This attribute overrides the dark theme of on-screen keyboard.
+ // This attribute overrides the light theme of on-screen keyboard.
// The attribute is only fully supported on Apple TV at the moment.
- attribute boolean? darkTheme;
+ attribute boolean? lightTheme;
};
diff --git a/cobalt/dom/on_screen_keyboard_bridge.h b/cobalt/dom/on_screen_keyboard_bridge.h
index c5623af..ac6ad1c 100644
--- a/cobalt/dom/on_screen_keyboard_bridge.h
+++ b/cobalt/dom/on_screen_keyboard_bridge.h
@@ -17,6 +17,7 @@
#include <string>
+#include "base/basictypes.h"
#include "cobalt/dom/dom_rect.h"
namespace cobalt {
@@ -39,8 +40,8 @@
virtual scoped_refptr<DOMRect> BoundingRect() const = 0;
virtual void SetKeepFocus(bool keep_focus) = 0;
virtual bool IsValidTicket(int ticket) const = 0;
- virtual void SetBackgroundColor(const char* background_color) = 0;
- virtual void SetDarkTheme(bool dark_theme) = 0;
+ virtual void SetBackgroundColor(uint8 r, uint8 g, uint8 b) = 0;
+ virtual void SetLightTheme(bool light_theme) = 0;
};
} // namespace dom
diff --git a/cobalt/dom/on_screen_keyboard_test.cc b/cobalt/dom/on_screen_keyboard_test.cc
index fd616a3..b567585 100644
--- a/cobalt/dom/on_screen_keyboard_test.cc
+++ b/cobalt/dom/on_screen_keyboard_test.cc
@@ -112,9 +112,9 @@
void SetKeepFocus(bool keep_focus) override { SetKeepFocusMock(keep_focus); }
- void SetBackgroundColor(const char* background_color) override {}
+ void SetBackgroundColor(uint8 r, uint8 g, uint8 b) override {}
- void SetDarkTheme(bool dark_theme) override {}
+ void SetLightTheme(bool light_theme) override {}
MOCK_METHOD1(ShowMock, void(std::string));
MOCK_METHOD0(HideMock, void());
@@ -386,7 +386,7 @@
let promise;
let logString;
)";
- EXPECT_TRUE(EvaluateScript(let_script, NULL));
+ EXPECT_TRUE(EvaluateScript(let_script));
const char event_script[] = R"(
logString = '(empty)';
window.onScreenKeyboard.onshow = function() {
@@ -436,7 +436,7 @@
let promise;
let logString;
)";
- EXPECT_TRUE(EvaluateScript(let_script, NULL));
+ EXPECT_TRUE(EvaluateScript(let_script));
const char event_script[] = R"(
logString = '(empty)';
window.onScreenKeyboard.onhide = function() {
@@ -485,7 +485,7 @@
let promise;
let logString;
)";
- EXPECT_TRUE(EvaluateScript(let_script, NULL));
+ EXPECT_TRUE(EvaluateScript(let_script));
const char event_script[] = R"(
logString = '(empty)';
window.onScreenKeyboard.onfocus = function() {
@@ -534,7 +534,7 @@
let promise;
let logString;
)";
- EXPECT_TRUE(EvaluateScript(let_script, NULL));
+ EXPECT_TRUE(EvaluateScript(let_script));
const char event_script[] = R"(
logString = '(empty)';
window.onScreenKeyboard.onblur = function() {
@@ -605,7 +605,7 @@
window.onScreenKeyboard.keepFocus = false;
window.onScreenKeyboard.keepFocus = true;
)";
- EXPECT_TRUE(EvaluateScript(script, NULL));
+ EXPECT_TRUE(EvaluateScript(script));
}
TEST_F(OnScreenKeyboardTest, SetBackgroundColor) {
@@ -635,21 +635,21 @@
EXPECT_EQ(color_str, result);
}
-TEST_F(OnScreenKeyboardTest, SetDarkTheme) {
+TEST_F(OnScreenKeyboardTest, SetLightTheme) {
if (SkipLocale()) return;
std::string result;
- EXPECT_TRUE(EvaluateScript("window.onScreenKeyboard.darkTheme;", &result));
+ EXPECT_TRUE(EvaluateScript("window.onScreenKeyboard.lightTheme;", &result));
EXPECT_EQ("null", result);
- std::string dark_theme_str = "false";
+ std::string light_theme_str = "true";
EXPECT_TRUE(
- EvaluateScript("window.onScreenKeyboard.darkTheme = " + dark_theme_str +
+ EvaluateScript("window.onScreenKeyboard.lightTheme = " + light_theme_str +
";"
- "window.onScreenKeyboard.darkTheme",
+ "window.onScreenKeyboard.lightTheme",
&result));
- EXPECT_EQ(dark_theme_str, result);
+ EXPECT_EQ(light_theme_str, result);
}
} // namespace dom
diff --git a/cobalt/dom/source_buffer.cc b/cobalt/dom/source_buffer.cc
index 1f6278b..449eaa1 100644
--- a/cobalt/dom/source_buffer.cc
+++ b/cobalt/dom/source_buffer.cc
@@ -103,6 +103,19 @@
return std::max<int>(bytes, 0);
}
+size_t GetMaxAppendSizeInBytes(script::EnvironmentSettings* settings,
+ size_t default_value) {
+ DOMSettings* dom_settings =
+ base::polymorphic_downcast<DOMSettings*>(settings);
+ DCHECK(dom_settings);
+ DCHECK(dom_settings->media_source_settings());
+ int bytes = dom_settings->media_source_settings()
+ ->GetMaxSourceBufferAppendSizeInBytes()
+ .value_or(default_value);
+ DCHECK_GT(bytes, 0);
+ return bytes;
+}
+
} // namespace
SourceBuffer::OnInitSegmentReceivedHelper::OnInitSegmentReceivedHelper(
@@ -133,13 +146,13 @@
SourceBuffer::SourceBuffer(script::EnvironmentSettings* settings,
const std::string& id, MediaSource* media_source,
- bool asynchronous_reduction_enabled,
ChunkDemuxer* chunk_demuxer, EventQueue* event_queue)
: web::EventTarget(settings),
on_init_segment_received_helper_(new OnInitSegmentReceivedHelper(this)),
id_(id),
- asynchronous_reduction_enabled_(asynchronous_reduction_enabled),
evict_extra_in_bytes_(GetEvictExtraInBytes(settings)),
+ max_append_buffer_size_(
+ GetMaxAppendSizeInBytes(settings, kDefaultMaxAppendBufferSize)),
media_source_(media_source),
chunk_demuxer_(chunk_demuxer),
event_queue_(event_queue),
@@ -154,6 +167,7 @@
DCHECK(event_queue);
LOG(INFO) << "Evict extra in bytes is set to " << evict_extra_in_bytes_;
+ LOG(INFO) << "Max append size in bytes is set to " << max_append_buffer_size_;
chunk_demuxer_->SetTracksWatcher(
id_,
@@ -381,10 +395,7 @@
std::unique_ptr<SourceBufferAlgorithm> algorithm(
new SourceBufferRemoveAlgorithm(
chunk_demuxer_, id_, DoubleToTimeDelta(start), DoubleToTimeDelta(end),
- base::Bind(asynchronous_reduction_enabled_
- ? &SourceBuffer::ScheduleAndMaybeDispatchImmediately
- : &SourceBuffer::ScheduleEvent,
- base::Unretained(this)),
+ base::Bind(&SourceBuffer::ScheduleEvent, base::Unretained(this)),
base::Bind(&SourceBuffer::OnAlgorithmFinalized,
base::Unretained(this))));
auto algorithm_runner =
@@ -481,16 +492,6 @@
event_queue_->Enqueue(event);
}
-void SourceBuffer::ScheduleAndMaybeDispatchImmediately(base::Token event_name) {
- ScheduleEvent(event_name);
- // TODO(b/244773734): Re-enable direct event dispatching
- /*
- scoped_refptr<web::Event> event = new web::Event(event_name);
- event->set_target(this);
- event_queue_->EnqueueAndMaybeDispatchImmediately(event);
- */
-}
-
bool SourceBuffer::PrepareAppend(size_t new_data_size,
script::ExceptionState* exception_state) {
TRACE_EVENT1("cobalt::dom", "SourceBuffer::PrepareAppend()", "new_data_size",
@@ -555,15 +556,12 @@
std::unique_ptr<SourceBufferAlgorithm> algorithm(
new SourceBufferAppendAlgorithm(
media_source_, chunk_demuxer_, id_, pending_append_data_.get(), size,
- DoubleToTimeDelta(append_window_start_),
+ max_append_buffer_size_, DoubleToTimeDelta(append_window_start_),
DoubleToTimeDelta(append_window_end_),
DoubleToTimeDelta(timestamp_offset_),
base::Bind(&SourceBuffer::UpdateTimestampOffset,
base::Unretained(this)),
- base::Bind(asynchronous_reduction_enabled_
- ? &SourceBuffer::ScheduleAndMaybeDispatchImmediately
- : &SourceBuffer::ScheduleEvent,
- base::Unretained(this)),
+ base::Bind(&SourceBuffer::ScheduleEvent, base::Unretained(this)),
base::Bind(&SourceBuffer::OnAlgorithmFinalized,
base::Unretained(this)),
&metrics_));
diff --git a/cobalt/dom/source_buffer.h b/cobalt/dom/source_buffer.h
index c7336e6..25b15ac 100644
--- a/cobalt/dom/source_buffer.h
+++ b/cobalt/dom/source_buffer.h
@@ -90,8 +90,8 @@
// Custom, not in any spec.
//
SourceBuffer(script::EnvironmentSettings* settings, const std::string& id,
- MediaSource* media_source, bool asynchronous_reduction_enabled,
- ChunkDemuxer* chunk_demuxer, EventQueue* event_queue);
+ MediaSource* media_source, ChunkDemuxer* chunk_demuxer,
+ EventQueue* event_queue);
// Web API: SourceBuffer
//
@@ -167,7 +167,6 @@
void OnInitSegmentReceived(std::unique_ptr<MediaTracks> tracks);
void ScheduleEvent(base::Token event_name);
- void ScheduleAndMaybeDispatchImmediately(base::Token event_name);
bool PrepareAppend(size_t new_data_size,
script::ExceptionState* exception_state);
void AppendBufferInternal(const unsigned char* data, size_t size,
@@ -185,10 +184,12 @@
const std::string& track_type,
const std::string& byte_stream_track_id) const;
+ static const size_t kDefaultMaxAppendBufferSize = 128 * 1024;
+
scoped_refptr<OnInitSegmentReceivedHelper> on_init_segment_received_helper_;
const std::string id_;
- const bool asynchronous_reduction_enabled_;
const size_t evict_extra_in_bytes_;
+ const size_t max_append_buffer_size_;
MediaSource* media_source_;
ChunkDemuxer* chunk_demuxer_;
diff --git a/cobalt/dom/source_buffer_algorithm.cc b/cobalt/dom/source_buffer_algorithm.cc
index 50eec01..a24e51c 100644
--- a/cobalt/dom/source_buffer_algorithm.cc
+++ b/cobalt/dom/source_buffer_algorithm.cc
@@ -27,8 +27,8 @@
SourceBufferAppendAlgorithm::SourceBufferAppendAlgorithm(
MediaSource* media_source, ::media::ChunkDemuxer* chunk_demuxer,
const std::string& id, const uint8_t* buffer, size_t size_in_bytes,
- base::TimeDelta append_window_start, base::TimeDelta append_window_end,
- base::TimeDelta timestamp_offset,
+ size_t max_append_size_in_bytes, base::TimeDelta append_window_start,
+ base::TimeDelta append_window_end, base::TimeDelta timestamp_offset,
UpdateTimestampOffsetCB&& update_timestamp_offset_cb,
ScheduleEventCB&& schedule_event_cb, base::OnceClosure&& finalized_cb,
SourceBufferMetrics* metrics)
@@ -36,6 +36,7 @@
chunk_demuxer_(chunk_demuxer),
id_(id),
buffer_(buffer),
+ max_append_size_(max_append_size_in_bytes),
bytes_remaining_(size_in_bytes),
append_window_start_(append_window_start),
append_window_end_(append_window_end),
@@ -46,6 +47,7 @@
metrics_(metrics) {
DCHECK(media_source_);
DCHECK(chunk_demuxer_);
+ DCHECK_GT(static_cast<int>(max_append_size_), 0);
if (bytes_remaining_ > 0) {
DCHECK(buffer);
}
@@ -60,9 +62,7 @@
DCHECK(finished);
DCHECK(!*finished);
- const size_t kMaxAppendSize = 128 * 1024;
-
- size_t append_size = std::min(bytes_remaining_, kMaxAppendSize);
+ size_t append_size = std::min(bytes_remaining_, max_append_size_);
TRACE_EVENT1("cobalt::dom", "SourceBufferAppendAlgorithm::Process()",
"append_size", append_size);
diff --git a/cobalt/dom/source_buffer_algorithm.h b/cobalt/dom/source_buffer_algorithm.h
index d9e0f16..3505794 100644
--- a/cobalt/dom/source_buffer_algorithm.h
+++ b/cobalt/dom/source_buffer_algorithm.h
@@ -58,8 +58,8 @@
SourceBufferAppendAlgorithm(
MediaSource* media_source, ::media::ChunkDemuxer* chunk_demuxer,
const std::string& id, const uint8_t* buffer, size_t size_in_bytes,
- base::TimeDelta append_window_start, base::TimeDelta append_window_end,
- base::TimeDelta timestamp_offset,
+ size_t max_append_size_in_bytes, base::TimeDelta append_window_start,
+ base::TimeDelta append_window_end, base::TimeDelta timestamp_offset,
UpdateTimestampOffsetCB&& update_timestamp_offset_cb,
ScheduleEventCB&& schedule_event_cb, base::OnceClosure&& finalized_cb,
SourceBufferMetrics* metrics);
@@ -74,6 +74,7 @@
::media::ChunkDemuxer* const chunk_demuxer_;
const std::string id_;
const uint8_t* buffer_;
+ const size_t max_append_size_;
size_t bytes_remaining_;
const base::TimeDelta append_window_start_;
const base::TimeDelta append_window_end_;
diff --git a/cobalt/dom/testing/stub_window.h b/cobalt/dom/testing/stub_window.h
index 6651633..9a67b66 100644
--- a/cobalt/dom/testing/stub_window.h
+++ b/cobalt/dom/testing/stub_window.h
@@ -91,18 +91,6 @@
on_screen_keyboard_bridge_ = on_screen_keyboard_bridge;
}
- private:
- static void StubLoadCompleteCallback(
- const base::Optional<std::string>& error) {}
-
- void InitializeWebContext() {
- web_context_.reset(new web::testing::StubWebContext());
- web_context()->setup_environment_settings(
- new dom::testing::StubEnvironmentSettings(options_));
- web_context()->environment_settings()->set_creation_url(
- GURL("about:blank"));
- }
-
void InitializeWindow() {
loader_factory_.reset(new loader::LoaderFactory(
"Test", web_context()->fetcher_factory(), NULL,
@@ -143,6 +131,19 @@
window_, web_context()->environment_settings());
}
+ private:
+ static void StubLoadCompleteCallback(
+ const base::Optional<std::string>& error) {}
+
+ void InitializeWebContext() {
+ web_context_.reset(new web::testing::StubWebContext());
+ web_context()->setup_environment_settings(
+ new dom::testing::StubEnvironmentSettings(options_));
+ web_context()->environment_settings()->set_creation_url(
+ GURL("about:blank"));
+ }
+
+
OnScreenKeyboardBridge* on_screen_keyboard_bridge_ = nullptr;
DOMSettings::Options options_;
std::unique_ptr<css_parser::Parser> css_parser_;
diff --git a/cobalt/dom/testing/test_with_javascript.h b/cobalt/dom/testing/test_with_javascript.h
index 30204af..e51747f 100644
--- a/cobalt/dom/testing/test_with_javascript.h
+++ b/cobalt/dom/testing/test_with_javascript.h
@@ -42,24 +42,38 @@
EXPECT_TRUE(GlobalStats::GetInstance()->CheckNoLeaks());
}
- StubWindow* stub_window() { return stub_window_.get(); }
- web::testing::StubWebContext* stub_web_context() {
+ StubWindow* stub_window() const { return stub_window_.get(); }
+ web::testing::StubWebContext* stub_web_context() const {
+ DCHECK(stub_window_);
return stub_window_->web_context();
}
- Window* window() { return stub_window_->window().get(); }
+ Window* window() const {
+ DCHECK(stub_window_);
+ return stub_window_->window().get();
+ }
- bool EvaluateScript(const std::string& js_code, std::string* result) {
+ web::Context* web_context() const { return stub_web_context(); }
+
+ scoped_refptr<script::GlobalEnvironment> global_environment() const {
+ DCHECK(web_context());
+ return web_context()->global_environment();
+ }
+
+ bool EvaluateScript(const std::string& js_code,
+ std::string* result = nullptr) {
+ DCHECK(global_environment());
return global_environment()->EvaluateScript(
CreateSourceCodeAndPrepareEval(js_code), result);
}
bool EvaluateScript(
const std::string& js_code,
- const scoped_refptr<script::Wrappable>& owning_object,
- base::Optional<script::ValueHandleHolder::Reference>* result = NULL) {
+ base::Optional<script::ValueHandleHolder::Reference>* result) {
+ DCHECK(global_environment());
return global_environment()->EvaluateScript(
- CreateSourceCodeAndPrepareEval(js_code), owning_object, result);
+ CreateSourceCodeAndPrepareEval(js_code),
+ web_context()->GetWindowOrWorkerGlobalScope(), result);
}
::testing::StrictMock<script::testing::MockExceptionState>*
diff --git a/cobalt/extension/crash_handler.h b/cobalt/extension/crash_handler.h
index 8cf4732..912caba 100644
--- a/cobalt/extension/crash_handler.h
+++ b/cobalt/extension/crash_handler.h
@@ -36,8 +36,15 @@
// The fields below this point were added in version 1 or later.
+ // Deprecated in version 2 and later.
bool (*OverrideCrashpadAnnotations)(
CrashpadAnnotations* crashpad_annotations);
+
+ // The fields below this point were added in version 2 or later.
+
+ // Sets a (key, value) pair for the handler to include when annotating a
+ // crash. Returns true on success and false on failure.
+ bool (*SetString)(const char* key, const char* value);
} CobaltExtensionCrashHandlerApi;
#ifdef __cplusplus
diff --git a/cobalt/extension/extension_test.cc b/cobalt/extension/extension_test.cc
index cd7158d..58f051e 100644
--- a/cobalt/extension/extension_test.cc
+++ b/cobalt/extension/extension_test.cc
@@ -221,9 +221,14 @@
}
EXPECT_STREQ(extension_api->name, kExtensionName);
- EXPECT_EQ(extension_api->version, 1u);
+ EXPECT_GE(extension_api->version, 1u);
+ EXPECT_LE(extension_api->version, 2u);
EXPECT_NE(extension_api->OverrideCrashpadAnnotations, nullptr);
+ if (extension_api->version >= 2) {
+ EXPECT_NE(extension_api->SetString, nullptr);
+ }
+
const ExtensionApi* second_extension_api =
static_cast<const ExtensionApi*>(SbSystemGetExtension(kExtensionName));
EXPECT_EQ(second_extension_api, extension_api)
diff --git a/cobalt/extension/on_screen_keyboard.h b/cobalt/extension/on_screen_keyboard.h
index a1d922d..315e2b7 100644
--- a/cobalt/extension/on_screen_keyboard.h
+++ b/cobalt/extension/on_screen_keyboard.h
@@ -15,8 +15,6 @@
#ifndef COBALT_EXTENSION_ON_SCREEN_KEYBOARD_H_
#define COBALT_EXTENSION_ON_SCREEN_KEYBOARD_H_
-#include <stdint.h>
-
#include "starboard/system.h"
#include "starboard/window.h"
@@ -38,16 +36,12 @@
// The fields below this point were added in version 1 or later.
- // This function overrides the background color of on-screen keyboard.
- // The function is only enabled for Apple TV at the moment.
- // background_color should be a string of below formats:
- // 1. hex color notation #RRGGBB, e.g. "#0000FF".
- // 2. rgb color notation rgb(R, G, B), e.g. "rgb(0, 0, 255)".
- void (*SetBackgroundColor)(SbWindow window, const char* background_color);
+ // This function overrides the background color of on-screen keyboard in RGB
+ // color space, where r, g, b are between 0 and 255.
+ void (*SetBackgroundColor)(SbWindow window, uint8_t r, uint8_t g, uint8_t b);
- // This function overrides the dark theme of on-screen keyboard.
- // The function is only enabled for Apple TV at the moment.
- void (*SetDarkTheme)(SbWindow window, bool dark_theme);
+ // This function overrides the light theme of on-screen keyboard.
+ void (*SetLightTheme)(SbWindow window, bool light_theme);
} CobaltExtensionOnScreenKeyboardApi;
#ifdef __cplusplus
diff --git a/cobalt/h5vcc/h5vcc_crash_log.cc b/cobalt/h5vcc/h5vcc_crash_log.cc
index 737d64c..a240d92 100644
--- a/cobalt/h5vcc/h5vcc_crash_log.cc
+++ b/cobalt/h5vcc/h5vcc_crash_log.cc
@@ -20,6 +20,7 @@
#include "base/atomicops.h"
#include "base/memory/singleton.h"
#include "base/synchronization/lock.h"
+#include "cobalt/extension/crash_handler.h"
#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
#include STARBOARD_CORE_DUMP_HANDLER_INCLUDE
@@ -97,6 +98,15 @@
bool H5vccCrashLog::SetString(const std::string& key,
const std::string& value) {
+ auto crash_handler_extension =
+ static_cast<const CobaltExtensionCrashHandlerApi*>(
+ SbSystemGetExtension(kCobaltExtensionCrashHandlerName));
+ if (crash_handler_extension && crash_handler_extension->version >= 2) {
+ return crash_handler_extension->SetString(key.c_str(), value.c_str());
+ }
+ // The platform has not implemented a version of the CrashHandler Cobalt
+ // Extension appropriate for this use case.
+
// Forward the call to a global singleton so that we keep a consistent crash
// log globally.
CrashLogDictionary::GetInstance()->SetString(key, value);
diff --git a/cobalt/h5vcc/h5vcc_crash_log.idl b/cobalt/h5vcc/h5vcc_crash_log.idl
index 7892219..e93caac 100644
--- a/cobalt/h5vcc/h5vcc_crash_log.idl
+++ b/cobalt/h5vcc/h5vcc_crash_log.idl
@@ -56,9 +56,8 @@
boolean ping(DOMString name, DOMString ping_info);
// Returns a json string containing the Watchdog violations since the last
- // call, up to the 200 most recent. Clears internal cache of Watchdog
- // violations to prevent duplicates. Timestamps are stored as strings due to
- // int size constraints.
+ // call, up to 200. Clears internal cache of Watchdog violations to prevent
+ // duplicates. Timestamps are stored as strings due to int size constraints.
// Example json:
// {
// "test-name":{
diff --git a/cobalt/layout_tests/layout_snapshot.cc b/cobalt/layout_tests/layout_snapshot.cc
index 57e3769..88d07f3 100644
--- a/cobalt/layout_tests/layout_snapshot.cc
+++ b/cobalt/layout_tests/layout_snapshot.cc
@@ -83,7 +83,7 @@
// Use test runner mode to allow the content itself to dictate when it is
// ready for layout should be performed. See cobalt/dom/test_runner.h.
- browser::WebModule::Options web_module_options("SnapshotURL");
+ browser::WebModule::Options web_module_options;
web_module_options.layout_trigger = layout::LayoutManager::kTestRunnerMode;
web_module_options.image_cache_capacity = kImageCacheCapacity;
web_module_options.provide_screenshot_function = screenshot_provider;
@@ -97,7 +97,8 @@
base::Optional<browser::WebModule::LayoutResults> results;
// Create the WebModule and wait for a layout to occur.
- browser::WebModule web_module(
+ browser::WebModule web_module("SnapshotURL");
+ web_module.Run(
url, base::kApplicationStateStarted,
base::Bind(&WebModuleOnRenderTreeProducedCallback, &results, &run_loop,
base::MessageLoop::current()),
diff --git a/cobalt/layout_tests/web_platform_tests.cc b/cobalt/layout_tests/web_platform_tests.cc
index 520ed72..c5406bf 100644
--- a/cobalt/layout_tests/web_platform_tests.cc
+++ b/cobalt/layout_tests/web_platform_tests.cc
@@ -209,7 +209,7 @@
web::kCspEnforcementEnable, CspDelegatePermissive::Create);
// Use test runner mode to allow the content itself to dictate when it is
// ready for layout should be performed. See cobalt/dom/test_runner.h.
- browser::WebModule::Options web_module_options("RunWebPlatformTest");
+ browser::WebModule::Options web_module_options;
web_module_options.layout_trigger = layout::LayoutManager::kTestRunnerMode;
// We assume that we won't suspend/resume while running the tests, and so
// we take advantage of the convenience of inline script tags.
@@ -222,7 +222,8 @@
base::RunLoop run_loop;
// Create the WebModule and wait for a layout to occur.
- browser::WebModule web_module(
+ browser::WebModule web_module("RunWebPlatformTest");
+ web_module.Run(
url, base::kApplicationStateStarted,
base::Bind(&WebModuleOnRenderTreeProducedCallback, &results),
base::Bind(&WebModuleErrorCallback, &run_loop,
diff --git a/cobalt/loader/loader_factory.cc b/cobalt/loader/loader_factory.cc
index ba571ba..0cb575e 100644
--- a/cobalt/loader/loader_factory.cc
+++ b/cobalt/loader/loader_factory.cc
@@ -71,7 +71,8 @@
std::unique_ptr<Loader> loader(new Loader(
fetcher_creator,
- base::Bind(&loader::TextDecoder::Create, link_available_callback),
+ base::Bind(&loader::TextDecoder::Create, link_available_callback,
+ loader::TextDecoder::ResponseStartedCallback()),
load_complete_callback,
base::Bind(&LoaderFactory::OnLoaderDestroyed, base::Unretained(this)),
is_suspended_));
diff --git a/cobalt/loader/loader_test.cc b/cobalt/loader/loader_test.cc
index fc0b3b6..424f402 100644
--- a/cobalt/loader/loader_test.cc
+++ b/cobalt/loader/loader_test.cc
@@ -250,13 +250,13 @@
FileFetcher::Options fetcher_options;
TextDecoderCallback text_decoder_callback(&run_loop);
LoaderCallback loader_callback(&run_loop);
- Loader loader(
- base::Bind(&FileFetcher::Create, file_path, fetcher_options),
- base::Bind(&loader::TextDecoder::Create,
- base::Bind(&TextDecoderCallback::OnDone,
- base::Unretained(&text_decoder_callback))),
- base::Bind(&LoaderCallback::OnLoadComplete,
- base::Unretained(&loader_callback)));
+ Loader loader(base::Bind(&FileFetcher::Create, file_path, fetcher_options),
+ base::Bind(&loader::TextDecoder::Create,
+ base::Bind(&TextDecoderCallback::OnDone,
+ base::Unretained(&text_decoder_callback)),
+ loader::TextDecoder::ResponseStartedCallback()),
+ base::Bind(&LoaderCallback::OnLoadComplete,
+ base::Unretained(&loader_callback)));
// When the message loop runs, the loader will start loading. It'll quit when
// loading is finished.
diff --git a/cobalt/loader/script_loader_factory.cc b/cobalt/loader/script_loader_factory.cc
index 8fb5cac..0e64cf0 100644
--- a/cobalt/loader/script_loader_factory.cc
+++ b/cobalt/loader/script_loader_factory.cc
@@ -47,19 +47,31 @@
const csp::SecurityCallback& url_security_callback,
const TextDecoder::TextAvailableCallback& script_available_callback,
const Loader::OnCompleteFunction& load_complete_callback) {
+ return CreateScriptLoader(
+ url, origin, url_security_callback, script_available_callback,
+ TextDecoder::ResponseStartedCallback(), load_complete_callback);
+}
+
+std::unique_ptr<Loader> ScriptLoaderFactory::CreateScriptLoader(
+ const GURL& url, const Origin& origin,
+ const csp::SecurityCallback& url_security_callback,
+ const TextDecoder::TextAvailableCallback& script_available_callback,
+ const TextDecoder::ResponseStartedCallback& response_started_callback,
+ const Loader::OnCompleteFunction& load_complete_callback) {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
Loader::FetcherCreator fetcher_creator =
MakeFetcherCreator(url, url_security_callback, kNoCORSMode, origin,
disk_cache::kUncompiledScript);
- std::unique_ptr<Loader> loader(new Loader(
- fetcher_creator,
- base::Bind(&loader::TextDecoder::Create, script_available_callback),
- load_complete_callback,
- base::Bind(&ScriptLoaderFactory::OnLoaderDestroyed,
- base::Unretained(this)),
- is_suspended_));
+ std::unique_ptr<Loader> loader(
+ new Loader(fetcher_creator,
+ base::Bind(&TextDecoder::Create, script_available_callback,
+ response_started_callback),
+ load_complete_callback,
+ base::Bind(&ScriptLoaderFactory::OnLoaderDestroyed,
+ base::Unretained(this)),
+ is_suspended_));
OnLoaderCreated(loader.get());
return loader;
diff --git a/cobalt/loader/script_loader_factory.h b/cobalt/loader/script_loader_factory.h
index 5fcc8a4..2ae2a40 100644
--- a/cobalt/loader/script_loader_factory.h
+++ b/cobalt/loader/script_loader_factory.h
@@ -48,6 +48,13 @@
const TextDecoder::TextAvailableCallback& script_available_callback,
const Loader::OnCompleteFunction& load_complete_callback);
+ std::unique_ptr<Loader> CreateScriptLoader(
+ const GURL& url, const Origin& origin,
+ const csp::SecurityCallback& url_security_callback,
+ const TextDecoder::TextAvailableCallback& script_available_callback,
+ const TextDecoder::ResponseStartedCallback& response_started_callback,
+ const Loader::OnCompleteFunction& load_complete_callback);
+
protected:
void OnLoaderCreated(Loader* loader);
void OnLoaderDestroyed(Loader* loader);
diff --git a/cobalt/loader/text_decoder.h b/cobalt/loader/text_decoder.h
index 07a2492..16ad4ce 100644
--- a/cobalt/loader/text_decoder.h
+++ b/cobalt/loader/text_decoder.h
@@ -34,6 +34,9 @@
// results.
class TextDecoder : public Decoder {
public:
+ typedef base::Callback<bool(
+ Fetcher* fetcher, const scoped_refptr<net::HttpResponseHeaders>& headers)>
+ ResponseStartedCallback;
typedef base::Callback<void(const loader::Origin&,
std::unique_ptr<std::string>)>
TextAvailableCallback;
@@ -43,10 +46,24 @@
// This function is used for binding callback for creating TextDecoder.
static std::unique_ptr<Decoder> Create(
const TextAvailableCallback& text_available_callback,
+ const ResponseStartedCallback& response_started_callback =
+ ResponseStartedCallback(),
const loader::Decoder::OnCompleteFunction& load_complete_callback =
loader::Decoder::OnCompleteFunction()) {
- return std::unique_ptr<Decoder>(
- new TextDecoder(text_available_callback, load_complete_callback));
+ return std::unique_ptr<Decoder>(new TextDecoder(text_available_callback,
+ response_started_callback,
+ load_complete_callback));
+ }
+
+ LoadResponseType OnResponseStarted(
+ Fetcher* fetcher, const scoped_refptr<net::HttpResponseHeaders>& headers)
+ override WARN_UNUSED_RESULT {
+ if (fetcher && headers && !response_started_callback_.is_null()) {
+ if (!response_started_callback_.Run(fetcher, headers)) {
+ return kLoadResponseAbort;
+ }
+ }
+ return kLoadResponseContinue;
}
// From Decoder.
@@ -105,13 +122,16 @@
private:
explicit TextDecoder(
const TextAvailableCallback& text_available_callback,
+ const ResponseStartedCallback& response_started_callback,
const loader::Decoder::OnCompleteFunction& load_complete_callback)
: text_available_callback_(text_available_callback),
+ response_started_callback_(response_started_callback),
load_complete_callback_(load_complete_callback),
suspended_(false) {}
THREAD_CHECKER(thread_checker_);
TextAvailableCallback text_available_callback_;
+ ResponseStartedCallback response_started_callback_;
loader::Decoder::OnCompleteFunction load_complete_callback_;
loader::Origin last_url_origin_;
std::unique_ptr<std::string> text_;
diff --git a/cobalt/media/base/pipeline.h b/cobalt/media/base/pipeline.h
index e729c41..9f9995e 100644
--- a/cobalt/media/base/pipeline.h
+++ b/cobalt/media/base/pipeline.h
@@ -57,6 +57,7 @@
typedef ::media::PipelineStatistics PipelineStatistics;
typedef ::media::PipelineStatus PipelineStatus;
typedef ::media::PipelineStatusCallback PipelineStatusCallback;
+ typedef ::media::PipelineStatusCB PipelineStatusCB;
typedef base::Callback<void(PipelineStatus status, bool is_initial_preroll,
const std::string& error_message)>
@@ -126,7 +127,7 @@
// It is an error to call this method after the pipeline has already started.
virtual void Start(Demuxer* demuxer,
const SetDrmSystemReadyCB& set_drm_system_ready_cb,
- PipelineStatusCallback ended_cb, const ErrorCB& error_cb,
+ const PipelineStatusCB& ended_cb, const ErrorCB& error_cb,
const SeekCB& seek_cb,
const BufferingStateCB& buffering_state_cb,
const base::Closure& duration_change_cb,
@@ -140,7 +141,7 @@
const OnEncryptedMediaInitDataEncounteredCB&
encrypted_media_init_data_encountered_cb,
const std::string& source_url,
- PipelineStatusCallback ended_cb, const ErrorCB& error_cb,
+ const PipelineStatusCB& ended_cb, const ErrorCB& error_cb,
const SeekCB& seek_cb,
const BufferingStateCB& buffering_state_cb,
const base::Closure& duration_change_cb,
diff --git a/cobalt/media/base/sbplayer_pipeline.cc b/cobalt/media/base/sbplayer_pipeline.cc
index c48b29c..9b9d538 100644
--- a/cobalt/media/base/sbplayer_pipeline.cc
+++ b/cobalt/media/base/sbplayer_pipeline.cc
@@ -76,7 +76,7 @@
struct StartTaskParameters {
Demuxer* demuxer;
SetDrmSystemReadyCB set_drm_system_ready_cb;
- PipelineStatusCallback ended_cb;
+ ::media::PipelineStatusCB ended_cb;
ErrorCB error_cb;
Pipeline::SeekCB seek_cb;
Pipeline::BufferingStateCB buffering_state_cb;
@@ -113,7 +113,7 @@
void Start(Demuxer* demuxer,
const SetDrmSystemReadyCB& set_drm_system_ready_cb,
- PipelineStatusCallback ended_cb, const ErrorCB& error_cb,
+ const PipelineStatusCB& ended_cb, const ErrorCB& error_cb,
const SeekCB& seek_cb, const BufferingStateCB& buffering_state_cb,
const base::Closure& duration_change_cb,
const base::Closure& output_mode_change_cb,
@@ -123,7 +123,7 @@
void Start(const SetDrmSystemReadyCB& set_drm_system_ready_cb,
const OnEncryptedMediaInitDataEncounteredCB&
encrypted_media_init_data_encountered_cb,
- const std::string& source_url, PipelineStatusCallback ended_cb,
+ const std::string& source_url, const PipelineStatusCB& ended_cb,
const ErrorCB& error_cb, const SeekCB& seek_cb,
const BufferingStateCB& buffering_state_cb,
const base::Closure& duration_change_cb,
@@ -265,7 +265,7 @@
// Permanent callbacks passed in via Start().
SetDrmSystemReadyCB set_drm_system_ready_cb_;
- PipelineStatusCallback ended_cb_;
+ PipelineStatusCB ended_cb_;
ErrorCB error_cb_;
BufferingStateCB buffering_state_cb_;
base::Closure duration_change_cb_;
@@ -441,7 +441,7 @@
void SbPlayerPipeline::Start(Demuxer* demuxer,
const SetDrmSystemReadyCB& set_drm_system_ready_cb,
- PipelineStatusCallback ended_cb,
+ const PipelineStatusCB& ended_cb,
const ErrorCB& error_cb, const SeekCB& seek_cb,
const BufferingStateCB& buffering_state_cb,
const base::Closure& duration_change_cb,
@@ -462,7 +462,7 @@
StartTaskParameters parameters;
parameters.demuxer = demuxer;
parameters.set_drm_system_ready_cb = set_drm_system_ready_cb;
- parameters.ended_cb = std::move(ended_cb);
+ parameters.ended_cb = ended_cb;
parameters.error_cb = error_cb;
parameters.seek_cb = seek_cb;
parameters.buffering_state_cb = buffering_state_cb;
@@ -484,7 +484,7 @@
const OnEncryptedMediaInitDataEncounteredCB&
on_encrypted_media_init_data_encountered_cb,
const std::string& source_url,
- PipelineStatusCallback ended_cb,
+ const PipelineStatusCB& ended_cb,
const ErrorCB& error_cb, const SeekCB& seek_cb,
const BufferingStateCB& buffering_state_cb,
const base::Closure& duration_change_cb,
@@ -504,7 +504,7 @@
StartTaskParameters parameters;
parameters.demuxer = NULL;
parameters.set_drm_system_ready_cb = set_drm_system_ready_cb;
- parameters.ended_cb = std::move(ended_cb);
+ parameters.ended_cb = ended_cb;
parameters.error_cb = error_cb;
parameters.seek_cb = seek_cb;
parameters.buffering_state_cb = buffering_state_cb;
@@ -810,7 +810,7 @@
demuxer_ = parameters.demuxer;
set_drm_system_ready_cb_ = parameters.set_drm_system_ready_cb;
- ended_cb_ = std::move(parameters.ended_cb);
+ ended_cb_ = parameters.ended_cb;
error_cb_ = parameters.error_cb;
{
base::AutoLock auto_lock(lock_);
@@ -1327,7 +1327,7 @@
break;
}
case kSbPlayerStateEndOfStream:
- std::move(ended_cb_).Run(::media::PIPELINE_OK);
+ ended_cb_.Run(::media::PIPELINE_OK);
ended_ = true;
break;
case kSbPlayerStateDestroyed:
diff --git a/cobalt/media/base/starboard_player.cc b/cobalt/media/base/starboard_player.cc
index 7e7da28..3c9d8cf 100644
--- a/cobalt/media/base/starboard_player.cc
+++ b/cobalt/media/base/starboard_player.cc
@@ -567,12 +567,6 @@
bool is_visible = SbWindowIsValid(window_);
SbMediaAudioCodec audio_codec = audio_sample_info_.codec;
- SbMediaVideoCodec video_codec = kSbMediaVideoCodecNone;
- // TODO: This is temporary for supporting background media playback.
- // Need to be removed with media refactor.
- if (is_visible) {
- video_codec = video_sample_info_.codec;
- }
bool has_audio = audio_codec != kSbMediaAudioCodecNone;
@@ -1023,8 +1017,8 @@
" kSbPlayerStatePrerolling received %" PRId64 " us\n"
" First media sample(s) written [a/v] %" PRId64 "/%" PRId64 " us\n"
" kSbPlayerStatePresenting received %" PRId64 " us\n"
- " Startup latency statistics (us):\n"
- " min: %" PRId64 ", median: %" PRId64 ", average: %" PRId64
+ " Startup latency statistics (us):"
+ " min: %" PRId64 ", median: %" PRId64 ", average: %" PRId64
", max: %" PRId64,
startup_latency,
first_events_str.c_str(), player_initialization_time_delta,
diff --git a/cobalt/media/progressive/avc_parser.cc b/cobalt/media/progressive/avc_parser.cc
index f9dcc0b..4c447db 100644
--- a/cobalt/media/progressive/avc_parser.cc
+++ b/cobalt/media/progressive/avc_parser.cc
@@ -477,6 +477,7 @@
aac.GetChannelLayout(kSbrInMimetype),
aac.GetOutputSamplesPerSecond(kSbrInMimetype), aac.codec_specific_data(),
::media::EncryptionScheme::kUnencrypted, base::TimeDelta(), 0);
+ audio_config_.set_aac_extra_data(aac.codec_specific_data());
}
size_t AVCParser::CalculatePrependSize(DemuxerStream::Type type,
diff --git a/cobalt/media_integration_tests/functionality/general_playback.py b/cobalt/media_integration_tests/functionality/general_playback.py
index 8b3ea3a..8dcd83d 100644
--- a/cobalt/media_integration_tests/functionality/general_playback.py
+++ b/cobalt/media_integration_tests/functionality/general_playback.py
@@ -40,8 +40,7 @@
TEST_PARAMETERS = [
('H264', PlaybackUrls.H264_ONLY, None),
- # TODO(b/223856877) -- find out why Progressive still broken
- #('PROGRESSIVE', PlaybackUrls.PROGRESSIVE, None),
+ ('PROGRESSIVE', PlaybackUrls.PROGRESSIVE, None),
('ENCRYPTED', PlaybackUrls.ENCRYPTED, None),
('VR', PlaybackUrls.VR, None),
('VP9', PlaybackUrls.VP9, MimeStrings.VP9),
diff --git a/cobalt/script/script_value.h b/cobalt/script/script_value.h
index e1345e2..25567d7 100644
--- a/cobalt/script/script_value.h
+++ b/cobalt/script/script_value.h
@@ -17,6 +17,7 @@
#include <algorithm>
#include <memory>
+#include <utility>
#include "base/basictypes.h"
#include "base/logging.h"
@@ -171,8 +172,10 @@
: Handle(reference.referenced_value().MakeWeakCopy().release()) {}
Handle(const Handle& other) : script_value_(other.script_value_) {
- script_value_->PreventGarbageCollection();
- script_value_->reference_count_++;
+ if (script_value_) {
+ script_value_->PreventGarbageCollection();
+ script_value_->reference_count_++;
+ }
}
// We need the default constructor for nullable ScriptValue.
Handle() = default;
diff --git a/cobalt/script/v8c/conversion_helpers.h b/cobalt/script/v8c/conversion_helpers.h
index 81bf303..d1779af 100644
--- a/cobalt/script/v8c/conversion_helpers.h
+++ b/cobalt/script/v8c/conversion_helpers.h
@@ -85,7 +85,8 @@
inline void ToJSValue(v8::Isolate* isolate, const std::string& in_string,
v8::Local<v8::Value>* out_value) {
v8::MaybeLocal<v8::String> maybe_string = v8::String::NewFromUtf8(
- isolate, in_string.data(), v8::NewStringType::kNormal, in_string.size());
+ isolate, in_string.data(), v8::NewStringType::kNormal,
+ static_cast<int>(in_string.size()));
v8::Local<v8::Value> string;
if (!maybe_string.ToLocal(&string)) {
*out_value = v8::Null(isolate);
@@ -107,7 +108,8 @@
inline void ToJSValue(v8::Isolate* isolate, const std::vector<uint8_t>& in_data,
v8::Local<v8::Value>* out_value) {
v8::MaybeLocal<v8::String> maybe_string = v8::String::NewFromOneByte(
- isolate, in_data.data(), v8::NewStringType::kNormal, in_data.size());
+ isolate, in_data.data(), v8::NewStringType::kNormal,
+ static_cast<int>(in_data.size()));
v8::Local<v8::Value> string;
if (!maybe_string.ToLocal(&string)) {
*out_value = v8::Null(isolate);
@@ -165,12 +167,12 @@
}
template <typename T>
-inline const double UpperBound() {
+inline double UpperBound() {
return std::numeric_limits<T>::max();
}
template <typename T>
-inline const double LowerBound() {
+inline double LowerBound() {
return std::numeric_limits<T>::min();
}
@@ -179,19 +181,19 @@
// step 1 of ConvertToInt, see:
// https://heycam.github.io/webidl/#abstract-opdef-converttoint
template <>
-inline const double UpperBound<int64_t>() {
+inline double UpperBound<int64_t>() {
const double kInt64UpperBound = static_cast<double>((1ll << 53) - 1);
return kInt64UpperBound;
}
template <>
-inline const double LowerBound<int64_t>() {
+inline double LowerBound<int64_t>() {
const double kInt64LowerBound = static_cast<double>(-(1ll << 53) + 1);
return kInt64LowerBound;
}
template <>
-inline const double UpperBound<uint64_t>() {
+inline double UpperBound<uint64_t>() {
const double kUInt64UpperBound = static_cast<double>((1ll << 53) - 1);
return kUInt64UpperBound;
}
@@ -602,8 +604,7 @@
// 4.3. Let P be the result of calling ToString(i).
// 4.4. Call CreateDataProperty(A, P, E).
- v8::Maybe<bool> set_result =
- array->Set(isolate->GetCurrentContext(), index, element);
+ array->Set(isolate->GetCurrentContext(), index, element).Check();
// 4.5. Set i to i + 1.
}
diff --git a/cobalt/script/v8c/helpers.h b/cobalt/script/v8c/helpers.h
index c2bfbef..2529039 100644
--- a/cobalt/script/v8c/helpers.h
+++ b/cobalt/script/v8c/helpers.h
@@ -15,6 +15,8 @@
#ifndef COBALT_SCRIPT_V8C_HELPERS_H_
#define COBALT_SCRIPT_V8C_HELPERS_H_
+#include <string>
+
#include "starboard/common/string.h"
#include "v8/include/v8.h"
@@ -35,7 +37,7 @@
}
return v8::String::NewFromOneByte(
isolate, reinterpret_cast<const uint8_t*>(string),
- v8::NewStringType::kInternalized, strlen(string))
+ v8::NewStringType::kInternalized, static_cast<int>(strlen(string)))
.ToLocalChecked();
}
diff --git a/cobalt/script/v8c/v8c_array_buffer.h b/cobalt/script/v8c/v8c_array_buffer.h
index 17d468c..e1d1212 100644
--- a/cobalt/script/v8c/v8c_array_buffer.h
+++ b/cobalt/script/v8c/v8c_array_buffer.h
@@ -36,7 +36,7 @@
V8cArrayBuffer() = default;
V8cArrayBuffer(v8::Isolate* isolate, v8::Local<v8::Value> value)
- : isolate_(isolate), ScopedPersistent(isolate, value) {
+ : ScopedPersistent(isolate, value), isolate_(isolate) {
DCHECK(value->IsArrayBuffer());
}
@@ -95,8 +95,7 @@
return;
}
- *out_array_buffer =
- std::move(V8cUserObjectHolder<V8cArrayBuffer>(isolate, value));
+ *out_array_buffer = V8cUserObjectHolder<V8cArrayBuffer>(isolate, value);
}
} // namespace v8c
diff --git a/cobalt/script/v8c/v8c_array_buffer_view.h b/cobalt/script/v8c/v8c_array_buffer_view.h
index caaf6a2..0c00986 100644
--- a/cobalt/script/v8c/v8c_array_buffer_view.h
+++ b/cobalt/script/v8c/v8c_array_buffer_view.h
@@ -36,7 +36,7 @@
// Default constructor should only be used by bindings code.
V8cArrayBufferView() = default;
V8cArrayBufferView(v8::Isolate* isolate, v8::Local<v8::Value> value)
- : isolate_(isolate), ScopedPersistent(isolate, value) {
+ : ScopedPersistent(isolate, value), isolate_(isolate) {
DCHECK(value->IsArrayBufferView());
}
@@ -111,7 +111,7 @@
}
*out_array_buffer_view =
- std::move(V8cUserObjectHolder<V8cArrayBufferView>(isolate, value));
+ V8cUserObjectHolder<V8cArrayBufferView>(isolate, value);
}
} // namespace v8c
diff --git a/cobalt/script/v8c/v8c_data_view.h b/cobalt/script/v8c/v8c_data_view.h
index 0a0ae84..d8f56ee 100644
--- a/cobalt/script/v8c/v8c_data_view.h
+++ b/cobalt/script/v8c/v8c_data_view.h
@@ -35,7 +35,7 @@
// Default constructor should only be used by bindings code.
V8cDataView() = default;
V8cDataView(v8::Isolate* isolate, v8::Local<v8::Value> value)
- : isolate_(isolate), ScopedPersistent(isolate, value) {
+ : ScopedPersistent(isolate, value), isolate_(isolate) {
DCHECK(value->IsDataView());
}
@@ -110,8 +110,7 @@
return;
}
- *out_array_buffer_view =
- std::move(V8cUserObjectHolder<V8cDataView>(isolate, value));
+ *out_array_buffer_view = V8cUserObjectHolder<V8cDataView>(isolate, value);
}
} // namespace v8c
diff --git a/cobalt/script/v8c/v8c_typed_arrays.h b/cobalt/script/v8c/v8c_typed_arrays.h
index e8c9474..82e7509 100644
--- a/cobalt/script/v8c/v8c_typed_arrays.h
+++ b/cobalt/script/v8c/v8c_typed_arrays.h
@@ -37,7 +37,7 @@
// Default constructor should only be used by bindings code.
V8cTypedArray() = default;
V8cTypedArray(v8::Isolate* isolate, v8::Local<v8::Value> value)
- : isolate_(isolate), ScopedPersistent(isolate, value) {
+ : ScopedPersistent(isolate, value), isolate_(isolate) {
DCHECK(value->IsTypedArray());
}
@@ -115,8 +115,8 @@
return;
}
- *out_typed_array = std::move(
- V8cUserObjectHolder<V8cTypedArray>(isolate, value.As<v8::TypedArray>()));
+ *out_typed_array =
+ V8cUserObjectHolder<V8cTypedArray>(isolate, value.As<v8::TypedArray>());
}
template <typename CType, typename BaseTypeName, typename V8Type,
@@ -129,7 +129,7 @@
// Default constructor should only be used by bindings code.
V8cTypedArrayImpl() = default;
V8cTypedArrayImpl(v8::Isolate* isolate, v8::Local<v8::Value> value)
- : isolate_(isolate), ScopedPersistent(isolate, value) {
+ : ScopedPersistent(isolate, value), isolate_(isolate) {
DCHECK(((**value).*(V8ValueIsTypeFunction))());
}
@@ -178,42 +178,42 @@
COBALT_SCRIPT_TYPED_ARRAY_LIST(COBALT_SCRIPT_USING_V8C_ARRAY)
#undef COBALT_SCRIPT_USING_V8C_ARRAY
-#define COBALT_SCRIPT_CONVERSION_BOILERPLATE(array, ctype) \
- template <> \
- struct TypeTraits<array> { \
- using ConversionType = V8cUserObjectHolder<V8c##array>; \
- using ReturnType = const ScriptValue<array>*; \
- }; \
- \
- inline void ToJSValue(v8::Isolate* isolate, \
- const ScriptValue<array>* array_value, \
- v8::Local<v8::Value>* out_value) { \
- if (!array_value) { \
- *out_value = v8::Null(isolate); \
- return; \
- } \
- const auto* v8c_array_value = \
- base::polymorphic_downcast<const V8cUserObjectHolder<V8c##array>*>( \
- array_value); \
- *out_value = v8c_array_value->v8_value(); \
- } \
- \
- inline void FromJSValue(v8::Isolate* isolate, v8::Local<v8::Value> value, \
- int conversion_flags, \
- ExceptionState* exception_state, \
- V8cUserObjectHolder<V8c##array>* out_array) { \
- DCHECK_EQ(0, conversion_flags); \
- DCHECK(out_array); \
- if (!value->IsObject()) { \
- exception_state->SetSimpleException(kNotObjectType); \
- return; \
- } \
- if (!value->Is##array()) { \
- exception_state->SetSimpleException(kTypeError, \
- "Expected object of type array"); \
- return; \
- } \
- *out_array = std::move(V8cUserObjectHolder<V8c##array>(isolate, value)); \
+#define COBALT_SCRIPT_CONVERSION_BOILERPLATE(array, ctype) \
+ template <> \
+ struct TypeTraits<array> { \
+ using ConversionType = V8cUserObjectHolder<V8c##array>; \
+ using ReturnType = const ScriptValue<array>*; \
+ }; \
+ \
+ inline void ToJSValue(v8::Isolate* isolate, \
+ const ScriptValue<array>* array_value, \
+ v8::Local<v8::Value>* out_value) { \
+ if (!array_value) { \
+ *out_value = v8::Null(isolate); \
+ return; \
+ } \
+ const auto* v8c_array_value = \
+ base::polymorphic_downcast<const V8cUserObjectHolder<V8c##array>*>( \
+ array_value); \
+ *out_value = v8c_array_value->v8_value(); \
+ } \
+ \
+ inline void FromJSValue(v8::Isolate* isolate, v8::Local<v8::Value> value, \
+ int conversion_flags, \
+ ExceptionState* exception_state, \
+ V8cUserObjectHolder<V8c##array>* out_array) { \
+ DCHECK_EQ(0, conversion_flags); \
+ DCHECK(out_array); \
+ if (!value->IsObject()) { \
+ exception_state->SetSimpleException(kNotObjectType); \
+ return; \
+ } \
+ if (!value->Is##array()) { \
+ exception_state->SetSimpleException(kTypeError, \
+ "Expected object of type array"); \
+ return; \
+ } \
+ *out_array = V8cUserObjectHolder<V8c##array>(isolate, value); \
}
COBALT_SCRIPT_TYPED_ARRAY_LIST(COBALT_SCRIPT_CONVERSION_BOILERPLATE)
#undef COBALT_SCRIPT_CONVERSION_BOILERPLATE
diff --git a/cobalt/site/docs/development/setup-android.md b/cobalt/site/docs/development/setup-android.md
index 2c8bdb5..0382b42 100644
--- a/cobalt/site/docs/development/setup-android.md
+++ b/cobalt/site/docs/development/setup-android.md
@@ -17,6 +17,15 @@
1. Download and install [Android Studio](https://developer.android.com/studio/).
+1. To enable parallel gradle builds, add the following to your `~/.bashrc`:
+
+ ```
+ export COBALT_GRADLE_BUILD_COUNT=4
+ ```
+
+ Where 4 is the number of parallel threads. You can adjust the number of
+ parallel threads according to how your workstation performs.
+
1. Run `cobalt/build/gn.py -p android-x86` to configure the Cobalt build,
which also installs the SDK and NDK. (This step will have to be repeated
with 'android-arm' or 'android-arm64' to target those architectures.) The
@@ -214,6 +223,15 @@
instead of 'cobalt'. Then you can set breakpoints, etc. in the test the same as
when debugging Cobalt.
+## Debugging (Terminal)
+
+Use `adb logcat` while Cobalt is running, or use `adb bugreport` shortly after
+exiting to view Android logs. You will need to filter or search for
+Cobalt-related output.
+
+As with the Linux build, use the `debug`, `devel`, or `qa` configs to trace
+Cobalt's callstacks.
+
## Removing the Cobalt Android Environment
1. Unset ANDROID_HOME and or ANDROID_NDK_HOME in your shell and in .bashrc
diff --git a/cobalt/site/docs/development/setup-linux.md b/cobalt/site/docs/development/setup-linux.md
index 8f570d6..190cac0 100644
--- a/cobalt/site/docs/development/setup-linux.md
+++ b/cobalt/site/docs/development/setup-linux.md
@@ -186,6 +186,14 @@
</tr>
</table>
+## Debugging Cobalt
+
+`debug`, `devel`, and `qa` configs of Cobalt expose a feature enabling
+developers to trace Cobalt's callstacks per-thread. This is not only a great way
+to debug application performance, but also a great way to debug issues and
+better understand Cobalt's execution flow in general.
+
+Simply build and run one of these configs and observe the terminal output.
<!--
<aside class="note">
<b>Note:</b> If you plan to upload reviews to the Cobalt repository, you
diff --git a/cobalt/updater/BUILD.gn b/cobalt/updater/BUILD.gn
index da5cd31..94e7ae6 100644
--- a/cobalt/updater/BUILD.gn
+++ b/cobalt/updater/BUILD.gn
@@ -100,9 +100,11 @@
target(gtest_target_type, "updater_test") {
testonly = true
+ has_pedantic_warnings = true
sources = [
"//starboard/common/test_main.cc",
+ "configurator_test.cc",
"utils_test.cc",
]
diff --git a/cobalt/updater/configurator.cc b/cobalt/updater/configurator.cc
index 033152a..3383817 100644
--- a/cobalt/updater/configurator.cc
+++ b/cobalt/updater/configurator.cc
@@ -32,6 +32,8 @@
const int kDelayOneMinute = 60;
const int kDelayOneHour = kDelayOneMinute * 60;
const char kDefaultUpdaterChannel[] = "prod";
+const char kOmahaCobaltTrunkAppID[] = "{A9557415-DDCD-4948-8113-C643EFCF710C}";
+const char kOmahaCobaltAppID[] = "{6D4E53F3-CC64-4CB8-B6BD-AB0B8F300E1C}";
std::string GetDeviceProperty(SbSystemPropertyId id) {
const size_t kSystemPropertyMaxLength = 1024;
@@ -221,9 +223,17 @@
std::vector<uint8_t> Configurator::GetRunActionKeyHash() const { return {}; }
+std::string Configurator::GetAppGuidHelper(const std::string& version) {
+ if (version.find(".lts.") != std::string::npos &&
+ version.find(".master.") == std::string::npos) {
+ return kOmahaCobaltAppID;
+ }
+ return kOmahaCobaltTrunkAppID;
+}
+
std::string Configurator::GetAppGuid() const {
- // Omaha console app id for trunk
- return "{A9557415-DDCD-4948-8113-C643EFCF710C}";
+ const std::string version(COBALT_VERSION);
+ return GetAppGuidHelper(version);
}
std::unique_ptr<update_client::ProtocolHandlerFactory>
diff --git a/cobalt/updater/configurator.h b/cobalt/updater/configurator.h
index 630861a..992f176 100644
--- a/cobalt/updater/configurator.h
+++ b/cobalt/updater/configurator.h
@@ -101,6 +101,8 @@
bool GetUseCompressedUpdates() const override;
void SetUseCompressedUpdates(bool use_compressed_updates) override;
+ // Added for testing purposes.
+ static std::string GetAppGuidHelper(const std::string&);
private:
friend class base::RefCountedThreadSafe<Configurator>;
diff --git a/cobalt/updater/configurator_test.cc b/cobalt/updater/configurator_test.cc
new file mode 100644
index 0000000..cba7ccf
--- /dev/null
+++ b/cobalt/updater/configurator_test.cc
@@ -0,0 +1,58 @@
+// Copyright 2022 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "cobalt/updater/configurator.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+const char kOmahaCobaltTrunkAppID[] = "{A9557415-DDCD-4948-8113-C643EFCF710C}";
+const char kOmahaCobaltAppID[] = "{6D4E53F3-CC64-4CB8-B6BD-AB0B8F300E1C}";
+} // namespace
+
+namespace cobalt {
+namespace updater {
+
+class ConfiguratorTest : public testing::Test {
+ protected:
+ ConfiguratorTest() {}
+ ~ConfiguratorTest() {}
+};
+
+TEST_F(ConfiguratorTest, GetAppGuidReturnsTrunkIdWithVersionMaster) {
+ CHECK_EQ(cobalt::updater::Configurator::GetAppGuidHelper("23.master.0"),
+ kOmahaCobaltTrunkAppID);
+}
+
+TEST_F(ConfiguratorTest, GetAppGuidReturnsTrunkIdWithVersionMain) {
+ CHECK_EQ(cobalt::updater::Configurator::GetAppGuidHelper("23.main.0"),
+ kOmahaCobaltTrunkAppID);
+}
+
+TEST_F(ConfiguratorTest, GetAppGuidReturnsProdIdWithVersionLts) {
+ CHECK_EQ(cobalt::updater::Configurator::GetAppGuidHelper("23.lts.0"),
+ kOmahaCobaltAppID);
+}
+
+TEST_F(ConfiguratorTest, GetAppGuidReturnsTrunkIdWithVersionEmpty) {
+ CHECK_EQ(cobalt::updater::Configurator::GetAppGuidHelper(""),
+ kOmahaCobaltTrunkAppID);
+}
+
+TEST_F(ConfiguratorTest, GetAppGuidReturnsTrunkIdWithVersionMasterLts) {
+ CHECK_EQ(cobalt::updater::Configurator::GetAppGuidHelper("23.master.lts.0"),
+ kOmahaCobaltTrunkAppID);
+}
+
+} // namespace updater
+} // namespace cobalt
diff --git a/cobalt/web/agent.cc b/cobalt/web/agent.cc
index f52e113..f44a345 100644
--- a/cobalt/web/agent.cc
+++ b/cobalt/web/agent.cc
@@ -19,6 +19,7 @@
#include <utility>
#include "base/observer_list.h"
+#include "base/threading/thread_checker.h"
#include "base/trace_event/trace_event.h"
#include "cobalt/loader/fetcher_factory.h"
#include "cobalt/loader/script_loader_factory.h"
@@ -49,7 +50,7 @@
namespace {
class Impl : public Context {
public:
- explicit Impl(const Agent::Options& options);
+ Impl(const std::string& name, const Agent::Options& options);
virtual ~Impl();
void AddEnvironmentSettingsChangeObserver(
@@ -222,7 +223,8 @@
environment_settings_change_observers_;
};
-Impl::Impl(const Agent::Options& options) : name_(options.name) {
+Impl::Impl(const std::string& name, const Agent::Options& options)
+ : name_(name) {
TRACE_EVENT0("cobalt::web", "Agent::Impl::Impl()");
service_worker_jobs_ = options.service_worker_jobs;
platform_info_ = options.platform_info;
@@ -235,7 +237,7 @@
DCHECK(fetcher_factory_);
script_loader_factory_.reset(new loader::ScriptLoaderFactory(
- options.name.c_str(), fetcher_factory_.get(), options.thread_priority));
+ name.c_str(), fetcher_factory_.get(), options.thread_priority));
DCHECK(script_loader_factory_);
javascript_engine_ =
@@ -469,9 +471,31 @@
void Agent::WillDestroyCurrentMessageLoop() { context_.reset(); }
-Agent::Agent(const Options& options, InitializeCallback initialize_callback,
- DestructionObserver* destruction_observer)
- : thread_(options.name) {
+Agent::Agent(const std::string& name) : thread_(name) {}
+
+void Agent::Stop() {
+ DCHECK(message_loop());
+ DCHECK(thread_.IsRunning());
+
+ if (context() && context()->service_worker_jobs()) {
+ context()->service_worker_jobs()->UnregisterWebContext(context());
+ }
+
+ // Ensure that the destruction observer got added before stopping the thread.
+ destruction_observer_added_.Wait();
+ // Stop the thread. This will cause the destruction observer to be notified.
+ thread_.Stop();
+}
+
+Agent::~Agent() {
+ DCHECK(!thread_.IsRunning());
+ if (thread_.IsRunning()) {
+ Stop();
+ }
+}
+
+void Agent::Run(const Options& options, InitializeCallback initialize_callback,
+ DestructionObserver* destruction_observer) {
// Start the dedicated thread and create the internal implementation
// object on that thread.
base::Thread::Options thread_options(base::MessageLoop::TYPE_DEFAULT,
@@ -481,8 +505,9 @@
DCHECK(message_loop());
message_loop()->task_runner()->PostTask(
- FROM_HERE, base::Bind(&Agent::Initialize, base::Unretained(this), options,
- initialize_callback));
+ FROM_HERE,
+ base::Bind(&Agent::InitializeTaskInThread, base::Unretained(this),
+ options, initialize_callback));
if (destruction_observer) {
message_loop()->task_runner()->PostTask(
@@ -507,30 +532,17 @@
base::Unretained(&destruction_observer_added_)));
}
-Agent::~Agent() {
- DCHECK(message_loop());
- DCHECK(thread_.IsRunning());
-
- if (context() && context()->service_worker_jobs()) {
- context()->service_worker_jobs()->UnregisterWebContext(context());
- }
-
- // Ensure that the destruction observer got added before stopping the thread.
- destruction_observer_added_.Wait();
- // Stop the thread. This will cause the destruction observer to be notified.
- thread_.Stop();
-}
-
-void Agent::Initialize(const Options& options,
- InitializeCallback initialize_callback) {
+void Agent::InitializeTaskInThread(const Options& options,
+ InitializeCallback initialize_callback) {
DCHECK_EQ(base::MessageLoop::current(), message_loop());
- context_.reset(CreateContext(options, thread_.message_loop()));
+ context_.reset(
+ CreateContext(thread_.thread_name(), options, thread_.message_loop()));
initialize_callback.Run(context_.get());
}
-Context* Agent::CreateContext(const Options& options,
+Context* Agent::CreateContext(const std::string& name, const Options& options,
base::MessageLoop* message_loop) {
- auto* context = new Impl(options);
+ auto* context = new Impl(name, options);
context->set_message_loop(message_loop);
if (options.service_worker_jobs) {
options.service_worker_jobs->RegisterWebContext(context);
diff --git a/cobalt/web/agent.h b/cobalt/web/agent.h
index 956a6f6..aa48bb1 100644
--- a/cobalt/web/agent.h
+++ b/cobalt/web/agent.h
@@ -40,19 +40,12 @@
class Agent : public base::MessageLoop::DestructionObserver {
public:
struct Options {
- explicit Options(const std::string name) : name(name) {}
typedef base::Callback<scoped_refptr<script::Wrappable>(
- script::EnvironmentSettings*)>
+ web::EnvironmentSettings*)>
CreateObjectFunction;
typedef base::hash_map<std::string, CreateObjectFunction>
InjectedGlobalObjectAttributes;
- // The name of the Web Agent. This is useful for debugging purposes as
- // in the case where multiple Web Agent objects exist, it can be used to
- // differentiate which objects belong to which Web Agent. It is used
- // to name some CVals.
- std::string name;
-
// Specifies the priority of the web agent's thread. This is the thread
// that is responsible for executing JavaScript.
base::ThreadPriority thread_priority = base::ThreadPriority::NORMAL;
@@ -83,14 +76,17 @@
JavaScriptHeapStatisticsCallback;
typedef base::Callback<void(Context*)> InitializeCallback;
- Agent(const Options& options, InitializeCallback initialize_callback,
- DestructionObserver* destruction_observer = nullptr);
+ explicit Agent(const std::string& name);
~Agent();
- static Context* CreateContext(const Options& options,
+ void Run(const Options& options, InitializeCallback initialize_callback,
+ DestructionObserver* destruction_observer = nullptr);
+ void Stop();
+
+ static Context* CreateContext(const std::string& name, const Options& options,
base::MessageLoop* message_loop = nullptr);
static Context* CreateContext(const std::string& name) {
- return CreateContext(Options(name));
+ return CreateContext(name, Options());
}
Context* context() {
@@ -118,8 +114,8 @@
private:
// Called by the constructor to create the private implementation object and
// perform any other initialization required on the dedicated thread.
- void Initialize(const Options& options,
- InitializeCallback initialize_callback);
+ void InitializeTaskInThread(const Options& options,
+ InitializeCallback initialize_callback);
// The thread created and owned by this Web Agent.
// All sub-objects of this object are created on this thread, and all public
diff --git a/cobalt/web/blob_test.cc b/cobalt/web/blob_test.cc
index f3cb1b3..6ddc919 100644
--- a/cobalt/web/blob_test.cc
+++ b/cobalt/web/blob_test.cc
@@ -206,7 +206,7 @@
INSTANTIATE_TEST_CASE_P(
BlobTestsWithJavaScript, BlobTestWithJavaScript,
- ::testing::ValuesIn(testing::TestWebWithJavaScript::GetWorkerTypes()),
+ ::testing::ValuesIn(testing::TestWebWithJavaScript::GetWebTypes()),
testing::TestWebWithJavaScript::GetTypeName);
diff --git a/cobalt/web/csp_violation_reporter.cc b/cobalt/web/csp_violation_reporter.cc
index 2cb1951..63d2cbd 100644
--- a/cobalt/web/csp_violation_reporter.cc
+++ b/cobalt/web/csp_violation_reporter.cc
@@ -134,22 +134,16 @@
ViolationEvent violation_data;
GatherSecurityPolicyViolationEventData(global_, violation_info,
&violation_data);
+ EventTarget* target = global_;
if (global_->IsWindow()) {
- global_->AsWindow()->document()->DispatchEvent(
- new SecurityPolicyViolationEvent(
- violation_data.document_uri, violation_data.referrer,
- violation_data.blocked_uri, violation_data.violated_directive,
- violation_data.effective_directive, violation_data.original_policy,
- violation_data.source_file, violation_data.status_code,
- violation_data.line_number, violation_data.column_number));
- } else {
- global_->DispatchEvent(new SecurityPolicyViolationEvent(
- violation_data.document_uri, violation_data.referrer,
- violation_data.blocked_uri, violation_data.violated_directive,
- violation_data.effective_directive, violation_data.original_policy,
- violation_data.source_file, violation_data.status_code,
- violation_data.line_number, violation_data.column_number));
+ target = global_->AsWindow()->document();
}
+ target->DispatchEvent(new SecurityPolicyViolationEvent(
+ violation_data.document_uri, violation_data.referrer,
+ violation_data.blocked_uri, violation_data.violated_directive,
+ violation_data.effective_directive, violation_data.original_policy,
+ violation_data.source_file, violation_data.status_code,
+ violation_data.line_number, violation_data.column_number));
if (violation_info.endpoints.empty() || post_sender_.is_null()) {
return;
diff --git a/cobalt/web/custom_event_test.cc b/cobalt/web/custom_event_test.cc
index 9bf87ae..5d1bded 100644
--- a/cobalt/web/custom_event_test.cc
+++ b/cobalt/web/custom_event_test.cc
@@ -109,7 +109,7 @@
INSTANTIATE_TEST_CASE_P(
CustomEventTestsWithJavaScript, CustomEventTestWithJavaScript,
- ::testing::ValuesIn(testing::TestWebWithJavaScript::GetWorkerTypes()),
+ ::testing::ValuesIn(testing::TestWebWithJavaScript::GetWebTypes()),
testing::TestWebWithJavaScript::GetTypeName);
} // namespace web
diff --git a/cobalt/web/message_event.cc b/cobalt/web/message_event.cc
index a6e8888..b38a1fe 100644
--- a/cobalt/web/message_event.cc
+++ b/cobalt/web/message_event.cc
@@ -29,17 +29,36 @@
#include "starboard/memory.h"
#include "v8/include/v8.h"
+namespace cobalt {
+namespace web {
+
namespace {
const char* const kResponseTypes[] = {"text", "blob", "arraybuffer", "any"};
-COMPILE_ASSERT(arraysize(kResponseTypes) ==
- cobalt::web::MessageEvent::kResponseTypeMax,
+COMPILE_ASSERT(arraysize(kResponseTypes) == MessageEvent::kResponseTypeMax,
enum_and_array_size_mismatch);
} // namespace
-namespace cobalt {
-namespace web {
+MessageEvent::MessageEvent(const std::string& type,
+ const MessageEventInit& init_dict)
+ : Event(type, init_dict), response_type_(kAny) {
+ if (init_dict.has_data() && init_dict.data()) {
+ data_ = script::SerializeScriptValue(*(init_dict.data()));
+ }
+ if (init_dict.has_origin()) {
+ origin_ = init_dict.origin();
+ }
+ if (init_dict.has_last_event_id()) {
+ last_event_id_ = init_dict.last_event_id();
+ }
+ if (init_dict.has_source()) {
+ source_ = init_dict.source();
+ }
+ if (init_dict.has_ports()) {
+ ports_ = init_dict.ports();
+ }
+}
// static
std::string MessageEvent::GetResponseTypeAsString(
@@ -63,7 +82,7 @@
MessageEvent::Response MessageEvent::data(
script::EnvironmentSettings* settings) const {
if (!data_ && !data_io_buffer_) {
- return Response("");
+ return Response(script::Handle<script::ValueHandle>());
}
script::GlobalEnvironment* global_environment = nullptr;
@@ -71,7 +90,7 @@
response_type_ == kAny) {
DCHECK(settings);
global_environment =
- base::polymorphic_downcast<web::EnvironmentSettings*>(settings)
+ base::polymorphic_downcast<EnvironmentSettings*>(settings)
->context()
->global_environment();
DCHECK(global_environment);
@@ -92,8 +111,7 @@
std::move(buffer_copy);
if (response_type_ == kBlob) {
DCHECK(settings);
- scoped_refptr<web::Blob> blob =
- new web::Blob(settings, response_buffer);
+ scoped_refptr<Blob> blob = new Blob(settings, response_buffer);
return Response(blob);
}
return Response(response_buffer);
@@ -101,12 +119,14 @@
case kAny: {
v8::Isolate* isolate = global_environment->isolate();
script::v8c::EntryScope entry_scope(isolate);
+ DCHECK(isolate);
+ DCHECK(data_);
return Response(script::Handle<script::ValueHandle>(
std::move(script::DeserializeScriptValue(isolate, *data_))));
}
default:
NOTREACHED() << "Invalid response type.";
- return Response("");
+ return Response(script::Handle<script::ValueHandle>());
}
}
diff --git a/cobalt/web/message_event.h b/cobalt/web/message_event.h
index b39a198..ba81c1f 100644
--- a/cobalt/web/message_event.h
+++ b/cobalt/web/message_event.h
@@ -20,28 +20,32 @@
#include <string>
#include <utility>
-#include "base/memory/ref_counted.h"
+#include "base/memory/scoped_refptr.h"
#include "base/strings/string_piece.h"
#include "cobalt/base/token.h"
#include "cobalt/script/array_buffer.h"
+#include "cobalt/script/sequence.h"
#include "cobalt/script/union_type.h"
-#include "cobalt/script/v8c/v8c_value_handle.h"
-#include "cobalt/script/wrappable.h"
+#include "cobalt/script/value_handle.h"
#include "cobalt/web/blob.h"
#include "cobalt/web/event.h"
+#include "cobalt/web/event_target.h"
#include "cobalt/web/message_event_init.h"
+#include "cobalt/web/message_port.h"
#include "net/base/io_buffer.h"
#include "v8/include/v8.h"
namespace cobalt {
namespace web {
-class MessageEvent : public web::Event {
+class MessageEvent : public Event {
public:
- typedef script::UnionType4<std::string, scoped_refptr<web::Blob>,
+ typedef script::UnionType4<std::string, scoped_refptr<Blob>,
script::Handle<script::ArrayBuffer>,
script::Handle<script::ValueHandle>>
Response;
+
+
// These response types are ordered in the likelihood of being used.
// Keeping them in expected order will help make code faster.
enum ResponseType { kText, kBlob, kArrayBuffer, kAny, kResponseTypeMax };
@@ -56,14 +60,26 @@
MessageEvent(base::Token type, ResponseType response_type,
const scoped_refptr<net::IOBufferWithSize>& data)
: Event(type), response_type_(response_type), data_io_buffer_(data) {}
- MessageEvent(const std::string& type, const web::MessageEventInit& init_dict)
- : Event(type, init_dict),
- response_type_(kAny),
- data_(script::SerializeScriptValue(*(init_dict.data()))) {}
+ MessageEvent(const std::string& type, const MessageEventInit& init_dict);
Response data(script::EnvironmentSettings* settings = nullptr) const;
+ const std::string& origin() const { return origin_; }
+ const std::string& last_event_id() const { return last_event_id_; }
+ const scoped_refptr<EventTarget>& source() const { return source_; }
+ script::Sequence<scoped_refptr<MessagePort>> ports() const { return ports_; }
// These helper functions are custom, and not in any spec.
+ void set_origin(const std::string& origin) { origin_ = origin; }
+ void set_last_event_id(const std::string& last_event_id) {
+ last_event_id_ = last_event_id;
+ }
+ void set_source(const scoped_refptr<EventTarget>& source) {
+ source_ = source;
+ }
+ void set_ports(script::Sequence<scoped_refptr<MessagePort>> ports) {
+ ports_ = ports;
+ }
+
static std::string GetResponseTypeAsString(const ResponseType response_type);
static MessageEvent::ResponseType GetResponseType(base::StringPiece to_match);
@@ -73,6 +89,10 @@
ResponseType response_type_ = kText;
scoped_refptr<net::IOBufferWithSize> data_io_buffer_;
std::unique_ptr<script::DataBuffer> data_;
+ std::string origin_;
+ std::string last_event_id_;
+ scoped_refptr<EventTarget> source_;
+ script::Sequence<scoped_refptr<MessagePort>> ports_;
};
} // namespace web
diff --git a/cobalt/web/message_event.idl b/cobalt/web/message_event.idl
index 0e15ab7..909fb66 100644
--- a/cobalt/web/message_event.idl
+++ b/cobalt/web/message_event.idl
@@ -20,4 +20,9 @@
Constructor(DOMString type, optional MessageEventInit eventInitDict)
] interface MessageEvent : Event {
[CallWith = EnvironmentSettings] readonly attribute any data;
+ readonly attribute USVString origin;
+ readonly attribute DOMString lastEventId;
+ readonly attribute EventTarget? source;
+ // TODO(b/236750294): Make this be FrozenArray<MessagePort> when available.
+ readonly attribute sequence<MessagePort> ports;
};
diff --git a/cobalt/web/message_event_init.idl b/cobalt/web/message_event_init.idl
index 9ccf914..edf7e7c 100644
--- a/cobalt/web/message_event_init.idl
+++ b/cobalt/web/message_event_init.idl
@@ -12,8 +12,12 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-// https://www.w3.org/TR/html50/webappapis.html#erroreventinit
+// https://html.spec.whatwg.org/multipage/comms.html#messageeventinit
dictionary MessageEventInit : EventInit {
- any data = null;
+ any data;
+ USVString origin = "";
+ DOMString lastEventId = "";
+ EventTarget? source;
+ sequence<MessagePort> ports;
};
diff --git a/cobalt/web/message_event_test.cc b/cobalt/web/message_event_test.cc
index d8f6d6d..93893b2 100644
--- a/cobalt/web/message_event_test.cc
+++ b/cobalt/web/message_event_test.cc
@@ -19,11 +19,14 @@
#include "base/bind.h"
#include "base/logging.h"
-#include "cobalt/dom/testing/test_with_javascript.h"
+#include "base/memory/scoped_refptr.h"
#include "cobalt/script/v8c/entry_scope.h"
#include "cobalt/script/value_handle.h"
+#include "cobalt/web/blob.h"
#include "cobalt/web/message_event_init.h"
#include "cobalt/web/testing/gtest_workarounds.h"
+#include "cobalt/web/testing/test_with_javascript.h"
+#include "net/base/io_buffer.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
@@ -31,8 +34,7 @@
namespace web {
namespace {
-class MessageEventTestWithJavaScript : public dom::testing::TestWithJavaScript {
-};
+class MessageEventTestWithJavaScript : public testing::TestWebWithJavaScript {};
} // namespace
TEST(MessageEventTest, ConstructorWithEventTypeString) {
@@ -49,19 +51,44 @@
EXPECT_FALSE(event->propagation_stopped());
EXPECT_FALSE(event->immediate_propagation_stopped());
MessageEvent::Response event_data = event->data();
- EXPECT_TRUE(event_data.IsType<std::string>());
- EXPECT_EQ("", event_data.AsType<std::string>());
+ EXPECT_TRUE(event_data.IsType<script::Handle<script::ValueHandle>>());
+ EXPECT_TRUE(
+ event_data.AsType<script::Handle<script::ValueHandle>>().IsEmpty());
}
-TEST_F(MessageEventTestWithJavaScript,
- ConstructorWithEventTypeAndDefaultInitDict) {
- MessageEventInit init;
- base::Optional<script::ValueHandleHolder::Reference> reference;
- EvaluateScript("'data_value'", window(), &reference);
- init.set_data(&(reference->referenced_value()));
- scoped_refptr<MessageEvent> event = new MessageEvent("mytestevent", init);
+TEST(MessageEventTest, ConstructorWithText) {
+ std::string message_string("ConstructorWithTextMessageData");
+ scoped_refptr<net::IOBufferWithSize> data =
+ base::MakeRefCounted<net::IOBufferWithSize>(message_string.size());
+ memcpy(data->data(), message_string.c_str(), message_string.size());
+ scoped_refptr<MessageEvent> event =
+ new MessageEvent(base::Tokens::message(), MessageEvent::kText, data);
- EXPECT_EQ("mytestevent", event->type());
+ EXPECT_EQ("message", event->type());
+ EXPECT_EQ(NULL, event->target().get());
+ EXPECT_EQ(NULL, event->current_target().get());
+ EXPECT_EQ(Event::kNone, event->event_phase());
+ EXPECT_FALSE(event->bubbles());
+ EXPECT_FALSE(event->cancelable());
+ EXPECT_FALSE(event->default_prevented());
+ EXPECT_FALSE(event->IsBeingDispatched());
+ EXPECT_FALSE(event->propagation_stopped());
+ EXPECT_FALSE(event->immediate_propagation_stopped());
+ MessageEvent::Response event_data = event->data();
+ EXPECT_TRUE(event_data.IsType<std::string>());
+ EXPECT_EQ(message_string.size(), event_data.AsType<std::string>().size());
+ EXPECT_EQ("ConstructorWithTextMessageData", event_data.AsType<std::string>());
+}
+
+TEST_P(MessageEventTestWithJavaScript, ConstructorWithBlob) {
+ std::string message_string("ConstructorWithBlobMessageData");
+ scoped_refptr<net::IOBufferWithSize> data =
+ base::MakeRefCounted<net::IOBufferWithSize>(message_string.size());
+ memcpy(data->data(), message_string.c_str(), message_string.size());
+ scoped_refptr<MessageEvent> event =
+ new MessageEvent(base::Tokens::message(), MessageEvent::kBlob, data);
+
+ EXPECT_EQ("message", event->type());
EXPECT_EQ(NULL, event->target().get());
EXPECT_EQ(NULL, event->current_target().get());
EXPECT_EQ(Event::kNone, event->event_phase());
@@ -72,7 +99,139 @@
EXPECT_FALSE(event->propagation_stopped());
EXPECT_FALSE(event->immediate_propagation_stopped());
MessageEvent::Response event_data =
- event->data(window()->environment_settings());
+ event->data(web_context()->environment_settings());
+ EXPECT_TRUE(event_data.IsType<scoped_refptr<Blob>>());
+ EXPECT_EQ(message_string.size(),
+ event_data.AsType<scoped_refptr<Blob>>()->size());
+ EXPECT_EQ("ConstructorWithBlobMessageData",
+ std::string(reinterpret_cast<const char*>(
+ event_data.AsType<scoped_refptr<Blob>>()->data()),
+ static_cast<size_t>(
+ event_data.AsType<scoped_refptr<Blob>>()->size())));
+ EXPECT_TRUE(event_data.AsType<scoped_refptr<Blob>>()->type().empty());
+}
+
+TEST_P(MessageEventTestWithJavaScript, ConstructorWithArrayBuffer) {
+ std::string message_string("ConstructorWithArrayBufferMessageData");
+ scoped_refptr<net::IOBufferWithSize> data =
+ base::MakeRefCounted<net::IOBufferWithSize>(message_string.size());
+ memcpy(data->data(), message_string.c_str(), message_string.size());
+ scoped_refptr<MessageEvent> event = new MessageEvent(
+ base::Tokens::message(), MessageEvent::kArrayBuffer, data);
+
+ EXPECT_EQ("message", event->type());
+ EXPECT_EQ(NULL, event->target().get());
+ EXPECT_EQ(NULL, event->current_target().get());
+ EXPECT_EQ(Event::kNone, event->event_phase());
+ EXPECT_FALSE(event->bubbles());
+ EXPECT_FALSE(event->cancelable());
+ EXPECT_FALSE(event->default_prevented());
+ EXPECT_FALSE(event->IsBeingDispatched());
+ EXPECT_FALSE(event->propagation_stopped());
+ EXPECT_FALSE(event->immediate_propagation_stopped());
+ MessageEvent::Response event_data =
+ event->data(web_context()->environment_settings());
+ EXPECT_TRUE(event_data.IsType<script::Handle<script::ArrayBuffer>>());
+ EXPECT_EQ(
+ message_string.size(),
+ event_data.AsType<script::Handle<script::ArrayBuffer>>()->ByteLength());
+ EXPECT_EQ(
+ "ConstructorWithArrayBufferMessageData",
+ std::string(
+ reinterpret_cast<const char*>(
+ event_data.AsType<script::Handle<script::ArrayBuffer>>()->Data()),
+ static_cast<size_t>(
+ event_data.AsType<script::Handle<script::ArrayBuffer>>()
+ ->ByteLength())));
+}
+
+TEST_P(MessageEventTestWithJavaScript, ConstructorWithAny) {
+ base::Optional<script::ValueHandleHolder::Reference> reference;
+ EvaluateScript("'ConstructorWithAnyMessageData'", &reference);
+ std::unique_ptr<script::DataBuffer> data(
+ script::SerializeScriptValue(reference->referenced_value()));
+ EXPECT_NE(nullptr, data.get());
+ EXPECT_NE(nullptr, data->ptr);
+ EXPECT_GT(data->size, 0U);
+ scoped_refptr<MessageEvent> event =
+ new MessageEvent(base::Tokens::message(), std::move(data));
+
+ EXPECT_EQ("message", event->type());
+ EXPECT_EQ(NULL, event->target().get());
+ EXPECT_EQ(NULL, event->current_target().get());
+ EXPECT_EQ(Event::kNone, event->event_phase());
+ EXPECT_FALSE(event->bubbles());
+ EXPECT_FALSE(event->cancelable());
+ EXPECT_FALSE(event->default_prevented());
+ EXPECT_FALSE(event->IsBeingDispatched());
+ EXPECT_FALSE(event->propagation_stopped());
+ EXPECT_FALSE(event->immediate_propagation_stopped());
+ MessageEvent::Response event_data =
+ event->data(web_context()->environment_settings());
+ EXPECT_TRUE(event_data.IsType<script::Handle<script::ValueHandle>>());
+ EXPECT_FALSE(
+ event_data.AsType<script::Handle<script::ValueHandle>>().IsEmpty());
+ auto script_value =
+ event_data.AsType<script::Handle<script::ValueHandle>>().GetScriptValue();
+ auto* isolate = script::GetIsolate(*script_value);
+ script::v8c::EntryScope entry_scope(isolate);
+ v8::Local<v8::Value> v8_value = script::GetV8Value(*script_value);
+ std::string actual =
+ *(v8::String::Utf8Value(isolate, v8_value.As<v8::String>()));
+ EXPECT_EQ("ConstructorWithAnyMessageData", actual);
+}
+
+TEST_P(MessageEventTestWithJavaScript,
+ ConstructorWithEventTypeAndDefaultInitDict) {
+ MessageEventInit init;
+ scoped_refptr<MessageEvent> event = new MessageEvent("mytestevent", init);
+
+ EXPECT_EQ("mytestevent", event->type());
+ EXPECT_EQ(nullptr, event->target().get());
+ EXPECT_EQ(nullptr, event->current_target().get());
+ EXPECT_EQ(Event::kNone, event->event_phase());
+ EXPECT_FALSE(event->bubbles());
+ EXPECT_FALSE(event->cancelable());
+ EXPECT_FALSE(event->default_prevented());
+ EXPECT_FALSE(event->IsBeingDispatched());
+ EXPECT_FALSE(event->propagation_stopped());
+ EXPECT_FALSE(event->immediate_propagation_stopped());
+
+ MessageEvent::Response event_data =
+ event->data(web_context()->environment_settings());
+ EXPECT_TRUE(event_data.IsType<script::Handle<script::ValueHandle>>());
+ EXPECT_TRUE(
+ event_data.AsType<script::Handle<script::ValueHandle>>().IsEmpty());
+
+ EXPECT_TRUE(event->origin().empty());
+ EXPECT_TRUE(event->last_event_id().empty());
+ EXPECT_EQ(nullptr, event->source().get());
+ EXPECT_TRUE(event->ports().empty());
+}
+
+TEST_P(MessageEventTestWithJavaScript, ConstructorWithEventTypeAndInitDict) {
+ MessageEventInit init;
+ base::Optional<script::ValueHandleHolder::Reference> reference;
+ EvaluateScript("'data_value'", &reference);
+ init.set_data(&(reference->referenced_value()));
+ init.set_origin("OriginString");
+ init.set_last_event_id("lastEventIdString");
+ init.set_source(web_context()->GetWindowOrWorkerGlobalScope());
+ scoped_refptr<MessageEvent> event = new MessageEvent("mytestevent", init);
+
+ EXPECT_EQ("mytestevent", event->type());
+ EXPECT_EQ(nullptr, event->target().get());
+ EXPECT_EQ(nullptr, event->current_target().get());
+ EXPECT_EQ(Event::kNone, event->event_phase());
+ EXPECT_FALSE(event->bubbles());
+ EXPECT_FALSE(event->cancelable());
+ EXPECT_FALSE(event->default_prevented());
+ EXPECT_FALSE(event->IsBeingDispatched());
+ EXPECT_FALSE(event->propagation_stopped());
+ EXPECT_FALSE(event->immediate_propagation_stopped());
+
+ MessageEvent::Response event_data =
+ event->data(web_context()->environment_settings());
EXPECT_TRUE(event_data.IsType<script::Handle<script::ValueHandle>>());
auto script_value =
event_data.AsType<script::Handle<script::ValueHandle>>().GetScriptValue();
@@ -82,24 +241,44 @@
std::string actual =
*(v8::String::Utf8Value(isolate, v8_value.As<v8::String>()));
EXPECT_EQ("data_value", actual);
+
+ EXPECT_EQ("OriginString", event->origin());
+ EXPECT_EQ("lastEventIdString", event->last_event_id());
+ EXPECT_EQ(web_context()->GetWindowOrWorkerGlobalScope(),
+ event->source().get());
+ EXPECT_TRUE(event->ports().empty());
}
-TEST_F(MessageEventTestWithJavaScript,
- ConstructorWithEventTypeAndErrorInitDict) {
+TEST_P(MessageEventTestWithJavaScript,
+ ConstructorWithEventTypeAndMessageEventInitDict) {
std::string result;
EXPECT_TRUE(
EvaluateScript("var event = new MessageEvent('dog', "
- " {'cancelable':true, "
- " 'data':'data_value'});"
+ " {cancelable: true, "
+ " origin: 'OriginValue',"
+ " lastEventId: 'LastEventIdValue',"
+ " source: this,"
+ " data: {value: 'data_value'},"
+ " }"
+ ");"
"if (event.type == 'dog' &&"
" event.bubbles == false &&"
" event.cancelable == true &&"
- " event.data == 'data_value') "
- " event.data;",
+ " event.origin == 'OriginValue' &&"
+ " event.lastEventId == 'LastEventIdValue' &&"
+ " event.source == this &&"
+ " event.ports.length == 0 &&"
+ " event.data.value == 'data_value') "
+ " event.data.value;",
&result))
<< "Failed to evaluate script.";
EXPECT_EQ("data_value", result);
}
+INSTANTIATE_TEST_CASE_P(
+ MessageEventTestsWithJavaScript, MessageEventTestWithJavaScript,
+ ::testing::ValuesIn(testing::TestWebWithJavaScript::GetWebTypes()),
+ testing::TestWebWithJavaScript::GetTypeName);
+
} // namespace web
} // namespace cobalt
diff --git a/cobalt/web/message_port.h b/cobalt/web/message_port.h
index 183e35a..9d53f49 100644
--- a/cobalt/web/message_port.h
+++ b/cobalt/web/message_port.h
@@ -29,7 +29,6 @@
#include "cobalt/web/context.h"
#include "cobalt/web/event_target.h"
#include "cobalt/web/event_target_listener_info.h"
-#include "cobalt/web/message_event.h"
namespace cobalt {
namespace web {
diff --git a/cobalt/web/message_port.idl b/cobalt/web/message_port.idl
index 86b9528..24bab52 100644
--- a/cobalt/web/message_port.idl
+++ b/cobalt/web/message_port.idl
@@ -17,7 +17,6 @@
interface MessagePort /* : EventTarget */ {
// [RaisesException]
void postMessage(any message);
- // void postMessage(USVString message, sequence<USVString> transfer);
// TODO: Support sequence<object>: b/218501774
// void postMessage(any message, sequence<object> transfer);
// TODO: Support overloads with dictionary parameter: b/218506730
diff --git a/cobalt/web/testing/test_with_javascript.h b/cobalt/web/testing/test_with_javascript.h
index f37276b..011ab7a 100644
--- a/cobalt/web/testing/test_with_javascript.h
+++ b/cobalt/web/testing/test_with_javascript.h
@@ -23,7 +23,6 @@
#include "cobalt/dom/testing/stub_window.h"
#include "cobalt/dom/window.h"
#include "cobalt/script/wrappable.h"
-#include "cobalt/web/window_or_worker_global_scope.h"
#include "cobalt/worker/testing/test_with_javascript.h"
namespace cobalt {
@@ -42,17 +41,14 @@
DCHECK(!this->worker_global_scope());
this->ClearWebContext();
window_.reset(new dom::testing::StubWindow());
+ window_->InitializeWindow();
}
}
- WindowOrWorkerGlobalScope* window_or_worker_global_scope() {
- return window_ ? window_->window().get() : this->worker_global_scope();
- }
-
- scoped_refptr<script::GlobalEnvironment> global_environment() override {
- if (window_) return window_->global_environment();
+ web::Context* web_context() const override {
+ if (window_) return window_->web_context();
return worker::testing::TestWithJavaScriptBase<
- TypeIdProvider>::global_environment();
+ TypeIdProvider>::web_context();
}
private:
@@ -66,7 +62,7 @@
public:
// Return a vector of values for all known worker types, to be used in the
// INSTANTIATE_TEST_CASE_P() declaration.
- static std::vector<base::TypeId> GetWorkerTypes() {
+ static std::vector<base::TypeId> GetWebTypes() {
std::vector<base::TypeId> worker_types =
worker::testing::TestWorkersWithJavaScript::GetWorkerTypes();
worker_types.push_back(base::GetTypeId<dom::Window>());
diff --git a/cobalt/web/url_test.cc b/cobalt/web/url_test.cc
index ee6f405..fa0dbcc 100644
--- a/cobalt/web/url_test.cc
+++ b/cobalt/web/url_test.cc
@@ -195,7 +195,7 @@
INSTANTIATE_TEST_CASE_P(
URLTestsWithJavaScript, URLTestWithJavaScript,
- ::testing::ValuesIn(testing::TestWebWithJavaScript::GetWorkerTypes()),
+ ::testing::ValuesIn(testing::TestWebWithJavaScript::GetWebTypes()),
testing::TestWebWithJavaScript::GetTypeName);
diff --git a/cobalt/web/url_utils.cc b/cobalt/web/url_utils.cc
index 462c6f4..c69bc2d 100644
--- a/cobalt/web/url_utils.cc
+++ b/cobalt/web/url_utils.cc
@@ -126,7 +126,8 @@
// https://www.w3.org/TR/2014/WD-url-1-20141209/#pre-update-steps
void URLUtils::RunPreUpdateSteps(const GURL& new_url,
const std::string& value) {
- DLOG(INFO) << "Update URL to " << new_url.possibly_invalid_spec();
+ DLOG(INFO) << "Update URL to "
+ << (value.empty() ? new_url.possibly_invalid_spec() : value);
// 1. If value is not given, let value be the result of serializing the
// associated url.
diff --git a/cobalt/webdriver/session_driver.cc b/cobalt/webdriver/session_driver.cc
index 1c45c01..b04aa70 100644
--- a/cobalt/webdriver/session_driver.cc
+++ b/cobalt/webdriver/session_driver.cc
@@ -14,6 +14,8 @@
#include "cobalt/webdriver/session_driver.h"
+#include <utility>
+
#include "base/logging.h"
#include "cobalt/base/log_message_handler.h"
@@ -56,13 +58,13 @@
logging_callback_id_(0) {
logging_callback_id_ = base::LogMessageHandler::GetInstance()->AddCallback(
base::Bind(&SessionDriver::LogMessageHandler, base::Unretained(this)));
- window_driver_ = create_window_driver_callback_.Run(GetUniqueWindowId());
+ RefreshWindowDriver();
}
void SessionDriver::RefreshWindowDriver() {
DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
- window_driver_ =
- create_window_driver_callback_.Run(window_driver_->window_id());
+ window_driver_ = create_window_driver_callback_.Run(
+ window_driver_ ? window_driver_->window_id() : GetUniqueWindowId());
}
SessionDriver::~SessionDriver() {
diff --git a/cobalt/worker/BUILD.gn b/cobalt/worker/BUILD.gn
index 8c0077a..cf05426 100644
--- a/cobalt/worker/BUILD.gn
+++ b/cobalt/worker/BUILD.gn
@@ -26,7 +26,9 @@
"dedicated_worker.h",
"dedicated_worker_global_scope.cc",
"dedicated_worker_global_scope.h",
+ "extendable_event.cc",
"extendable_event.h",
+ "extendable_message_event.cc",
"extendable_message_event.h",
"navigation_preload_manager.cc",
"navigation_preload_manager.h",
@@ -80,6 +82,7 @@
sources = [
"dedicated_worker_global_scope_test.cc",
+ "extendable_message_event_test.cc",
"service_worker_global_scope_test.cc",
"worker_global_scope_test.cc",
"worker_location_test.cc",
diff --git a/cobalt/worker/dedicated_worker.cc b/cobalt/worker/dedicated_worker.cc
index 0dff482..1daf030 100644
--- a/cobalt/worker/dedicated_worker.cc
+++ b/cobalt/worker/dedicated_worker.cc
@@ -58,7 +58,7 @@
// allow the page to start dedicated workers).
// 2. Let outside settings be the current settings object.
// 3. Parse the scriptURL argument relative to outside settings.
- Worker::Options options(kDedicatedWorkerName);
+ Worker::Options options;
const GURL& base_url = environment_settings()->base_url();
options.url = base_url.Resolve(script_url_);
@@ -83,7 +83,7 @@
options.web_options.service_worker_jobs =
options.outside_settings->context()->service_worker_jobs();
- worker_.reset(new Worker(options));
+ worker_.reset(new Worker(kDedicatedWorkerName, options));
// 10. Return worker.
}
diff --git a/cobalt/worker/extendable_event.cc b/cobalt/worker/extendable_event.cc
new file mode 100644
index 0000000..6b49b47
--- /dev/null
+++ b/cobalt/worker/extendable_event.cc
@@ -0,0 +1,83 @@
+// Copyright 2022 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "cobalt/worker/extendable_event.h"
+
+namespace cobalt {
+namespace worker {
+
+void ExtendableEvent::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 ExtendableEvent::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_) {
+ if (done_callback_) {
+ std::move(done_callback_).Run(has_rejected_promise_);
+ }
+ 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;
+}
+
+} // namespace worker
+} // namespace cobalt
diff --git a/cobalt/worker/extendable_event.h b/cobalt/worker/extendable_event.h
index e7d7a6a..051e034 100644
--- a/cobalt/worker/extendable_event.h
+++ b/cobalt/worker/extendable_event.h
@@ -44,9 +44,9 @@
class ExtendableEvent : public web::Event {
public:
explicit ExtendableEvent(const std::string& type) : Event(type) {}
- explicit ExtendableEvent(base::Token type,
- base::OnceCallback<void(bool)> done_callback =
- base::OnceCallback<void(bool)>())
+ ExtendableEvent(base::Token type,
+ base::OnceCallback<void(bool)> done_callback =
+ base::OnceCallback<void(bool)>())
: Event(type), done_callback_(std::move(done_callback)) {}
ExtendableEvent(const std::string& type, const ExtendableEventInit& init_dict)
: Event(type, init_dict) {}
@@ -54,65 +54,10 @@
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();
- }
+ script::ExceptionState* exception_state);
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_) {
- if (done_callback_) {
- std::move(done_callback_).Run(has_rejected_promise_);
- }
- 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;
- }
+ const script::Promise<script::ValueHandle*>* promise);
bool IsActive() {
// An ExtendableEvent object is said to be active when its timed out flag
diff --git a/cobalt/worker/extendable_event_init.idl b/cobalt/worker/extendable_event_init.idl
index d040bfb..5a8c5ed 100644
--- a/cobalt/worker/extendable_event_init.idl
+++ b/cobalt/worker/extendable_event_init.idl
@@ -14,6 +14,6 @@
// https://w3c.github.io/ServiceWorker/#dictdef-extendableeventinit
-dictionary ExtendableEventInit : EventInit{
+dictionary ExtendableEventInit : EventInit {
// Defined for the forward compatibility across the derived events
};
diff --git a/cobalt/worker/extendable_message_event.cc b/cobalt/worker/extendable_message_event.cc
new file mode 100644
index 0000000..200e2a6
--- /dev/null
+++ b/cobalt/worker/extendable_message_event.cc
@@ -0,0 +1,68 @@
+// Copyright 2022 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "cobalt/worker/extendable_message_event.h"
+
+#include <string>
+#include <utility>
+
+#include "cobalt/script/environment_settings.h"
+#include "cobalt/script/global_environment.h"
+#include "cobalt/script/v8c/entry_scope.h"
+#include "cobalt/script/value_handle.h"
+#include "cobalt/worker/extendable_message_event_init.h"
+#include "v8/include/v8.h"
+
+namespace cobalt {
+namespace worker {
+
+ExtendableMessageEvent::ExtendableMessageEvent(
+ const std::string& type, const ExtendableMessageEventInit& init_dict)
+ : ExtendableEvent(type, init_dict) {
+ if (init_dict.has_data() && init_dict.data()) {
+ DCHECK(init_dict.data());
+ data_ = script::SerializeScriptValue(*(init_dict.data()));
+ }
+ if (init_dict.has_origin()) {
+ origin_ = init_dict.origin();
+ }
+ if (init_dict.has_last_event_id()) {
+ last_event_id_ = init_dict.last_event_id();
+ }
+ if (init_dict.has_source()) {
+ source_ = init_dict.source();
+ }
+ if (init_dict.has_ports()) {
+ ports_ = init_dict.ports();
+ }
+}
+
+script::Handle<script::ValueHandle> ExtendableMessageEvent::data(
+ script::EnvironmentSettings* settings) const {
+ if (!settings) return script::Handle<script::ValueHandle>();
+ script::GlobalEnvironment* global_environment =
+ base::polymorphic_downcast<web::EnvironmentSettings*>(settings)
+ ->context()
+ ->global_environment();
+ DCHECK(global_environment);
+ v8::Isolate* isolate = global_environment->isolate();
+ script::v8c::EntryScope entry_scope(isolate);
+ DCHECK(isolate);
+ if (!data_) return script::Handle<script::ValueHandle>();
+ return script::Handle<script::ValueHandle>(
+ std::move(script::DeserializeScriptValue(isolate, *data_)));
+}
+
+} // namespace worker
+} // namespace cobalt
diff --git a/cobalt/worker/extendable_message_event.h b/cobalt/worker/extendable_message_event.h
index c6364a7..475be64 100644
--- a/cobalt/worker/extendable_message_event.h
+++ b/cobalt/worker/extendable_message_event.h
@@ -17,57 +17,71 @@
#include <memory>
#include <string>
+#include <utility>
+#include "base/memory/scoped_refptr.h"
#include "base/optional.h"
#include "cobalt/base/token.h"
+#include "cobalt/script/union_type.h"
#include "cobalt/script/value_handle.h"
#include "cobalt/script/wrappable.h"
+#include "cobalt/web/event_target.h"
#include "cobalt/web/message_port.h"
+#include "cobalt/worker/client.h"
#include "cobalt/worker/extendable_event.h"
#include "cobalt/worker/extendable_message_event_init.h"
+#include "cobalt/worker/service_worker.h"
namespace cobalt {
namespace worker {
class ExtendableMessageEvent : public ExtendableEvent {
public:
- typedef scoped_refptr<script::Wrappable> SourceType;
+ using SourceType =
+ cobalt::script::UnionType3<scoped_refptr<Client>,
+ scoped_refptr<ServiceWorker>,
+ scoped_refptr<web::MessagePort>>;
explicit ExtendableMessageEvent(const std::string& type)
: ExtendableEvent(type) {}
explicit ExtendableMessageEvent(base::Token type) : ExtendableEvent(type) {}
+ ExtendableMessageEvent(base::Token type,
+ std::unique_ptr<script::DataBuffer> data)
+ : ExtendableEvent(type), data_(std::move(data)) {}
ExtendableMessageEvent(const std::string& type,
- const ExtendableMessageEventInit& init_dict)
- : ExtendableEvent(type, init_dict) {}
+ const ExtendableMessageEventInit& init_dict);
+ script::Handle<script::ValueHandle> data(
+ script::EnvironmentSettings* settings = nullptr) const;
- const script::ValueHandleHolder* data() const {
- if (!data_) {
- return NULL;
- }
-
- return &(data_->referenced_value());
- }
-
- std::string origin() const { return origin_; }
- std::string last_event_id() const { return last_event_id_; }
-
- base::Optional<SourceType> source() { return source_; }
-
+ const std::string& origin() const { return origin_; }
+ const std::string& last_event_id() const { return last_event_id_; }
+ const scoped_refptr<web::EventTarget>& source() const { return source_; }
script::Sequence<scoped_refptr<MessagePort>> ports() const { return ports_; }
+ // These helper functions are custom, and not in any spec.
+ void set_origin(const std::string& origin) { origin_ = origin; }
+ void set_last_event_id(const std::string& last_event_id) {
+ last_event_id_ = last_event_id;
+ }
+ void set_source(const scoped_refptr<web::EventTarget>& source) {
+ source_ = source;
+ }
+ void set_ports(script::Sequence<scoped_refptr<MessagePort>> ports) {
+ ports_ = ports;
+ }
+
DEFINE_WRAPPABLE_TYPE(ExtendableMessageEvent);
protected:
~ExtendableMessageEvent() override {}
private:
- std::unique_ptr<script::ValueHandleHolder::Reference> data_;
-
- std::string origin_ = "Origin Stub Value";
- std::string last_event_id_ = "Last Event Id Stub Value";
- base::Optional<SourceType> source_;
+ std::string origin_;
+ std::string last_event_id_;
+ scoped_refptr<web::EventTarget> source_;
script::Sequence<scoped_refptr<MessagePort>> ports_;
+ std::unique_ptr<script::DataBuffer> data_;
};
} // namespace worker
diff --git a/cobalt/worker/extendable_message_event.idl b/cobalt/worker/extendable_message_event.idl
index 1e2d5da..600fa71 100644
--- a/cobalt/worker/extendable_message_event.idl
+++ b/cobalt/worker/extendable_message_event.idl
@@ -18,10 +18,10 @@
Exposed = ServiceWorker,
Constructor(DOMString type, optional ExtendableMessageEventInit eventInitDict)
] interface ExtendableMessageEvent : ExtendableEvent {
- readonly attribute any data;
+ [CallWith = EnvironmentSettings] readonly attribute any data;
readonly attribute USVString origin;
readonly attribute DOMString lastEventId;
- [SameObject] readonly attribute (Client or ServiceWorker or MessagePort)? source;
+ readonly attribute EventTarget ? source;
// TODO(b/236750294): Make this be FrozenArray<MessagePort> when available.
readonly attribute sequence<MessagePort> ports;
};
diff --git a/cobalt/worker/extendable_message_event_init.idl b/cobalt/worker/extendable_message_event_init.idl
index 25da4cb..82c4e09 100644
--- a/cobalt/worker/extendable_message_event_init.idl
+++ b/cobalt/worker/extendable_message_event_init.idl
@@ -15,9 +15,10 @@
// https://w3c.github.io/ServiceWorker/#dictdef-extendablemessageeventinit
dictionary ExtendableMessageEventInit : ExtendableEventInit {
- any data = null;
+ any data;
USVString origin = "";
DOMString lastEventId = "";
- (Client or ServiceWorker or MessagePort)? source = null;
+ EventTarget? source;
+ //(Client or ServiceWorker or MessagePort) ? source = null;
sequence<MessagePort> ports;
};
diff --git a/cobalt/worker/extendable_message_event_test.cc b/cobalt/worker/extendable_message_event_test.cc
new file mode 100644
index 0000000..b5162b7
--- /dev/null
+++ b/cobalt/worker/extendable_message_event_test.cc
@@ -0,0 +1,199 @@
+// Copyright 2022 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "cobalt/worker/extendable_message_event.h"
+
+#include <memory>
+#include <string>
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/memory/scoped_refptr.h"
+#include "cobalt/script/testing/fake_script_value.h"
+#include "cobalt/script/v8c/entry_scope.h"
+#include "cobalt/script/value_handle.h"
+#include "cobalt/web/testing/gtest_workarounds.h"
+#include "cobalt/web/testing/mock_event_listener.h"
+#include "cobalt/worker/extendable_message_event_init.h"
+#include "cobalt/worker/testing/test_with_javascript.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cobalt {
+namespace worker {
+
+using script::testing::FakeScriptValue;
+using web::testing::MockEventListener;
+
+namespace {
+class ExtendableMessageEventTestWithJavaScript
+ : public testing::TestServiceWorkerWithJavaScript {
+ protected:
+ ExtendableMessageEventTestWithJavaScript() {
+ fake_event_listener_ = MockEventListener::Create();
+ }
+
+ ~ExtendableMessageEventTestWithJavaScript() override {}
+
+ std::unique_ptr<MockEventListener> fake_event_listener_;
+};
+} // namespace
+
+TEST_F(ExtendableMessageEventTestWithJavaScript,
+ ConstructorWithEventTypeString) {
+ scoped_refptr<ExtendableMessageEvent> event =
+ new ExtendableMessageEvent("mytestevent");
+
+ EXPECT_EQ("mytestevent", event->type());
+ EXPECT_EQ(NULL, event->target().get());
+ EXPECT_EQ(NULL, event->current_target().get());
+ EXPECT_EQ(web::Event::kNone, event->event_phase());
+ EXPECT_FALSE(event->bubbles());
+ EXPECT_FALSE(event->cancelable());
+ EXPECT_FALSE(event->default_prevented());
+ EXPECT_FALSE(event->IsBeingDispatched());
+ EXPECT_FALSE(event->propagation_stopped());
+ EXPECT_FALSE(event->immediate_propagation_stopped());
+ script::Handle<script::ValueHandle> event_data =
+ event->data(web_context()->environment_settings());
+ EXPECT_TRUE(event_data.IsEmpty());
+}
+
+TEST_F(ExtendableMessageEventTestWithJavaScript, ConstructorWithAny) {
+ base::Optional<script::ValueHandleHolder::Reference> reference;
+ EvaluateScript("'ConstructorWithAnyMessageData'", &reference);
+ std::unique_ptr<script::DataBuffer> data(
+ script::SerializeScriptValue(reference->referenced_value()));
+ EXPECT_NE(nullptr, data.get());
+ EXPECT_NE(nullptr, data->ptr);
+ EXPECT_GT(data->size, 0U);
+ scoped_refptr<ExtendableMessageEvent> event =
+ new ExtendableMessageEvent(base::Tokens::message(), std::move(data));
+
+ EXPECT_EQ("message", event->type());
+ EXPECT_EQ(NULL, event->target().get());
+ EXPECT_EQ(NULL, event->current_target().get());
+ EXPECT_EQ(web::Event::kNone, event->event_phase());
+ EXPECT_FALSE(event->bubbles());
+ EXPECT_FALSE(event->cancelable());
+ EXPECT_FALSE(event->default_prevented());
+ EXPECT_FALSE(event->IsBeingDispatched());
+ EXPECT_FALSE(event->propagation_stopped());
+ EXPECT_FALSE(event->immediate_propagation_stopped());
+ script::Handle<script::ValueHandle> event_data =
+ event->data(web_context()->environment_settings());
+ EXPECT_FALSE(event_data.IsEmpty());
+ auto script_value = event_data.GetScriptValue();
+ auto* isolate = script::GetIsolate(*script_value);
+ script::v8c::EntryScope entry_scope(isolate);
+ v8::Local<v8::Value> v8_value = script::GetV8Value(*script_value);
+ std::string actual =
+ *(v8::String::Utf8Value(isolate, v8_value.As<v8::String>()));
+ EXPECT_EQ("ConstructorWithAnyMessageData", actual);
+}
+
+TEST_F(ExtendableMessageEventTestWithJavaScript,
+ ConstructorWithEventTypeAndDefaultInitDict) {
+ ExtendableMessageEventInit init;
+ scoped_refptr<ExtendableMessageEvent> event =
+ new ExtendableMessageEvent("mytestevent", init);
+
+ EXPECT_EQ("mytestevent", event->type());
+ EXPECT_EQ(nullptr, event->target().get());
+ EXPECT_EQ(nullptr, event->current_target().get());
+ EXPECT_EQ(web::Event::kNone, event->event_phase());
+ EXPECT_FALSE(event->bubbles());
+ EXPECT_FALSE(event->cancelable());
+ EXPECT_FALSE(event->default_prevented());
+ EXPECT_FALSE(event->IsBeingDispatched());
+ EXPECT_FALSE(event->propagation_stopped());
+ EXPECT_FALSE(event->immediate_propagation_stopped());
+
+ script::Handle<script::ValueHandle> event_data =
+ event->data(web_context()->environment_settings());
+ EXPECT_TRUE(event_data.IsEmpty());
+ EXPECT_TRUE(event->origin().empty());
+ EXPECT_TRUE(event->last_event_id().empty());
+ EXPECT_EQ(nullptr, event->source().get());
+ EXPECT_TRUE(event->ports().empty());
+}
+
+TEST_F(ExtendableMessageEventTestWithJavaScript,
+ ConstructorWithEventTypeAndInitDict) {
+ ExtendableMessageEventInit init;
+ base::Optional<script::ValueHandleHolder::Reference> reference;
+ EvaluateScript("'data_value'", &reference);
+ init.set_data(&(reference->referenced_value()));
+ init.set_origin("OriginString");
+ init.set_last_event_id("lastEventIdString");
+ init.set_source(web_context()->GetWindowOrWorkerGlobalScope());
+ scoped_refptr<ExtendableMessageEvent> event =
+ new ExtendableMessageEvent("mytestevent", init);
+
+ EXPECT_EQ("mytestevent", event->type());
+ EXPECT_EQ(nullptr, event->target().get());
+ EXPECT_EQ(nullptr, event->current_target().get());
+ EXPECT_EQ(web::Event::kNone, event->event_phase());
+ EXPECT_FALSE(event->bubbles());
+ EXPECT_FALSE(event->cancelable());
+ EXPECT_FALSE(event->default_prevented());
+ EXPECT_FALSE(event->IsBeingDispatched());
+ EXPECT_FALSE(event->propagation_stopped());
+ EXPECT_FALSE(event->immediate_propagation_stopped());
+
+ script::Handle<script::ValueHandle> event_data =
+ event->data(web_context()->environment_settings());
+ auto script_value = event_data.GetScriptValue();
+ auto* isolate = script::GetIsolate(*script_value);
+ script::v8c::EntryScope entry_scope(isolate);
+ v8::Local<v8::Value> v8_value = script::GetV8Value(*script_value);
+ std::string actual =
+ *(v8::String::Utf8Value(isolate, v8_value.As<v8::String>()));
+ EXPECT_EQ("data_value", actual);
+
+ EXPECT_EQ("OriginString", event->origin());
+ EXPECT_EQ("lastEventIdString", event->last_event_id());
+ EXPECT_EQ(web_context()->GetWindowOrWorkerGlobalScope(),
+ event->source().get());
+ EXPECT_TRUE(event->ports().empty());
+}
+
+TEST_F(ExtendableMessageEventTestWithJavaScript,
+ ConstructorWithEventTypeAndExtendableMessageEventInitDict) {
+ std::string result;
+ EXPECT_TRUE(
+ EvaluateScript("var event = new ExtendableMessageEvent('dog', "
+ " {cancelable: true, "
+ " origin: 'OriginValue',"
+ " lastEventId: 'LastEventIdValue',"
+ " source: this,"
+ " data: {value: 'data_value'},"
+ " }"
+ ");"
+ "if (event.type == 'dog' &&"
+ " event.bubbles == false &&"
+ " event.cancelable == true &&"
+ " event.origin == 'OriginValue' &&"
+ " event.lastEventId == 'LastEventIdValue' &&"
+ " event.source == this &&"
+ " event.ports.length == 0 &&"
+ " event.data.value == 'data_value') "
+ " event.data.value;",
+ &result))
+ << "Failed to evaluate script.";
+ EXPECT_EQ("data_value", result);
+}
+
+} // namespace worker
+} // namespace cobalt
diff --git a/cobalt/worker/service_worker.cc b/cobalt/worker/service_worker.cc
index 4d6ac58..0756da2 100644
--- a/cobalt/worker/service_worker.cc
+++ b/cobalt/worker/service_worker.cc
@@ -17,8 +17,12 @@
#include <memory>
#include <utility>
+#include "base/bind.h"
#include "cobalt/script/environment_settings.h"
+#include "cobalt/script/value_handle.h"
+#include "cobalt/web/event_target.h"
#include "cobalt/web/message_port.h"
+#include "cobalt/worker/extendable_message_event.h"
#include "cobalt/worker/service_worker_global_scope.h"
#include "cobalt/worker/service_worker_object.h"
#include "cobalt/worker/service_worker_state.h"
@@ -30,8 +34,33 @@
worker::ServiceWorkerObject* worker)
: web::EventTarget(settings),
worker_(worker),
- message_port_(new web::MessagePort(worker->worker_global_scope())),
state_(kServiceWorkerStateParsed) {}
+
+void ServiceWorker::PostMessage(const script::ValueHandleHolder& message) {
+ // https://w3c.github.io/ServiceWorker/#service-worker-postmessage-options
+ web::EventTarget* event_target = worker_->worker_global_scope();
+ if (!event_target) return;
+
+ base::MessageLoop* message_loop =
+ event_target->environment_settings()->context()->message_loop();
+ if (!message_loop) {
+ return;
+ }
+ std::unique_ptr<script::DataBuffer> data_buffer(
+ script::SerializeScriptValue(message));
+ if (!data_buffer) {
+ return;
+ }
+ message_loop->task_runner()->PostTask(
+ FROM_HERE, base::BindOnce(
+ [](web::EventTarget* event_target,
+ std::unique_ptr<script::DataBuffer> data_buffer) {
+ event_target->DispatchEvent(new ExtendableMessageEvent(
+ base::Tokens::message(), std::move(data_buffer)));
+ },
+ base::Unretained(event_target), std::move(data_buffer)));
+}
+
} // namespace worker
} // namespace cobalt
diff --git a/cobalt/worker/service_worker.h b/cobalt/worker/service_worker.h
index a281746..193a6a4 100644
--- a/cobalt/worker/service_worker.h
+++ b/cobalt/worker/service_worker.h
@@ -20,6 +20,7 @@
#include <utility>
#include "cobalt/script/environment_settings.h"
+#include "cobalt/script/value_handle.h"
#include "cobalt/script/wrappable.h"
#include "cobalt/web/event_target.h"
#include "cobalt/web/event_target_listener_info.h"
@@ -43,10 +44,7 @@
// Web API: ServiceWorker
//
- void PostMessage(const script::ValueHandleHolder& message) {
- DCHECK(message_port_);
- if (worker_->worker_global_scope()) message_port_->PostMessage(message);
- }
+ void PostMessage(const script::ValueHandleHolder& message);
// The scriptURL getter steps are to return the
// service worker's serialized script url.
@@ -77,13 +75,9 @@
DEFINE_WRAPPABLE_TYPE(ServiceWorker);
private:
- ~ServiceWorker() override {
- message_port_.reset();
- worker_ = nullptr;
- }
+ ~ServiceWorker() override { worker_ = nullptr; }
scoped_refptr<ServiceWorkerObject> worker_;
- scoped_refptr<web::MessagePort> message_port_;
ServiceWorkerState state_;
};
diff --git a/cobalt/worker/service_worker_global_scope_test.cc b/cobalt/worker/service_worker_global_scope_test.cc
index a2a1c0c..0c56208 100644
--- a/cobalt/worker/service_worker_global_scope_test.cc
+++ b/cobalt/worker/service_worker_global_scope_test.cc
@@ -29,6 +29,8 @@
using script::testing::FakeScriptValue;
using web::testing::MockEventListener;
+namespace {
+
class ServiceWorkerGlobalScopeTest
: public testing::TestServiceWorkerWithJavaScript {
protected:
@@ -41,6 +43,8 @@
std::unique_ptr<MockEventListener> fake_event_listener_;
};
+} // namespace
+
TEST_F(ServiceWorkerGlobalScopeTest, RegistrationIsObject) {
std::string result;
EXPECT_TRUE(EvaluateScript("typeof self.registration", &result));
diff --git a/cobalt/worker/service_worker_object.cc b/cobalt/worker/service_worker_object.cc
index 436f256..e63c421 100644
--- a/cobalt/worker/service_worker_object.cc
+++ b/cobalt/worker/service_worker_object.cc
@@ -58,6 +58,7 @@
DCHECK(message_loop());
DCHECK(web_context_);
web_agent_->WaitUntilDone();
+ web_agent_->Stop();
web_agent_.reset();
web_context_ = nullptr;
}
@@ -123,10 +124,11 @@
void ServiceWorkerObject::ObtainWebAgentAndWaitUntilDone() {
TRACE_EVENT0("cobalt::worker",
"ServiceWorkerObject::ObtainWebAgentAndWaitUntilDone()");
- web_agent_.reset(new web::Agent(
+ web_agent_.reset(new web::Agent(options_.name));
+ web_agent_->Run(
options_.web_options,
base::Bind(&ServiceWorkerObject::Initialize, base::Unretained(this)),
- this));
+ this);
web_agent_->WaitUntilDone();
}
diff --git a/cobalt/worker/service_worker_object.h b/cobalt/worker/service_worker_object.h
index 8b4daa6..a3cf5cb 100644
--- a/cobalt/worker/service_worker_object.h
+++ b/cobalt/worker/service_worker_object.h
@@ -56,15 +56,16 @@
public:
// Worker Options needed at thread run time.
struct Options {
- explicit Options(
+ Options(
const std::string& name, network::NetworkModule* network_module,
ServiceWorkerRegistrationObject* containing_service_worker_registration)
- : web_options(name),
+ : name(name),
containing_service_worker_registration(
containing_service_worker_registration) {
web_options.network_module = network_module;
}
+ std::string name;
web::Agent::Options web_options;
ServiceWorkerRegistrationObject* containing_service_worker_registration;
};
diff --git a/cobalt/worker/testing/test_with_javascript.h b/cobalt/worker/testing/test_with_javascript.h
index f6499d5..72dda4c 100644
--- a/cobalt/worker/testing/test_with_javascript.h
+++ b/cobalt/worker/testing/test_with_javascript.h
@@ -83,23 +83,34 @@
web_context_.reset();
}
- WorkerGlobalScope* worker_global_scope() { return worker_global_scope_; }
-
- virtual scoped_refptr<script::GlobalEnvironment> global_environment() {
- return web_context_->global_environment();
+ WorkerGlobalScope* worker_global_scope() const {
+ return worker_global_scope_;
}
- bool EvaluateScript(const std::string& js_code, std::string* result) {
- DCHECK(this->global_environment());
- scoped_refptr<script::SourceCode> source_code =
- script::SourceCode::CreateSourceCode(
- js_code, base::SourceLocation(__FILE__, __LINE__, 1));
+ virtual web::Context* web_context() const {
+ DCHECK(web_context_);
+ return web_context_.get();
+ }
- this->global_environment()->EnableEval();
- this->global_environment()->SetReportEvalCallback(base::Closure());
- bool succeeded =
- this->global_environment()->EvaluateScript(source_code, result);
- return succeeded;
+ scoped_refptr<script::GlobalEnvironment> global_environment() const {
+ DCHECK(this->web_context());
+ return this->web_context()->global_environment();
+ }
+
+ bool EvaluateScript(const std::string& js_code,
+ std::string* result = nullptr) {
+ DCHECK(global_environment());
+ return global_environment()->EvaluateScript(
+ CreateSourceCodeAndPrepareEval(js_code), result);
+ }
+
+ bool EvaluateScript(
+ const std::string& js_code,
+ base::Optional<script::ValueHandleHolder::Reference>* result) {
+ DCHECK(global_environment());
+ return global_environment()->EvaluateScript(
+ CreateSourceCodeAndPrepareEval(js_code),
+ this->web_context()->GetWindowOrWorkerGlobalScope(), result);
}
::testing::StrictMock<script::testing::MockExceptionState>*
@@ -108,6 +119,15 @@
}
private:
+ scoped_refptr<script::SourceCode> CreateSourceCodeAndPrepareEval(
+ const std::string& js_code) {
+ DCHECK(global_environment());
+ global_environment()->EnableEval();
+ global_environment()->SetReportEvalCallback(base::Closure());
+ return script::SourceCode::CreateSourceCode(
+ js_code, base::SourceLocation(__FILE__, __LINE__, 1));
+ }
+
std::unique_ptr<web::testing::StubWebContext> web_context_;
WorkerGlobalScope* worker_global_scope_ = nullptr;
scoped_refptr<DedicatedWorkerGlobalScope> dedicated_worker_global_scope_;
diff --git a/cobalt/worker/worker.cc b/cobalt/worker/worker.cc
index a820c8f..870783d 100644
--- a/cobalt/worker/worker.cc
+++ b/cobalt/worker/worker.cc
@@ -43,7 +43,7 @@
bool PermitAnyURL(const GURL&, bool) { return true; }
} // namespace
-Worker::Worker(const Options& options) : options_(options) {
+Worker::Worker(const char* name, const Options& options) : options_(options) {
// Algorithm for 'run a worker'
// https://html.spec.whatwg.org/commit-snapshots/465a6b672c703054de278b0f8133eb3ad33d93f4/#run-a-worker
// 1. Let is shared be true if worker is a SharedWorker object, and false
@@ -57,9 +57,15 @@
// 6. Let agent be the result of obtaining a dedicated/shared worker agent
// given outside settings and is shared. Run the rest of these steps in
// that agent.
- web_agent_.reset(new web::Agent(
- options.web_options,
- base::Bind(&Worker::Initialize, base::Unretained(this)), this));
+ std::string agent_name(name);
+ if (!options.options.name().empty()) {
+ agent_name.push_back(':');
+ agent_name.append(options.options.name());
+ }
+ web_agent_.reset(new web::Agent(agent_name));
+ web_agent_->Run(options.web_options,
+ base::Bind(&Worker::Initialize, base::Unretained(this)),
+ this);
}
void Worker::WillDestroyCurrentMessageLoop() {
@@ -126,7 +132,7 @@
#endif // ENABLE_DEBUGGER
// 10. Set worker global scope's name to the value of options's name member.
- dedicated_worker_global_scope->set_name(options_.web_options.name);
+ dedicated_worker_global_scope->set_name(options_.options.name());
// 11. Append owner to worker global scope's owner set.
// 12. If is shared is true, then:
// 1. Set worker global scope's constructor origin to outside settings's
@@ -170,6 +176,8 @@
loader_ = web_context_->script_loader_factory()->CreateScriptLoader(
url, origin, csp_callback,
base::Bind(&Worker::OnContentProduced, base::Unretained(this)),
+ base::Bind(&WorkerGlobalScope::InitializePolicyContainerCallback,
+ worker_global_scope_),
base::Bind(&Worker::OnLoadingComplete, base::Unretained(this)));
}
@@ -309,6 +317,7 @@
if (web_agent_) {
DCHECK(message_loop());
web_agent_->WaitUntilDone();
+ web_agent_->Stop();
web_agent_.reset();
web_context_ = nullptr;
}
diff --git a/cobalt/worker/worker.h b/cobalt/worker/worker.h
index 2c488ec..feea239 100644
--- a/cobalt/worker/worker.h
+++ b/cobalt/worker/worker.h
@@ -55,8 +55,6 @@
public:
// Worker Options needed at thread run time.
struct Options {
- explicit Options(const std::string& name) : web_options(name) {}
-
web::Agent::Options web_options;
// True if worker is a SharedWorker object, and false otherwise.
@@ -70,7 +68,7 @@
WorkerOptions options;
};
- explicit Worker(const Options& options);
+ Worker(const char* name, const Options& options);
~Worker();
Worker(const Worker&) = delete;
Worker& operator=(const Worker&) = delete;
diff --git a/cobalt/worker/worker_global_scope.cc b/cobalt/worker/worker_global_scope.cc
index 662aaa5..4c68bbe 100644
--- a/cobalt/worker/worker_global_scope.cc
+++ b/cobalt/worker/worker_global_scope.cc
@@ -23,6 +23,7 @@
#include "base/message_loop/message_loop_current.h"
#include "base/threading/thread.h"
#include "base/trace_event/trace_event.h"
+#include "cobalt/loader/net_fetcher.h"
#include "cobalt/loader/origin.h"
#include "cobalt/script/environment_settings.h"
#include "cobalt/web/context.h"
@@ -195,6 +196,53 @@
set_navigator_base(navigator_);
}
+bool WorkerGlobalScope::InitializePolicyContainerCallback(
+ loader::Fetcher* fetcher,
+ const scoped_refptr<net::HttpResponseHeaders>& headers) {
+ DCHECK(headers);
+ // https://html.spec.whatwg.org/commit-snapshots/465a6b672c703054de278b0f8133eb3ad33d93f4/#initialize-worker-policy-container
+ // 1. If workerGlobalScope's url is local but its scheme is not "blob":
+ // 1. Assert: workerGlobalScope's owner set's size is 1.
+ // 2. Set workerGlobalScope's policy container to a clone of
+ // workerGlobalScope's owner set[0]'s relevant settings object's policy
+ // container.
+ // 2. Otherwise, set workerGlobalScope's policy container to the result of
+ // creating a policy container from a fetch response given response and
+ // environment.
+ // Steps from create a policy container from a fetch response:
+ // https://html.spec.whatwg.org/commit-snapshots/465a6b672c703054de278b0f8133eb3ad33d93f4/#creating-a-policy-container-from-a-fetch-response
+ // 1. If response's URL's scheme is "blob", then return a clone of response's
+ // URL's blob URL entry's environment's policy container.
+ // 2. Let result be a new policy container.
+ // 3. Set result's CSP list to the result of parsing a response's Content
+ // Security Policies given response.
+ // 4. If environment is non-null, then set result's embedder policy to the
+ // result of obtaining an embedder policy given response and environment.
+ // Otherwise, set it to "unsafe-none".
+ // 5. Set result's referrer policy to the result of parsing the
+ // `Referrer-Policy` header given response. [REFERRERPOLICY]
+ // 6. Return result.
+
+ // Steps 3-6. Since csp_delegate doesn't fully mirror PolicyContainer, we
+ // don't create a new one here and return it. Instead we update the existing
+ // one for this worker and return true for success and false for failure.
+ csp::ResponseHeaders csp_headers(headers);
+ if (csp_delegate()->OnReceiveHeaders(csp_headers)) {
+ return true;
+ }
+ // Only NetFetchers are expected to call this, since only they have the
+ // response headers.
+ loader::NetFetcher* net_fetcher =
+ base::polymorphic_downcast<loader::NetFetcher*>(fetcher);
+ net::URLFetcher* url_fetcher = net_fetcher->url_fetcher();
+ LOG(INFO) << "Failure receiving Content Security Policy headers "
+ "for URL: "
+ << url_fetcher->GetURL() << ".";
+ // Return true regardless of CSP headers being received to continue loading
+ // the response.
+ return true;
+}
+
void WorkerGlobalScope::ImportScripts(const std::vector<std::string>& urls,
script::ExceptionState* exception_state) {
ImportScriptsInternal(urls, exception_state, URLLookupCallback(),
diff --git a/cobalt/worker/worker_global_scope.h b/cobalt/worker/worker_global_scope.h
index f4e2291..345220b 100644
--- a/cobalt/worker/worker_global_scope.h
+++ b/cobalt/worker/worker_global_scope.h
@@ -63,6 +63,13 @@
virtual void Initialize() {}
+ // https://html.spec.whatwg.org/commit-snapshots/465a6b672c703054de278b0f8133eb3ad33d93f4/#initialize-worker-policy-container
+ // Intended to be called from a loader::Decoder::OnResponseStarted to
+ // initialize CSP headers once they're fetched.
+ bool InitializePolicyContainerCallback(
+ loader::Fetcher* fetcher,
+ const scoped_refptr<net::HttpResponseHeaders>& headers);
+
// Web API: WorkerGlobalScope
//
scoped_refptr<WorkerGlobalScope> self() { return this; }
diff --git a/cobalt/worker/worker_global_scope_test.cc b/cobalt/worker/worker_global_scope_test.cc
index 67ee3ed..216da15 100644
--- a/cobalt/worker/worker_global_scope_test.cc
+++ b/cobalt/worker/worker_global_scope_test.cc
@@ -20,6 +20,7 @@
#include "cobalt/bindings/testing/utils.h"
#include "cobalt/script/testing/fake_script_value.h"
#include "cobalt/web/error_event.h"
+#include "cobalt/web/message_event.h"
#include "cobalt/web/testing/mock_event_listener.h"
#include "cobalt/worker/testing/test_with_javascript.h"
diff --git a/glimp/gles/context.cc b/glimp/gles/context.cc
index 5a5eb59..ac0b53b 100644
--- a/glimp/gles/context.cc
+++ b/glimp/gles/context.cc
@@ -1,5 +1,5 @@
/*
- * Copyright 2015 Google Inc. All Rights Reserved.
+ * Copyright 2015 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.
@@ -37,6 +37,7 @@
namespace {
+std::atomic_int s_context_id_counter_(0);
SbOnceControl s_tls_current_context_key_once_control = SB_ONCE_INITIALIZER;
SbThreadLocalKey s_tls_current_context_key = kSbThreadLocalKeyInvalid;
@@ -54,6 +55,7 @@
Context::Context(nb::scoped_ptr<ContextImpl> context_impl,
Context* share_context)
: impl_(context_impl.Pass()),
+ context_id_(s_context_id_counter_++),
current_thread_(kSbThreadInvalid),
has_been_current_(false),
active_texture_(GL_TEXTURE0),
@@ -974,7 +976,7 @@
SB_DCHECK(access & GL_MAP_INVALIDATE_BUFFER_BIT)
<< "glimp requires the GL_MAP_INVALIDATE_BUFFER_BIT flag to be set.";
SB_DCHECK(access & GL_MAP_UNSYNCHRONIZED_BIT)
- << "glimp requres the GL_MAP_UNSYNCHRONIZED_BIT flag to be set.";
+ << "glimp requires the GL_MAP_UNSYNCHRONIZED_BIT flag to be set.";
SB_DCHECK(!(access & GL_MAP_FLUSH_EXPLICIT_BIT))
<< "glimp does not support the GL_MAP_FLUSH_EXPLICIT_BIT flag.";
SB_DCHECK(length == bound_buffer->size_in_bytes())
diff --git a/glimp/gles/context.h b/glimp/gles/context.h
index 5444618..66e9ed7 100644
--- a/glimp/gles/context.h
+++ b/glimp/gles/context.h
@@ -1,5 +1,5 @@
/*
- * Copyright 2015 Google Inc. All Rights Reserved.
+ * Copyright 2015 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.
@@ -19,6 +19,7 @@
#include <GLES3/gl3.h>
+#include <atomic>
#include <map>
#include <set>
#include <string>
@@ -58,6 +59,9 @@
// Releases the current thread's current context.
static void ReleaseTLSCurrentContext();
+ // Returns the unique id of the context instance.
+ int context_id() const { return context_id_; }
+
egl::Surface* draw_surface() {
return default_draw_framebuffer_->color_attachment_surface();
}
@@ -302,6 +306,10 @@
// A reference to the platform-specific implementation aspects of the context.
nb::scoped_ptr<ContextImpl> impl_;
+ // The unique id of context instance. It might be queried from different
+ // threads.
+ std::atomic_int context_id_;
+
// The thread that currently holds this context as its current context.
SbThread current_thread_;
diff --git a/net/data/url_request_unittest/redirect302-to-echo-cacheable.mock-http-headers b/net/data/url_request_unittest/redirect302-to-echo-cacheable.mock-http-headers
index fce2271..d41294c 100644
--- a/net/data/url_request_unittest/redirect302-to-echo-cacheable.mock-http-headers
+++ b/net/data/url_request_unittest/redirect302-to-echo-cacheable.mock-http-headers
@@ -2,3 +2,4 @@
Location: /echo
Content-Length: 1
Cache-control: max-age=60000
+Content-Type: example/unit_test
diff --git a/net/disk_cache/simple/simple_synchronous_entry.cc b/net/disk_cache/simple/simple_synchronous_entry.cc
index c8ca20a..2a42726 100644
--- a/net/disk_cache/simple/simple_synchronous_entry.cc
+++ b/net/disk_cache/simple/simple_synchronous_entry.cc
@@ -336,6 +336,7 @@
GetFilenameFromEntryFileKeyAndFileIndex(entry_file_key_, i));
#if defined(STARBOARD)
ok = false;
+ // Note: Files can not be renamed on Starboard.
#else
ok = base::ReplaceFile(old_name, new_name, &out_error) && ok;
#endif
@@ -350,6 +351,7 @@
path_.AppendASCII(GetSparseFilenameFromEntryFileKey(entry_file_key_));
#if defined(STARBOARD)
ok = false;
+ // Note: Files can not be renamed on Starboard.
#else
ok = base::ReplaceFile(old_name, new_name, &out_error) && ok;
#endif
diff --git a/net/disk_cache/simple/simple_util.cc b/net/disk_cache/simple/simple_util.cc
index 5c1f5a7..513de96 100644
--- a/net/disk_cache/simple/simple_util.cc
+++ b/net/disk_cache/simple/simple_util.cc
@@ -63,20 +63,30 @@
std::string GetFilenameFromEntryFileKeyAndFileIndex(
const SimpleFileTracker::EntryFileKey& key,
int file_index) {
+#if defined(STARBOARD)
+ return base::StringPrintf("%016" PRIx64 "_%1d", key.entry_hash, file_index);
+#else
+ // Files are not renamed on Starboard.
if (key.doom_generation == 0)
return base::StringPrintf("%016" PRIx64 "_%1d", key.entry_hash, file_index);
else
return base::StringPrintf("todelete_%016" PRIx64 "_%1d_%" PRIu64,
key.entry_hash, file_index, key.doom_generation);
+#endif
}
std::string GetSparseFilenameFromEntryFileKey(
const SimpleFileTracker::EntryFileKey& key) {
+#if defined(STARBOARD)
+ return base::StringPrintf("%016" PRIx64 "_s", key.entry_hash);
+#else
+ // Files are not renamed on Starboard.
if (key.doom_generation == 0)
return base::StringPrintf("%016" PRIx64 "_s", key.entry_hash);
else
return base::StringPrintf("todelete_%016" PRIx64 "_s_%" PRIu64,
key.entry_hash, key.doom_generation);
+#endif
}
std::string GetFilenameFromKeyAndFileIndex(const std::string& key,
diff --git a/net/http/http_cache_lookup_manager_unittest.cc b/net/http/http_cache_lookup_manager_unittest.cc
index ac7dec9..d3776d7 100644
--- a/net/http/http_cache_lookup_manager_unittest.cc
+++ b/net/http/http_cache_lookup_manager_unittest.cc
@@ -37,7 +37,8 @@
std::unique_ptr<MockTransaction> CreateMockTransaction(const GURL& url) {
MockTransaction mock_trans = {
url.spec().c_str(), "GET", base::Time(), "", LOAD_NORMAL,
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n",
base::Time(), "<html><body>Google Blah Blah</body></html>",
diff --git a/net/http/http_cache_transaction.cc b/net/http/http_cache_transaction.cc
index 9f13b95..5758e00 100644
--- a/net/http/http_cache_transaction.cc
+++ b/net/http/http_cache_transaction.cc
@@ -68,7 +68,8 @@
static const char* const kMimeTypesCacheAllowlist[] = {
"text/html", "text/css", "image/gif", "image/jpeg",
"image/png", "image/svg+xml", "image/webp", "font/otf",
- "font/ttf", "font/woff", "font/woff2", "text/javascript"};
+ "font/ttf", "font/woff", "font/woff2", "text/javascript",
+ "example/unit_test", "application/javascript"};
#endif
constexpr TimeDelta kStaleRevalidateTimeout = TimeDelta::FromSeconds(60);
@@ -3085,14 +3086,11 @@
// Only allow caching for specific mime types.
std::string mime_type;
response_.headers->GetMimeType(&mime_type);
- // TODO(b/243727663): Empty mime types should not get cached either.
- bool is_allowed_mime_type = mime_type.empty();
- if (!is_allowed_mime_type) {
- for (auto allowed_type : kMimeTypesCacheAllowlist) {
- if (mime_type.compare(allowed_type) == 0) {
- is_allowed_mime_type = true;
- break;
- }
+ bool is_allowed_mime_type = false;
+ for (auto allowed_type : kMimeTypesCacheAllowlist) {
+ if (mime_type.compare(allowed_type) == 0) {
+ is_allowed_mime_type = true;
+ break;
}
}
#else
diff --git a/net/http/http_cache_unittest.cc b/net/http/http_cache_unittest.cc
index 0740dc8..0d887ad 100644
--- a/net/http/http_cache_unittest.cc
+++ b/net/http/http_cache_unittest.cc
@@ -369,7 +369,8 @@
base::Time(),
"",
LOAD_VALIDATE_CACHE,
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test\n",
"Cache-Control: max-age=10000\n",
base::Time(),
"<html><body>Google Blah Blah</body></html>",
@@ -437,6 +438,10 @@
// AddHeadersFromString() (_not_ AddHeaderFromString()).
#define EXTRA_HEADER EXTRA_HEADER_LINE "\r\n"
+// Adds the unit_test MIME type to the EXTRA_HEADER for compatibility
+// with http_cache_transaction that now will require a MIME type.
+#define MIME_TYPE_EXTRA_HEADER "Content-Type: example/unit_test\r\n" EXTRA_HEADER
+
static const char kExtraHeaderKey[] = "Extra";
// Static.
@@ -477,7 +482,10 @@
ranges.size() != 1) {
// This is not a byte range request. We return 200.
response_status->assign("HTTP/1.1 200 OK");
- response_headers->assign("Date: Wed, 28 Nov 2007 09:40:09 GMT");
+ // Adds the unit_test MIME type to the response_headers for compatibility
+ // with http_cache_transaction that now will require a MIME type.
+ response_headers->assign("Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
+ "Content-Type: example/unit_test");
response_data->assign("Not a range");
return;
}
@@ -537,7 +545,8 @@
const MockTransaction kRangeGET_TransactionOK = {
"http://www.google.com/range", "GET", base::Time(),
"Range: bytes = 40-49\r\n" EXTRA_HEADER, LOAD_NORMAL,
- "HTTP/1.1 206 Partial Content",
+ "HTTP/1.1 206 Partial Content\n"
+ "Content-Type: example/unit_test",
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
@@ -4759,7 +4768,8 @@
MockHttpCache cache;
ScopedMockTransaction transaction(kETagGET_Transaction);
- transaction.status = "HTTP/1.0 200 OK";
+ transaction.status = "HTTP/1.0 200 OK\n"
+ "Content-Type: example/unit_test\n";
// Write to the cache.
RunTransactionTest(cache.http_cache(), transaction);
@@ -4782,7 +4792,8 @@
MockHttpCache cache;
ScopedMockTransaction transaction(kETagGET_Transaction);
- transaction.status = "HTTP/1.0 200 OK";
+ transaction.status = "HTTP/1.0 200 OK\n"
+ "Content-Type: example/unit_test\n";
// Write to the cache.
RunTransactionTest(cache.http_cache(), transaction);
@@ -4961,7 +4972,8 @@
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache1) {
// First network response for |kUrl|.
static const Response kNetResponse1 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
"body1"
@@ -4969,7 +4981,8 @@
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
"body2"
@@ -4987,7 +5000,8 @@
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache2) {
// First network response for |kUrl|.
static const Response kNetResponse1 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Etag: \"ETAG1\"\n"
"Expires: Wed, 7 Sep 2033 21:46:42 GMT\n", // Should never expire.
@@ -4996,7 +5010,8 @@
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Etag: \"ETAG2\"\n"
"Expires: Wed, 7 Sep 2033 21:46:42 GMT\n", // Should never expire.
@@ -5015,7 +5030,8 @@
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache3) {
// First network response for |kUrl|.
static const Response kNetResponse1 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Server: server1\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
@@ -5024,7 +5040,8 @@
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
- "HTTP/1.1 304 Not Modified",
+ "HTTP/1.1 304 Not Modified\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Server: server2\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
@@ -5035,7 +5052,8 @@
"HTTP/1.1 200 OK",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Server: server2\n"
- "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
+ "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n"
+ "Content-Type: example/unit_test\n",
"body1"
};
@@ -5055,7 +5073,8 @@
const char kUrl[] = "http://foobar.com/main.css";
static const Response kNetResponse = {
- "HTTP/1.1 304 Not Modified",
+ "HTTP/1.1 304 Not Modified\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
""
@@ -5099,7 +5118,8 @@
const char kUrl[] = "http://foobar.com/main.css";
static const Response kNetResponse = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
"foobar!!!"
@@ -5140,7 +5160,8 @@
// (the if-modified-since date is 2 days AFTER the cache's modification date).
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache6) {
static const Response kNetResponse1 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Server: server1\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
@@ -5149,7 +5170,8 @@
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
- "HTTP/1.1 304 Not Modified",
+ "HTTP/1.1 304 Not Modified\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Server: server2\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
@@ -5170,7 +5192,8 @@
// response (304) to update the cache.
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache7) {
static const Response kNetResponse1 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Etag: \"Foo1\"\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
@@ -5179,7 +5202,8 @@
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
- "HTTP/1.1 304 Not Modified",
+ "HTTP/1.1 304 Not Modified\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Etag: \"Foo2\"\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
@@ -5197,7 +5221,8 @@
// and if-modified-since updates the cache.
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache8) {
static const Response kNetResponse1 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Etag: \"Foo1\"\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
@@ -5206,7 +5231,8 @@
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Etag: \"Foo2\"\n"
"Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
@@ -5225,7 +5251,8 @@
// and if-modified-since does not update the cache with only one match.
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache9) {
static const Response kNetResponse1 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Etag: \"Foo1\"\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
@@ -5234,7 +5261,8 @@
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Etag: \"Foo2\"\n"
"Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
@@ -5254,7 +5282,8 @@
// and if-modified-since does not update the cache with only one match.
TEST_F(HttpCacheTest, ConditionalizedRequestUpdatesCache10) {
static const Response kNetResponse1 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Etag: \"Foo1\"\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
@@ -5263,7 +5292,8 @@
// Second network response for |kUrl|.
static const Response kNetResponse2 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
"Etag: \"Foo2\"\n"
"Last-Modified: Fri, 03 Jul 2009 02:14:27 GMT\n",
@@ -5654,7 +5684,9 @@
RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
- EXPECT_EQ("HTTP/1.1 200 OK\nContent-Length: 42\n", headers);
+ EXPECT_EQ("HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test\n"
+ "Content-Length: 42\n", headers);
RemoveMockTransaction(&transaction);
}
@@ -7050,7 +7082,8 @@
TEST_F(HttpCacheTest, RangeGET_301) {
MockHttpCache cache;
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
- transaction.status = "HTTP/1.1 301 Moved Permanently";
+ transaction.status = "HTTP/1.1 301 Moved Permanently\n"
+ "Content-Type: example/unit_test";
transaction.response_headers = "Location: http://www.bar.com/\n";
transaction.data = "";
transaction.handler = NULL;
@@ -8394,6 +8427,7 @@
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
@@ -8411,6 +8445,7 @@
"HTTP/1.1 200 OK\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"Accept-Ranges: bytes\n"
+ "Content-Type: example/unit_test\n"
"ETag: \"foo\"\n"
"Content-Length: 80\n");
@@ -8552,7 +8587,8 @@
// The server will return 200 instead of a byte range.
std::string expected_headers(
"HTTP/1.1 200 OK\n"
- "Date: Wed, 28 Nov 2007 09:40:09 GMT\n");
+ "Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
+ "Content-Type: example/unit_test\n");
EXPECT_EQ(expected_headers, headers);
EXPECT_EQ(2, cache.network_layer()->transaction_count());
@@ -8607,6 +8643,7 @@
AddMockTransaction(&kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
@@ -8699,7 +8736,7 @@
// Now make a regular request.
std::string headers;
- transaction.request_headers = EXTRA_HEADER;
+ transaction.request_headers = MIME_TYPE_EXTRA_HEADER;
transaction.data = "Not a range";
RangeTransactionServer handler;
handler.set_bad_200(true);
@@ -8720,6 +8757,7 @@
ScopedMockTransaction transaction(kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test\n"
"Last-Modified: Sat, 18 Apr 2009 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
@@ -8842,7 +8880,8 @@
MockHttpCache cache;
ScopedMockTransaction kTestTransaction(kSimpleGET_Transaction);
- kTestTransaction.status = "HTTP/1.1 301 Moved Permanently";
+ kTestTransaction.status = "HTTP/1.1 301 Moved Permanently\n"
+ "Content-Type: example/unit_test";
kTestTransaction.response_headers = "Location: http://www.bar.com/\n";
MockHttpRequest request(kTestTransaction);
@@ -9138,7 +9177,8 @@
request.data = kData;
static const Response kNetResponse1 = {
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Fri, 12 Jun 2009 21:46:42 GMT\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
kData
@@ -9154,7 +9194,8 @@
request.load_flags = LOAD_VALIDATE_CACHE;
static const Response kNetResponse2 = {
- "HTTP/1.1 304 Not Modified",
+ "HTTP/1.1 304 Not Modified\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n",
""
};
@@ -9178,6 +9219,7 @@
EXPECT_EQ("HTTP/1.1 200 OK\n"
"Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
+ "Content-Type: example/unit_test\n"
"Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
ToSimpleString(response.headers));
@@ -9673,6 +9715,7 @@
AddMockTransaction(&kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
@@ -10091,6 +10134,7 @@
AddMockTransaction(&kRangeGET_TransactionOK);
std::string raw_headers("HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test\n"
"Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
"ETag: \"foo\"\n"
"Accept-Ranges: bytes\n"
diff --git a/net/http/http_transaction_test_util.cc b/net/http/http_transaction_test_util.cc
index 9b9c92c..8914895 100644
--- a/net/http/http_transaction_test_util.cc
+++ b/net/http/http_transaction_test_util.cc
@@ -48,7 +48,8 @@
base::Time(),
"",
LOAD_NORMAL,
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Cache-Control: max-age=10000\n",
base::Time(),
"<html><body>Google Blah Blah</body></html>",
@@ -67,7 +68,8 @@
base::Time(),
"",
LOAD_NORMAL,
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"",
base::Time(),
"<html><body>Google Blah Blah</body></html>",
@@ -86,7 +88,8 @@
base::Time(),
"",
LOAD_NORMAL,
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Date: Wed, 28 Nov 2007 09:40:09 GMT\n"
"Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n",
base::Time(),
@@ -106,7 +109,8 @@
base::Time(),
"",
LOAD_NORMAL,
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Cache-Control: max-age=10000\n"
"Etag: \"foopy\"\n",
base::Time(),
@@ -126,7 +130,8 @@
base::Time(),
"Range: 0-100\r\n",
LOAD_NORMAL,
- "HTTP/1.1 200 OK",
+ "HTTP/1.1 200 OK\n"
+ "Content-Type: example/unit_test",
"Cache-Control: max-age=10000\n",
base::Time(),
"<html><body>Google Blah Blah</body></html>",
diff --git a/net/url_request/url_request.cc b/net/url_request/url_request.cc
index b4a9ab4..e55c504 100644
--- a/net/url_request/url_request.cc
+++ b/net/url_request/url_request.cc
@@ -1156,12 +1156,6 @@
raw_header_size_ = GetTotalReceivedBytes();
ConvertRealLoadTimesToBlockingTimes(&load_timing_info_);
-#if defined (STARBOARD)
- load_timing_info_.encoded_body_size = static_cast<uint64_t>(GetTotalReceivedBytes());
- if (!load_timing_info_callback_.is_null()) {
- load_timing_info_callback_.Run(load_timing_info_);
- }
-#endif // defined(STARBOARD)
}
}
@@ -1171,6 +1165,13 @@
if (has_notified_completion_)
return;
+ #if defined (STARBOARD)
+ load_timing_info_.encoded_body_size = static_cast<uint64_t>(GetTotalReceivedBytes());
+ if (load_timing_info_callback_) {
+ load_timing_info_callback_.Run(load_timing_info_);
+ }
+ #endif // defined(STARBOARD)
+
is_pending_ = false;
is_redirecting_ = false;
has_notified_completion_ = true;
diff --git a/net/url_request/url_request_http_job_unittest.cc b/net/url_request/url_request_http_job_unittest.cc
index fc7b92b..e0f4358 100644
--- a/net/url_request/url_request_http_job_unittest.cc
+++ b/net/url_request/url_request_http_job_unittest.cc
@@ -494,6 +494,7 @@
{
MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
+ "Content-Type: example/unit_test\r\n"
"Content-Length: 12\r\n\r\n"),
MockRead("Test Content")};
diff --git a/starboard/android/apk/app/CMakeLists.txt b/starboard/android/apk/app/CMakeLists.txt
index d5d598f..5b1cb17 100644
--- a/starboard/android/apk/app/CMakeLists.txt
+++ b/starboard/android/apk/app/CMakeLists.txt
@@ -38,6 +38,13 @@
)
endif()
+# Abort gracefully if the config has not been generated. This should only happen
+# when building from Android Studio which builds all supported ABIs by default.
+if(NOT EXISTS "${COBALT_PRODUCT_DIR}")
+ message(WARNING "android-${COBALT_ARCH}_${COBALT_CONFIG} not configured. Please run GN. Skipping config.")
+ return()
+endif()
+
# If COBALT_CONTENT_DIR isn't set for a particular deploy target use the
# 'content/data' directory.
if(NOT COBALT_CONTENT_DIR)
@@ -47,9 +54,9 @@
endif()
# If COBALT_LIBRARY_DIR isn't set for a particular deploy target use the
-# toplevel lib/ subdirectory.
+# product root.
if(NOT COBALT_LIBRARY_DIR)
- set(COBALT_LIBRARY_DIR ${COBALT_PRODUCT_DIR}/lib)
+ set(COBALT_LIBRARY_DIR ${COBALT_PRODUCT_DIR})
endif()
# For platform deploy builds, use the -n parameter to skip Cobalt ninja and
@@ -76,9 +83,11 @@
# ("cobalt_content" never gets created, so this runs every time.)
add_custom_command(OUTPUT cobalt_content
DEPENDS coat_lib
+ COMMAND ${CMAKE_COMMAND} -E make_directory
+ ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/../../../../${COBALT_CONFIG}
COMMAND ${CMAKE_COMMAND} -E create_symlink
${COBALT_CONTENT_DIR}
- ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/../../../../cobalt_content
+ ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/../../../../${COBALT_CONFIG}/cobalt_content
)
# We need a target (not a file) for the phony native dependency below.
diff --git a/starboard/android/apk/app/build.gradle b/starboard/android/apk/app/build.gradle
index 2712f25..c78527f 100644
--- a/starboard/android/apk/app/build.gradle
+++ b/starboard/android/apk/app/build.gradle
@@ -140,16 +140,16 @@
}
// Add the directories symlinked by the CMake "cobalt_content" custom command.
debug {
- assets.srcDir "${buildDir}/intermediates/cxx/cobalt_content"
+ assets.srcDir "${buildDir}/intermediates/cxx/debug/cobalt_content"
}
devel {
- assets.srcDir "${buildDir}/intermediates/cxx/cobalt_content"
+ assets.srcDir "${buildDir}/intermediates/cxx/devel/cobalt_content"
}
qa {
- assets.srcDir "${buildDir}/intermediates/cxx/cobalt_content"
+ assets.srcDir "${buildDir}/intermediates/cxx/qa/cobalt_content"
}
release {
- assets.srcDir "${buildDir}/intermediates/cxx/cobalt_content"
+ assets.srcDir "${buildDir}/intermediates/cxx/gold/cobalt_content"
}
}
externalNativeBuild {
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 eeed7a7..1478b37 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
@@ -781,6 +781,10 @@
Log.e(TAG, "Failed to set operating rate with invalid fps " + mFps);
return;
}
+ if (mMediaCodec == null) {
+ Log.e(TAG, "Failed to set operating rate when media codec is null.");
+ return;
+ }
double operatingRate = mPlaybackRate * mFps;
Bundle b = new Bundle();
b.putFloat(MediaFormat.KEY_OPERATING_RATE, (float) operatingRate);
diff --git a/starboard/android/apk/build.gradle b/starboard/android/apk/build.gradle
index 3db6ad6..1247002 100644
--- a/starboard/android/apk/build.gradle
+++ b/starboard/android/apk/build.gradle
@@ -42,17 +42,16 @@
}
}
-task clean(type: Delete) {
- delete rootProject.buildDir
-}
-
// Move the 'buildDir' for all projects into sub-directories of a shared top-level build directory,
// which is either the root's original 'buildDir' or a custom location when building for platform
// deploy. Note that the platform deploy action sets a custom 'cobaltGradleDir' property rather
// than setting 'buildDir' directly on the command line since Gradle tries to get smart about
// 'buildDir' which can end up putting it at the wrong depth in the file system.
-def rootBuildDir = hasProperty('cobaltGradleDir') ? new File(cobaltGradleDir, 'build') : buildDir
-allprojects { buildDir = new File(rootBuildDir, project.name).canonicalFile }
+allprojects { buildDir = new File(gradle.ext.rootBuildDir, project.name).canonicalFile }
+
+task clean(type: Delete) {
+ delete gradle.ext.rootBuildDir
+}
// Android Studio Gradle plugin 3.5+ builds all supported ABIs for a connected device. Override the
// property it sets to build just the first one, which is the preferred ABI for the device.
diff --git a/starboard/android/apk/cobalt-gradle.sh b/starboard/android/apk/cobalt-gradle.sh
deleted file mode 100755
index a5b430f..0000000
--- a/starboard/android/apk/cobalt-gradle.sh
+++ /dev/null
@@ -1,70 +0,0 @@
-#!/bin/bash
-# Copyright 2016 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.
-
-# Helper to set ANDROID_HOME and ANDROID_NDK_HOME from command-line args
-# before running gradlew, as specified by leading --sdk and --ndk args.
-#
-# Also resets hung gradle builds when specified by a leading --reset arg.
-
-GRADLE_ARGS=()
-while [ "$1" ]; do
- case "$1" in
- --sdk) shift; ANDROID_HOME="$1" ;;
- --cache) shift; mkdir -p "$1";
- GRADLE_ARGS+=("--project-cache-dir" $(cd "$1"; pwd)) ;;
- --reset) RESET_GRADLE=1 ;;
- *) break ;;
- esac
- shift
-done
-GRADLE_ARGS+=("$@")
-
-# Cleanup Gradle from previous builds. Used as part of the GYP step.
-if [[ "${RESET_GRADLE}" ]]; then
- echo "Cleaning Gradle daemons and locks."
- # If there are any lock files, kill any hung processes still waiting on them.
- if compgen -G '/var/lock/cobalt-gradle.lock.*'; then
- lsof -t /var/lock/cobalt-gradle.lock.* | xargs -rt kill
- fi
- # Stop the Gradle daemon (if still running).
- $(dirname "$0")/gradlew --stop
- # Remove Gradle caches (including its lock files).
- rm -rf ${HOME}/.gradle/caches
- # Show the gradle version, which will cause it to download if needed.
- $(dirname "$0")/gradlew -v
- # After resetting, exit without running any gradle tasks.
- exit
-fi
-
-export ANDROID_HOME
-echo "ANDROID_HOME=${ANDROID_HOME}"
-
-# Allow parallel gradle builds, as defined by a COBALT_GRADLE_BUILD_COUNT envvar
-# or default to 1 if that's not set (so buildbot only runs 1 gradle at a time).
-BUCKETS=${COBALT_GRADLE_BUILD_COUNT:-1}
-if [ "$BUCKETS" -eq 1 ]; then
- echo "Gradle daemon and parallel gradle disabled for Cobalt build"
- GRADLE_ARGS+=(
- "-Dorg.gradle.parallel=false"
- "-Dorg.gradle.workers.max=1"
- "-Dorg.gradle.daemon=false"
- )
-fi
-
-MD5=$(echo "${GRADLE_ARGS[@]}" | md5sum)
-LOCKNUM=$(( ${BUCKETS} * 0x${MD5:0:6} / 0x1000000 ))
-
-echo "TASK: ${GRADLE_ARGS[-1]}"
-flock /var/lock/cobalt-gradle.lock.${LOCKNUM} $(dirname "$0")/gradlew "${GRADLE_ARGS[@]}"
diff --git a/starboard/android/apk/settings.gradle b/starboard/android/apk/settings.gradle
index 4fe2070..3b60efd 100644
--- a/starboard/android/apk/settings.gradle
+++ b/starboard/android/apk/settings.gradle
@@ -15,3 +15,7 @@
include ':app'
println "GRADLE VERSION: $gradle.gradleVersion"
+
+gradle.ext.rootBuildDir = hasProperty('cobaltGradleDir')
+ ? new File(cobaltGradleDir, 'build')
+ : new File(rootDir, "/../../../out/android_studio/gradle/build").canonicalFile
diff --git a/starboard/android/shared/install_target.gni b/starboard/android/shared/install_target.gni
index 0a635e1..6eae3d3 100644
--- a/starboard/android/shared/install_target.gni
+++ b/starboard/android/shared/install_target.gni
@@ -16,6 +16,16 @@
import("//starboard/android/shared/toolchain/toolchain.gni")
import("//starboard/build/config/install.gni")
+declare_args() {
+ # Must be set to a positive integer. Needs to be a string due to us not being
+ # able to cast to an integer in GN.
+ num_gradle_workers = getenv("COBALT_GRADLE_BUILD_COUNT")
+}
+
+if (num_gradle_workers == "") {
+ num_gradle_workers = "1"
+}
+
template("install_target") {
not_needed(invoker, [ "type" ])
@@ -36,10 +46,10 @@
gradle_build_type = build_type
}
- bash_script = "//starboard/android/apk/cobalt-gradle.sh"
+ gradle_wrapper = "//starboard/android/apk/gradlew"
sources = [
- bash_script,
+ gradle_wrapper,
target_output,
]
sources += apk_sources
@@ -52,14 +62,16 @@
cobalt_gradle_dir = rebase_path(gradle_files_dir)
cobalt_product_dir = rebase_path(root_out_dir)
cobalt_library_dir = rebase_path(root_out_dir)
+ project_cache_dir =
+ rebase_path("$root_build_dir/gradle/$installable_target_name/cache")
+ use_parallel_build = num_gradle_workers != "1"
script = "//starboard/build/run_bash.py"
args = [
- rebase_path(bash_script, root_build_dir),
- "--sdk",
- android_sdk_path,
- "--cache",
- rebase_path("$root_build_dir/gradle/$installable_target_name/cache"),
+ "env",
+ "ANDROID_HOME=${android_sdk_path}",
+ rebase_path(gradle_wrapper, root_build_dir),
+ "--project-cache-dir=$project_cache_dir",
"--project-dir",
cobalt_project_dir,
"-P",
@@ -79,6 +91,9 @@
"-P",
"enableVulkan=$enable_vulkan",
"assembleCobalt_$gradle_build_type",
+ "-Dorg.gradle.workers.max=$num_gradle_workers",
+ "-Dorg.gradle.workers.parallel=$use_parallel_build",
+ "-Dorg.gradle.workers.daemon=$use_parallel_build",
]
}
diff --git a/starboard/build/install/no_install.gni b/starboard/build/install/no_install.gni
index f2ca601..8d8c448 100644
--- a/starboard/build/install/no_install.gni
+++ b/starboard/build/install/no_install.gni
@@ -19,6 +19,7 @@
[
"testonly",
"installable_target_name",
+ "deps",
])
forward_variables_from(invoker,
[
@@ -27,5 +28,8 @@
])
group(target_name) {
deps = [ ":$installable_target_name" ]
+ if (defined(invoker.deps)) {
+ deps += invoker.deps
+ }
}
}
diff --git a/starboard/elf_loader/sandbox.cc b/starboard/elf_loader/sandbox.cc
index 019309f..2f2eb05 100644
--- a/starboard/elf_loader/sandbox.cc
+++ b/starboard/elf_loader/sandbox.cc
@@ -79,13 +79,16 @@
if (!get_user_agent_func) {
SB_LOG(ERROR) << "Failed to get user agent string";
} else {
- CrashpadAnnotations cobalt_version_info;
- memset(&cobalt_version_info, 0, sizeof(CrashpadAnnotations));
- starboard::strlcpy(cobalt_version_info.user_agent_string,
- get_user_agent_func(), USER_AGENT_STRING_MAX_SIZE);
- third_party::crashpad::wrapper::AddAnnotationsToCrashpad(
- cobalt_version_info);
- SB_DLOG(INFO) << "Added user agent string to Crashpad.";
+ std::vector<char> buffer(USER_AGENT_STRING_MAX_SIZE);
+ starboard::strlcpy(buffer.data(), get_user_agent_func(),
+ USER_AGENT_STRING_MAX_SIZE);
+ if (third_party::crashpad::wrapper::InsertCrashpadAnnotation(
+ third_party::crashpad::wrapper::kCrashpadUserAgentStringKey,
+ buffer.data())) {
+ SB_DLOG(INFO) << "Added user agent string to Crashpad.";
+ } else {
+ SB_DLOG(INFO) << "Failed to add user agent string to Crashpad.";
+ }
}
if (!g_sb_event_func) {
diff --git a/starboard/loader_app/loader_app.cc b/starboard/loader_app/loader_app.cc
index 8bae605..fcb2975 100644
--- a/starboard/loader_app/loader_app.cc
+++ b/starboard/loader_app/loader_app.cc
@@ -160,13 +160,16 @@
if (!get_user_agent_func) {
SB_LOG(ERROR) << "Failed to get user agent string";
} else {
- CrashpadAnnotations cobalt_version_info;
- memset(&cobalt_version_info, 0, sizeof(CrashpadAnnotations));
- starboard::strlcpy(cobalt_version_info.user_agent_string,
- get_user_agent_func(), USER_AGENT_STRING_MAX_SIZE);
- third_party::crashpad::wrapper::AddAnnotationsToCrashpad(
- cobalt_version_info);
- SB_DLOG(INFO) << "Added user agent string to Crashpad.";
+ std::vector<char> buffer(USER_AGENT_STRING_MAX_SIZE);
+ starboard::strlcpy(buffer.data(), get_user_agent_func(),
+ USER_AGENT_STRING_MAX_SIZE);
+ if (third_party::crashpad::wrapper::InsertCrashpadAnnotation(
+ third_party::crashpad::wrapper::kCrashpadUserAgentStringKey,
+ buffer.data())) {
+ SB_DLOG(INFO) << "Added user agent string to Crashpad.";
+ } else {
+ SB_DLOG(INFO) << "Failed to add user agent string to Crashpad.";
+ }
}
g_sb_event_func = reinterpret_cast<void (*)(const SbEvent*)>(
diff --git a/starboard/loader_app/slot_management.cc b/starboard/loader_app/slot_management.cc
index 9f76b11..fc5549a 100644
--- a/starboard/loader_app/slot_management.cc
+++ b/starboard/loader_app/slot_management.cc
@@ -28,6 +28,7 @@
#include "starboard/loader_app/installation_manager.h"
#include "starboard/memory.h"
#include "starboard/string.h"
+#include "third_party/crashpad/wrapper/annotations.h"
#include "third_party/crashpad/wrapper/wrapper.h"
namespace starboard {
@@ -315,13 +316,16 @@
if (!get_user_agent_func) {
SB_LOG(ERROR) << "Failed to get user agent string";
} else {
- CrashpadAnnotations cobalt_version_info;
- memset(&cobalt_version_info, 0, sizeof(CrashpadAnnotations));
- starboard::strlcpy(cobalt_version_info.user_agent_string,
- get_user_agent_func(), USER_AGENT_STRING_MAX_SIZE);
- third_party::crashpad::wrapper::AddAnnotationsToCrashpad(
- cobalt_version_info);
- SB_DLOG(INFO) << "Added user agent string to Crashpad.";
+ std::vector<char> buffer(USER_AGENT_STRING_MAX_SIZE);
+ starboard::strlcpy(buffer.data(), get_user_agent_func(),
+ USER_AGENT_STRING_MAX_SIZE);
+ if (third_party::crashpad::wrapper::InsertCrashpadAnnotation(
+ third_party::crashpad::wrapper::kCrashpadUserAgentStringKey,
+ buffer.data())) {
+ SB_DLOG(INFO) << "Added user agent string to Crashpad.";
+ } else {
+ SB_DLOG(INFO) << "Failed to add user agent string to Crashpad.";
+ }
}
SB_DLOG(INFO) << "Successfully loaded Cobalt!\n";
diff --git a/starboard/shared/ffmpeg/ffmpeg_demuxer_impl.cc b/starboard/shared/ffmpeg/ffmpeg_demuxer_impl.cc
index 0e6cf9a..ef15ed2 100644
--- a/starboard/shared/ffmpeg/ffmpeg_demuxer_impl.cc
+++ b/starboard/shared/ffmpeg/ffmpeg_demuxer_impl.cc
@@ -247,6 +247,65 @@
}
}
+// Attempts to parse a codec profile from |extradata|. Upon success,
+// |out_profile| is populated with the profile and true is returned. Upon
+// failure, false is returned and |out_profile| is not modified.
+bool TryParseH264Profile(const uint8_t* extradata,
+ size_t extradata_size,
+ CobaltExtensionDemuxerVideoCodecProfile& out_profile) {
+ if (extradata_size < 2) {
+ return false;
+ }
+ const uint8_t version = extradata[0];
+ if (version != 1) {
+ return false;
+ }
+ const int profile = extradata[1];
+ switch (profile) {
+ case FF_PROFILE_H264_BASELINE:
+ out_profile = kCobaltExtensionDemuxerH264ProfileBaseline;
+ return true;
+ case FF_PROFILE_H264_MAIN:
+ out_profile = kCobaltExtensionDemuxerH264ProfileMain;
+ return true;
+ case FF_PROFILE_H264_EXTENDED:
+ out_profile = kCobaltExtensionDemuxerH264ProfileExtended;
+ return true;
+ case FF_PROFILE_H264_HIGH:
+ out_profile = kCobaltExtensionDemuxerH264ProfileHigh;
+ return true;
+ case FF_PROFILE_H264_HIGH_10:
+ out_profile = kCobaltExtensionDemuxerH264ProfileHigh10Profile;
+ return true;
+ case FF_PROFILE_H264_HIGH_422:
+ out_profile = kCobaltExtensionDemuxerH264ProfileHigh422Profile;
+ return true;
+ case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
+ out_profile = kCobaltExtensionDemuxerH264ProfileHigh444PredictiveProfile;
+ return true;
+ default:
+ SB_LOG(ERROR) << "Unknown H264 profile: " << profile;
+ return false;
+ }
+}
+
+// Attempts to parse a codec profile from |extradata|. Upon success,
+// |out_profile| is populated with the profile and true is returned. Upon
+// failure, false is returned and |out_profile| is not modified.
+bool TryParseH265Profile(const uint8_t* extradata,
+ size_t extradata_size,
+ int& out_profile) {
+ if (extradata_size < 2) {
+ return false;
+ }
+ const uint8_t version = extradata[0];
+ if (version != 1) {
+ return false;
+ }
+ out_profile = extradata[1] & 0x1F;
+ return true;
+}
+
int AVIOReadOperation(void* opaque, uint8_t* buf, int buf_size) {
auto* data_source = static_cast<CobaltExtensionDemuxerDataSource*>(opaque);
const int bytes_read =
@@ -898,8 +957,15 @@
config->profile = ProfileIDToVideoCodecProfile(codec_context->profile);
if (config->profile == kCobaltExtensionDemuxerVideoCodecProfileUnknown &&
codec_context->extradata && codec_context->extradata_size) {
- // TODO(b/231631898): handle the extra data here, if necessary.
- SB_LOG(ERROR) << "Extra data is not currently handled.";
+ CobaltExtensionDemuxerVideoCodecProfile profile =
+ kCobaltExtensionDemuxerVideoCodecProfileUnknown;
+ // Attempt to populate profile based on extradata.
+ if (TryParseH264Profile(codec_context->extradata,
+ codec_context->extradata_size, profile)) {
+ config->profile = profile;
+ } else {
+ SB_LOG(ERROR) << "Could not parse H264 profile from extradata.";
+ }
}
break;
}
@@ -915,8 +981,11 @@
#endif // FF_PROFILE_HEVC_REXT
) &&
codec_context->extradata && codec_context->extradata_size) {
- // TODO(b/231631898): handle the extra data here, if necessary.
- SB_LOG(ERROR) << "Extra data is not currently handled.";
+ // Attempt to populate hevc_profile based on extradata.
+ if (!TryParseH265Profile(codec_context->extradata,
+ codec_context->extradata_size, hevc_profile)) {
+ SB_LOG(ERROR) << "Could not parse H265 profile from extradata.";
+ }
} else {
hevc_profile = codec_context->profile;
}
diff --git a/starboard/shared/starboard/crash_handler.cc b/starboard/shared/starboard/crash_handler.cc
index 572a022..0d6ec2d 100644
--- a/starboard/shared/starboard/crash_handler.cc
+++ b/starboard/shared/starboard/crash_handler.cc
@@ -25,14 +25,16 @@
namespace {
bool OverrideCrashpadAnnotations(CrashpadAnnotations* crashpad_annotations) {
- CrashpadAnnotations annotations;
- memset(&annotations, 0, sizeof(CrashpadAnnotations));
- memcpy(&annotations, crashpad_annotations, sizeof(CrashpadAnnotations));
- return third_party::crashpad::wrapper::AddAnnotationsToCrashpad(annotations);
+ return false; // Deprecated
+}
+
+bool SetString(const char* key, const char* value) {
+ return third_party::crashpad::wrapper::InsertCrashpadAnnotation(key, value);
}
const CobaltExtensionCrashHandlerApi kCrashHandlerApi = {
- kCobaltExtensionCrashHandlerName, 1, &OverrideCrashpadAnnotations,
+ kCobaltExtensionCrashHandlerName, 2, &OverrideCrashpadAnnotations,
+ &SetString,
};
} // namespace
diff --git a/starboard/shared/starboard/player/filter/video_renderer_internal_impl.cc b/starboard/shared/starboard/player/filter/video_renderer_internal_impl.cc
index b07a4fe..0e11da1 100644
--- a/starboard/shared/starboard/player/filter/video_renderer_internal_impl.cc
+++ b/starboard/shared/starboard/player/filter/video_renderer_internal_impl.cc
@@ -122,7 +122,6 @@
#if SB_PLAYER_FILTER_ENABLE_STATE_CHECK
first_input_written_at_ = SbTimeGetMonotonicNow();
#endif // SB_PLAYER_FILTER_ENABLE_STATE_CHECK
- absolute_time_of_first_input_ = SbTimeGetMonotonicNow();
}
SB_DCHECK(need_more_input_.load());
diff --git a/starboard/shared/starboard/player/filter/video_renderer_internal_impl.h b/starboard/shared/starboard/player/filter/video_renderer_internal_impl.h
index ee8bad0..a2fd2e4 100644
--- a/starboard/shared/starboard/player/filter/video_renderer_internal_impl.h
+++ b/starboard/shared/starboard/player/filter/video_renderer_internal_impl.h
@@ -92,7 +92,6 @@
PrerolledCB prerolled_cb_;
EndedCB ended_cb_;
- SbTimeMonotonic absolute_time_of_first_input_ = 0;
// Our owner will attempt to seek to time 0 when playback begins. In
// general, seeking could require a full reset of the underlying decoder on
// some platforms, so we make an effort to improve playback startup
diff --git a/starboard/shared/win32/audio_decoder.cc b/starboard/shared/win32/audio_decoder.cc
index d404441..0b54739 100644
--- a/starboard/shared/win32/audio_decoder.cc
+++ b/starboard/shared/win32/audio_decoder.cc
@@ -61,9 +61,19 @@
: audio_codec_(audio_codec),
audio_sample_info_(audio_sample_info),
drm_system_(drm_system),
- sample_type_(kSbMediaAudioSampleTypeFloat32),
+ sample_type_((audio_codec == kSbMediaAudioCodecAc3 ||
+ audio_codec == kSbMediaAudioCodecEac3)
+ ?
+#if SB_HAS_QUIRK(SUPPORT_INT16_AUDIO_SAMPLES)
+ kSbMediaAudioSampleTypeInt16
+#else
+ kSbMediaAudioSampleTypeInt16Deprecated
+#endif // SB_HAS_QUIRK(SUPPORT_INT16_AUDIO_SAMPLES)
+ : kSbMediaAudioSampleTypeFloat32),
stream_ended_(false) {
- SB_DCHECK(audio_codec == kSbMediaAudioCodecAac);
+ SB_DCHECK(audio_codec == kSbMediaAudioCodecAac ||
+ audio_codec == kSbMediaAudioCodecAc3 ||
+ audio_codec == kSbMediaAudioCodecEac3);
}
AudioDecoder::~AudioDecoder() {
diff --git a/starboard/shared/win32/audio_transform.cc b/starboard/shared/win32/audio_transform.cc
index 5a03f94..81aebd0 100644
--- a/starboard/shared/win32/audio_transform.cc
+++ b/starboard/shared/win32/audio_transform.cc
@@ -14,9 +14,12 @@
#include "starboard/shared/win32/audio_transform.h"
+#include <mfapi.h>
+
#include <vector>
#include "starboard/memory.h"
+#include "starboard/shared/uwp/wasapi_include.h"
#include "starboard/shared/win32/error_utils.h"
#include "starboard/shared/win32/media_common.h"
#include "starboard/shared/win32/media_foundation_utils.h"
@@ -40,6 +43,12 @@
case kSbMediaAudioCodecOpus: {
return MFAudioFormat_Opus;
}
+ case kSbMediaAudioCodecAc3: {
+ return MFAudioFormat_Dolby_AC3;
+ }
+ case kSbMediaAudioCodecEac3: {
+ return MFAudioFormat_Dolby_DDPlus;
+ }
default: {
SB_NOTIMPLEMENTED();
return MFAudioFormat_PCM;
@@ -47,9 +56,55 @@
}
}
+GUID ConvertToWin32TransformType(SbMediaAudioCodec codec) {
+ switch (codec) {
+ case kSbMediaAudioCodecAac: {
+ return CLSID_MSAACDecMFT;
+ }
+ case kSbMediaAudioCodecAc3:
+ case kSbMediaAudioCodecEac3: {
+ return CLSID_MSDDPlusDecMFT;
+ }
+ default: {
+ SB_NOTIMPLEMENTED();
+ return MFAudioFormat_Float;
+ }
+ }
+}
+
+GUID ConvertToWin32OutputFormat(SbMediaAudioCodec codec) {
+ switch (codec) {
+ case kSbMediaAudioCodecAac:
+ case kSbMediaAudioCodecOpus:
+ case kSbMediaAudioCodecNone: {
+ return MFAudioFormat_Float;
+ }
+ case kSbMediaAudioCodecAc3: {
+ return MFAudioFormat_Dolby_AC3_SPDIF;
+ }
+ case kSbMediaAudioCodecEac3: {
+ return KSDATAFORMAT_SUBTYPE_IEC61937_DOLBY_DIGITAL_PLUS;
+ }
+ default: {
+ SB_NOTIMPLEMENTED();
+ return MFAudioFormat_Float;
+ }
+ }
+}
+
class WinAudioFormat {
public:
explicit WinAudioFormat(const SbMediaAudioSampleInfo& audio_sample_info) {
+ if (audio_sample_info.codec == kSbMediaAudioCodecAac) {
+ CreateAacAudioFormat(audio_sample_info);
+ } else {
+ SB_DCHECK(audio_sample_info.codec == kSbMediaAudioCodecAc3 ||
+ audio_sample_info.codec == kSbMediaAudioCodecEac3);
+ CreateAc3AudioFormat(audio_sample_info);
+ }
+ }
+
+ void CreateAacAudioFormat(const SbMediaAudioSampleInfo& audio_sample_info) {
// The HEAACWAVEFORMAT structure has many specializations with varying data
// appended at the end.
// The "-1" is used to account for pbAudioSpecificConfig[1] at the end of
@@ -78,11 +133,32 @@
if (audio_sample_info.audio_specific_config_size > 0) {
memcpy(wave_format->pbAudioSpecificConfig,
- audio_sample_info.audio_specific_config,
- audio_sample_info.audio_specific_config_size);
+ audio_sample_info.audio_specific_config,
+ audio_sample_info.audio_specific_config_size);
}
}
+ void CreateAc3AudioFormat(const SbMediaAudioSampleInfo& audio_sample_info) {
+ format_buffer_.resize(sizeof(WAVEFORMATEXTENSIBLE));
+ WAVEFORMATEXTENSIBLE* wave_format =
+ reinterpret_cast<WAVEFORMATEXTENSIBLE*>(format_buffer_.data());
+
+ wave_format->Format.wFormatTag = WAVE_FORMAT_EXTENSIBLE;
+ wave_format->Format.nChannels = audio_sample_info.number_of_channels;
+ wave_format->Format.wBitsPerSample = audio_sample_info.bits_per_sample;
+ wave_format->Format.nSamplesPerSec = audio_sample_info.samples_per_second;
+ wave_format->Format.nBlockAlign = audio_sample_info.block_alignment;
+ wave_format->Format.nAvgBytesPerSec = 0;
+ wave_format->Format.cbSize =
+ sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX);
+ wave_format->Samples.wValidBitsPerSample =
+ wave_format->Format.wBitsPerSample;
+ wave_format->dwChannelMask = audio_sample_info.number_of_channels > 2
+ ? KSAUDIO_SPEAKER_5POINT1
+ : KSAUDIO_SPEAKER_STEREO;
+ wave_format->SubFormat = ConvertToWin32AudioCodec(audio_sample_info.codec);
+ }
+
WAVEFORMATEX* WaveFormatData() {
return reinterpret_cast<WAVEFORMATEX*>(format_buffer_.data());
}
@@ -97,8 +173,12 @@
scoped_ptr<MediaTransform> CreateAudioTransform(
const SbMediaAudioSampleInfo& audio,
SbMediaAudioCodec codec) {
+ SB_DCHECK(codec == kSbMediaAudioCodecAac || codec == kSbMediaAudioCodecAc3 ||
+ codec == kSbMediaAudioCodecEac3);
ComPtr<IMFTransform> transform;
- HRESULT hr = CreateDecoderTransform(CLSID_MSAACDecMFT, &transform);
+ HRESULT hr =
+ CreateDecoderTransform(ConvertToWin32TransformType(codec), &transform);
+
CheckResult(hr);
ComPtr<IMFMediaType> input_type;
@@ -123,7 +203,7 @@
scoped_ptr<MediaTransform> output(new MediaTransform(transform));
output->SetInputType(selected);
- output->SetOutputTypeBySubType(MFAudioFormat_Float);
+ output->SetOutputTypeBySubType(ConvertToWin32OutputFormat(codec));
return output.Pass();
}
diff --git a/starboard/shared/win32/win32_audio_decoder.cc b/starboard/shared/win32/win32_audio_decoder.cc
index df49374..fdfb0c0 100644
--- a/starboard/shared/win32/win32_audio_decoder.cc
+++ b/starboard/shared/win32/win32_audio_decoder.cc
@@ -19,6 +19,7 @@
#include "starboard/atomic.h"
#include "starboard/shared/starboard/thread_checker.h"
+#include "starboard/shared/uwp/wasapi_include.h"
#include "starboard/shared/win32/atomic_queue.h"
#include "starboard/shared/win32/audio_decoder.h"
#include "starboard/shared/win32/audio_transform.h"
@@ -35,10 +36,23 @@
using ::starboard::shared::win32::CreateAudioTransform;
const size_t kAacSamplesPerFrame = 1024;
-// We are using float samples on Xb1.
-const size_t kBytesPerSample = sizeof(float);
+// We are using float samples for AAC on Xb1.
+const size_t kAacBytesPerSample = sizeof(float);
namespace {
+size_t GetExpectedBufferSize(SbMediaAudioCodec codec, int num_channels) {
+ switch (codec) {
+ case kSbMediaAudioCodecAac:
+ return num_channels * kAacSamplesPerFrame * kAacBytesPerSample;
+ case kSbMediaAudioCodecAc3:
+ return kAc3BufferSize;
+ case kSbMediaAudioCodecEac3:
+ return kEac3BufferSize;
+ default:
+ SB_NOTREACHED();
+ return size_t(0);
+ }
+}
class AbstractWin32AudioDecoderImpl : public AbstractWin32AudioDecoder {
public:
@@ -53,12 +67,27 @@
sample_type_(sample_type),
number_of_channels_(audio_sample_info.number_of_channels),
heaac_detected_(false),
- samples_per_second_(
- static_cast<int>(audio_sample_info.samples_per_second)) {
+ expected_buffer_size_(
+ GetExpectedBufferSize(codec,
+ audio_sample_info.number_of_channels)) {
scoped_ptr<MediaTransform> audio_decoder =
CreateAudioTransform(audio_sample_info, codec_);
impl_.reset(
new DecryptingDecoder("audio", audio_decoder.Pass(), drm_system));
+ switch (codec) {
+ case kSbMediaAudioCodecAc3:
+ samples_per_second_ = kAc3SamplesPerSecond;
+ number_of_channels_ = kIec60958Channels;
+ break;
+ case kSbMediaAudioCodecEac3:
+ samples_per_second_ = kEac3SamplesPerSecond;
+ number_of_channels_ = kIec60958Channels;
+ break;
+ default:
+ samples_per_second_ =
+ static_cast<int>(audio_sample_info.samples_per_second);
+ number_of_channels_ = audio_sample_info.number_of_channels;
+ }
}
void Consume(ComPtr<IMFSample> sample) {
@@ -86,13 +115,18 @@
const uint8_t* data = reinterpret_cast<uint8_t*>(buffer);
const size_t data_size = static_cast<size_t>(length);
- const size_t expect_size_in_bytes =
- number_of_channels_ * kAacSamplesPerFrame * kBytesPerSample;
- if (data_size / expect_size_in_bytes == 2) {
+ if (codec_ == kSbMediaAudioCodecAac &&
+ (data_size / expected_buffer_size_ == 2)) {
heaac_detected_.store(true);
}
- const size_t decoded_data_size = std::max(expect_size_in_bytes, data_size);
+ const size_t decoded_data_size = std::max(expected_buffer_size_, data_size);
+
+ if (codec_ == kSbMediaAudioCodecAc3) {
+ SB_DCHECK(decoded_data_size == kAc3BufferSize);
+ } else if (codec_ == kSbMediaAudioCodecEac3) {
+ SB_DCHECK(decoded_data_size == kEac3BufferSize);
+ }
DecodedAudioPtr data_ptr(
new DecodedAudio(number_of_channels_, sample_type_, audio_frame_fmt_,
@@ -109,12 +143,14 @@
bool TryWrite(const scoped_refptr<InputBuffer>& buff) override {
SB_DCHECK(thread_checker_.CalledOnValidThread());
- // The incoming audio is in ADTS format which has a 7 bytes header. But
- // the audio decoder is configured to accept raw AAC. So we have to adjust
- // the data, size, and subsample mapping to skip the ADTS header.
- const int kADTSHeaderSize = 7;
- const bool write_ok = impl_->TryWriteInputBuffer(buff, kADTSHeaderSize);
- return write_ok;
+ if (codec_ == kSbMediaAudioCodecAac) {
+ // The incoming audio is in ADTS format which has a 7 bytes header. But
+ // the audio decoder is configured to accept raw AAC. So we have to
+ // adjust the data, size, and subsample mapping to skip the ADTS header.
+ const int kADTSHeaderSize = 7;
+ return impl_->TryWriteInputBuffer(buff, kADTSHeaderSize);
+ }
+ return impl_->TryWriteInputBuffer(buff, 0);
}
void WriteEndOfStream() override {
@@ -182,6 +218,7 @@
uint16_t number_of_channels_;
atomic_bool heaac_detected_;
int samples_per_second_;
+ const size_t expected_buffer_size_;
};
} // anonymous namespace.
diff --git a/starboard/tools/testing/sharding_configuration.json b/starboard/tools/testing/sharding_configuration.json
index 7dbbc2b..0641b05 100644
--- a/starboard/tools/testing/sharding_configuration.json
+++ b/starboard/tools/testing/sharding_configuration.json
@@ -56,5 +56,94 @@
"net_unittests": [2, 2],
"player_filter_tests": [2, 2]
}
+ ],
+ "raspi-2":[
+ {
+ "base_unittests": [1, 6],
+ "layout_tests": [5, 6],
+ "net_unittests": [2, 6],
+ "player_filter_tests": [1, 6],
+ "renderer_test": [6, 6]
+ },
+ {
+ "base_unittests": [2, 6],
+ "layout_tests": [4, 6],
+ "net_unittests": [1, 6],
+ "nplb": [1, 5],
+ "player_filter_tests": [5, 6],
+ "renderer_test": [5, 6]
+ },
+ {
+ "base_unittests": [3, 6],
+ "layout_tests": [6, 6],
+ "net_unittests": [4, 6],
+ "nplb": [4, 5],
+ "player_filter_tests": [3, 6],
+ "renderer_test": [1, 6]
+ },
+ {
+ "base_unittests": [5, 6],
+ "layout_tests": [3, 6],
+ "net_unittests": [5, 6],
+ "nplb": [2, 5],
+ "player_filter_tests": [2, 6],
+ "renderer_test": [2, 6]
+ },
+ {
+ "base_unittests": [6, 6],
+ "layout_tests": [1, 6],
+ "net_unittests": [3, 6],
+ "nplb": [3, 5],
+ "player_filter_tests": [4, 6],
+ "renderer_test": [4, 6]
+ },
+ {
+ "app_key_files_test": "*",
+ "app_key_test": "*",
+ "audio_test": "*",
+ "base_test": "*",
+ "base_unittests": [4, 6],
+ "bindings_test": "*",
+ "browser_test": "*",
+ "crypto_unittests": "*",
+ "csp_test": "*",
+ "css_parser_test": "*",
+ "cssom_test": "*",
+ "cwrappers_test": "*",
+ "dom_parser_test": "*",
+ "dom_test": "*",
+ "drain_file_test": "*",
+ "elf_loader_test": "*",
+ "extension_test": "*",
+ "graphics_system_test": "*",
+ "installation_manager_test": "*",
+ "layout_test": "*",
+ "layout_tests": [2, 6],
+ "loader_test": "*",
+ "math_test": "*",
+ "media_capture_test": "*",
+ "media_session_test": "*",
+ "media_stream_test": "*",
+ "memory_store_test": "*",
+ "nb_test": "*",
+ "net_unittests": [6, 6],
+ "network_test": "*",
+ "nplb": [5, 5],
+ "player_filter_tests": [6, 6],
+ "poem_unittests": "*",
+ "render_tree_test": "*",
+ "renderer_test": [3, 6],
+ "slot_management_test": "*",
+ "starboard_platform_tests": "*",
+ "storage_test": "*",
+ "text_encoding_test": "*",
+ "web_animations_test": "*",
+ "web_test": "*",
+ "webdriver_test": "*",
+ "websocket_test": "*",
+ "worker_test": "*",
+ "xhr_test": "*",
+ "zip_unittests": "*"
+ }
]
}
diff --git a/starboard/tools/testing/test_runner.py b/starboard/tools/testing/test_runner.py
index fe2fde7..2fc8f24 100755
--- a/starboard/tools/testing/test_runner.py
+++ b/starboard/tools/testing/test_runner.py
@@ -428,7 +428,7 @@
if gtest_filter_value:
test_params.append("--gtest_filter=" + gtest_filter_value)
- if shard_index and shard_count:
+ if shard_count is not None:
test_params.append("--gtest_total_shards={}".format(shard_count))
test_params.append("--gtest_shard_index={}".format(shard_index))
diff --git a/starboard/win/shared/BUILD.gn b/starboard/win/shared/BUILD.gn
index 5f20368..162b1c5 100644
--- a/starboard/win/shared/BUILD.gn
+++ b/starboard/win/shared/BUILD.gn
@@ -180,6 +180,7 @@
"//starboard/shared/stub/window_set_on_screen_keyboard_keep_focus.cc",
"//starboard/shared/stub/window_show_on_screen_keyboard.cc",
"//starboard/shared/stub/window_update_on_screen_keyboard_suggestions.cc",
+ "//starboard/shared/uwp/wasapi_include.h",
"//starboard/shared/win32/adapter_utils.cc",
"//starboard/shared/win32/adapter_utils.h",
"//starboard/shared/win32/atomic_public.h",
diff --git a/third_party/angle/src/libANGLE/renderer/d3d/DynamicHLSL.cpp b/third_party/angle/src/libANGLE/renderer/d3d/DynamicHLSL.cpp
index d50e5f3..18d2410 100644
--- a/third_party/angle/src/libANGLE/renderer/d3d/DynamicHLSL.cpp
+++ b/third_party/angle/src/libANGLE/renderer/d3d/DynamicHLSL.cpp
@@ -75,7 +75,7 @@
" float3 j = pow(SRGB_OETF(i), gamma);\n"
" float3 adj = (minLNits + (maxLNits - minLNits) * j) / kRefWhiteLevelSRGB;\n"
" float3 cri_float = (float3)cri;\n"
- " float3 ret = lerp(adj, L, cri_float);\n"
+ " float3 ret = lerp(L, adj, cri_float);\n"
" return ret;\n"
"}\n"
"//input: normalized L in units of RefWhite (1.0=100nits), output: normalized E\n"
@@ -97,7 +97,7 @@
"{\n"
" PS_OUTPUT output;\n"
" \n"
- " float3 input_colors = gl_Color[0].rgb;\n"
+ " float3 input_colors = max(gl_Color[0].rgb, 0);\n"
" float3 lin_osd_graphics = SRGB_EOTF(input_colors);\n"
" lin_osd_graphics = mul(BT709_TO_BT2020, lin_osd_graphics);\n"
" lin_osd_graphics *= kMaxNits/kRefWhiteLevelSRGB;\n"
diff --git a/third_party/crashpad/client/BUILD.gn b/third_party/crashpad/client/BUILD.gn
index 19aa8db..6ecd5c5 100644
--- a/third_party/crashpad/client/BUILD.gn
+++ b/third_party/crashpad/client/BUILD.gn
@@ -90,12 +90,13 @@
"../util",
]
+ deps = []
+
if (crashpad_is_in_starboard) {
public_deps += [ "//starboard/elf_loader:evergreen_info" ]
+ deps += [ "../wrapper/proto:crashpad_annotations_proto" ]
}
- deps = []
-
if (crashpad_is_win) {
libs = [ "rpcrt4.lib" ]
cflags = [ "/wd4201" ] # nonstandard extension used : nameless struct/union
diff --git a/third_party/crashpad/client/crashpad_client.h b/third_party/crashpad/client/crashpad_client.h
index 9dd12dd..4cf5a0e 100644
--- a/third_party/crashpad/client/crashpad_client.h
+++ b/third_party/crashpad/client/crashpad_client.h
@@ -41,7 +41,6 @@
#if defined(STARBOARD)
#include "starboard/elf_loader/evergreen_info.h"
#include "third_party/crashpad/snapshot/sanitized/sanitization_information.h"
-#include "third_party/crashpad/wrapper/annotations.h"
#endif
namespace crashpad {
@@ -391,14 +390,17 @@
//! \return `true` on success, `false` on failure with a message logged.
static bool SendEvergreenInfoToHandler(EvergreenInfo evergreen_info);
- //! \brief Sends mapping info to the handler
+ //! \brief Inserts annotation mapping info for the handler
//!
- //! A handler must have already been installed before calling this method.
- //! \param[in] annotations A CrashpadAnnotations struct, whose information
- //! was created on Evergreen startup.
+ //! A signal handler must have already been installed before calling this
+ //! method. Whether or not the annotation is sent to the Crashpad handler,
+ //! or just prepared to be sent, depends on whether the Crashpad handler is
+ //! started at launch or at crash.
+ //! \param[in] key The annotation's key.
+ //! \param[in] value The annotation's value.
//!
//! \return `true` on success, `false` on failure with a message logged.
- static bool SendAnnotationsToHandler(CrashpadAnnotations annotations);
+ static bool InsertAnnotationForHandler(const char* key, const char* value);
//! \brief Sends mapping info to the handler
//!
diff --git a/third_party/crashpad/client/crashpad_client_linux.cc b/third_party/crashpad/client/crashpad_client_linux.cc
index 5738668..1b579bf 100644
--- a/third_party/crashpad/client/crashpad_client_linux.cc
+++ b/third_party/crashpad/client/crashpad_client_linux.cc
@@ -26,6 +26,7 @@
#include "base/logging.h"
#include "base/strings/stringprintf.h"
#include "client/client_argv_handling.h"
+#include "starboard/common/mutex.h"
#include "third_party/lss/lss.h"
#include "util/file/file_io.h"
#include "util/file/filesystem.h"
@@ -37,6 +38,15 @@
#include "util/misc/from_pointer_cast.h"
#include "util/posix/double_fork_and_exec.h"
#include "util/posix/signals.h"
+// TODO(b/201538792): resolve conflict between mini_chromium and base functions.
+#ifdef LogMessage
+#define LOG_MESSAGE_DEFINED
+#undef LogMessage
+#endif
+#include "third_party/crashpad/wrapper/proto/crashpad_annotations.pb.h"
+#ifdef LOG_MESSAGE_DEFINED
+#define LogMessage MLogMessage
+#endif
namespace crashpad {
@@ -44,9 +54,7 @@
#if defined(STARBOARD)
constexpr char kEvergreenInfoKey[] = "evergreen-information";
-constexpr char kProductKey[] = "annotation=prod";
-constexpr char kVersionKey[] = "annotation=ver";
-constexpr char kUAKey[] = "annotation=user_agent_string";
+constexpr char kAnnotationKey[] = "annotation=%s";
#endif
std::string FormatArgumentInt(const std::string& name, int value) {
@@ -183,10 +191,10 @@
return SendEvergreenInfoImpl();
}
- bool SendAnnotations(CrashpadAnnotations annotations) {
- annotations_ = annotations;
- return SendAnnotationsImpl();
+ bool InsertAnnotation(const char* key, const char* value) {
+ return InsertAnnotationImpl(key, value);
}
+
#endif
// The base implementation for all signal handlers, suitable for calling
@@ -227,7 +235,6 @@
#if defined(STARBOARD)
const EvergreenInfo& GetEvergreenInfo() { return evergreen_info_; }
- const CrashpadAnnotations& GetAnnotations() { return annotations_; }
const SanitizationInformation& GetSanitizationInformation() {
return sanitization_information_;
}
@@ -239,7 +246,7 @@
#if defined(STARBOARD)
virtual bool SendEvergreenInfoImpl() = 0;
- virtual bool SendAnnotationsImpl() = 0;
+ virtual bool InsertAnnotationImpl(const char* key, const char* value) = 0;
#endif
virtual void HandleCrashImpl() = 0;
@@ -262,7 +269,6 @@
#if defined(STARBOARD)
EvergreenInfo evergreen_info_;
- CrashpadAnnotations annotations_;
SanitizationInformation sanitization_information_;
#endif
@@ -297,12 +303,18 @@
argv_strings_.push_back(FormatArgumentAddress("trace-parent-with-exception",
&GetExceptionInfo()));
+#if defined(STARBOARD)
+ argv_strings_.push_back("--handler-started-at-crash");
+#endif
+
StringVectorToCStringVector(argv_strings_, &argv_);
return Install(unhandled_signals);
}
#if defined(STARBOARD)
bool SendEvergreenInfoImpl() override {
+ starboard::ScopedLock scoped_lock(argv_lock_);
+
bool updated = false;
for (auto& s : argv_strings_) {
if (s.compare(2, strlen(kEvergreenInfoKey), kEvergreenInfoKey) == 0) {
@@ -324,27 +336,19 @@
return true;
}
- bool SendAnnotationsImpl() override {
- bool updated_product = false;
- bool updated_version = false;
- bool updated_user_agent_string = false;
+ bool InsertAnnotationImpl(const char* key, const char* value) override {
+ starboard::ScopedLock scoped_lock(argv_lock_);
+
+ std::string formatted_key = base::StringPrintf(kAnnotationKey, key);
+ bool updated_annotation = false;
for (auto& s : argv_strings_) {
- if (UpdateAnnotation(s, kProductKey, GetAnnotations().product)) {
- updated_product = true;
- } else if (UpdateAnnotation(s, kVersionKey, GetAnnotations().version)) {
- updated_version = true;
- } else if (UpdateAnnotation(s, kUAKey, GetAnnotations().user_agent_string)) {
- updated_user_agent_string = true;
+ if (UpdateAnnotation(s, formatted_key, value)) {
+ updated_annotation = true;
}
}
- if (!updated_product) {
- AddAnnotation(argv_strings_, kProductKey, GetAnnotations().product);
- }
- if (!updated_version) {
- AddAnnotation(argv_strings_, kVersionKey, GetAnnotations().version);
- }
- if (!updated_user_agent_string) {
- AddAnnotation(argv_strings_, kUAKey, GetAnnotations().user_agent_string);
+
+ if (!updated_annotation) {
+ AddAnnotation(argv_strings_, formatted_key, value);
}
StringVectorToCStringVector(argv_strings_, &argv_);
@@ -382,6 +386,10 @@
std::vector<std::string> argv_strings_;
std::vector<const char*> argv_;
+#if defined(STARBOARD)
+ // Protects access to both argv_strings_ and argv_.
+ starboard::Mutex argv_lock_;
+#endif
std::vector<std::string> envp_strings_;
std::vector<const char*> envp_;
bool set_envp_ = false;
@@ -446,6 +454,10 @@
}
#if defined(STARBOARD)
+ char* GetSerializedAnnotations() {
+ return serialized_annotations_.data();
+ }
+
bool SendEvergreenInfoImpl() override {
ExceptionHandlerClient client(sock_to_handler_.get(), true);
ExceptionHandlerProtocol::ClientInformation info = {};
@@ -455,13 +467,36 @@
return true;
}
- bool SendAnnotationsImpl() override {
+ bool InsertAnnotationImpl(const char* key, const char* value) override {
+ starboard::ScopedLock scoped_lock(annotations_lock_);
+
+ std::string key_str(key);
+ std::string value_str(value);
+
+ if (strcmp(key, "ver") == 0) {
+ annotations_.set_ver(value_str);
+ } else if (strcmp(key, "prod") == 0) {
+ annotations_.set_prod(value_str);
+ } else if (strcmp(key, "user_agent_string") == 0) {
+ annotations_.set_user_agent_string(value_str);
+ } else {
+ (*annotations_.mutable_runtime_annotations())[key_str] = value_str;
+ }
+
+ serialized_annotations_.resize(annotations_.ByteSize());
+ annotations_.SerializeToArray(serialized_annotations_.data(),
+ annotations_.ByteSize());
+
ExceptionHandlerClient client(sock_to_handler_.get(), true);
ExceptionHandlerProtocol::ClientInformation info = {};
- info.annotations_address = FromPointerCast<VMAddress>(&GetAnnotations());
+ info.serialized_annotations_address = FromPointerCast<VMAddress>(
+ GetSerializedAnnotations());
+ info.serialized_annotations_size = serialized_annotations_.size();
client.SendAnnotations(info);
+
return true;
}
+
#endif
void HandleCrashImpl() override {
@@ -471,9 +506,12 @@
#if defined(STARBOARD)
info.sanitization_information_address =
FromPointerCast<VMAddress>(&GetSanitizationInformation());
- info.annotations_address = FromPointerCast<VMAddress>(&GetAnnotations());
+ info.serialized_annotations_address = FromPointerCast<VMAddress>(
+ GetSerializedAnnotations());
+ info.serialized_annotations_size = serialized_annotations_.size();
info.evergreen_information_address =
FromPointerCast<VMAddress>(&GetEvergreenInfo());
+ info.handler_start_type = ExceptionHandlerProtocol::kStartAtLaunch;
#endif
#if defined(OS_CHROMEOS)
@@ -497,6 +535,13 @@
ScopedFileHandle sock_to_handler_;
pid_t handler_pid_ = -1;
+#if defined(STARBOARD)
+ crashpad::wrapper::CrashpadAnnotations annotations_;
+ std::vector<char> serialized_annotations_;
+
+ // Protects access to both annotations_ and serialized_annotations_;
+ starboard::Mutex annotations_lock_;
+#endif
#if defined(OS_CHROMEOS)
// An optional UNIX timestamp passed to us from Chrome.
@@ -694,14 +739,14 @@
return SignalHandler::Get()->SendEvergreenInfo(evergreen_info);
}
-bool CrashpadClient::SendAnnotationsToHandler(
- CrashpadAnnotations annotations) {
+bool CrashpadClient::InsertAnnotationForHandler(
+ const char* key, const char* value) {
if (!SignalHandler::Get()) {
DLOG(ERROR) << "Crashpad isn't enabled";
return false;
}
- return SignalHandler::Get()->SendAnnotations(annotations);
+ return SignalHandler::Get()->InsertAnnotation(key, value);
}
bool CrashpadClient::SendSanitizationInformationToHandler(
diff --git a/third_party/crashpad/handler/handler_main.cc b/third_party/crashpad/handler/handler_main.cc
index 51bd64e..cbf9bb5 100644
--- a/third_party/crashpad/handler/handler_main.cc
+++ b/third_party/crashpad/handler/handler_main.cc
@@ -172,6 +172,9 @@
#if defined(STARBOARD)
" --evergreen-information=EVERGREEN_INFORMATION_ADDRESS\n"
" the address of a EvegreenInfo struct.\n"
+" --handler-started-at-crash\n"
+" the handler was started at time of crash, as\n"
+" opposed to time of launch\n"
#endif
" --url=URL send crash reports to this Breakpad server URL,\n"
" only if uploads are enabled for the database\n"
@@ -214,6 +217,7 @@
bool shared_client_connection;
#if defined(STARBOARD)
VMAddress evergreen_information_address;
+ bool handler_started_at_crash = false;
#endif // defined(STARBOARD)
#if defined(OS_ANDROID)
bool write_minidump_to_log;
@@ -590,6 +594,7 @@
kOptionTraceParentWithException,
#if defined(STARBOARD)
kOptionEvergreenInformaton,
+ kOptionHandlerStartedAtCrash,
#endif // defined(STARBOARD)
#endif
kOptionURL,
@@ -676,6 +681,10 @@
required_argument,
nullptr,
kOptionEvergreenInformaton},
+ {"handler-started-at-crash",
+ no_argument,
+ nullptr,
+ kOptionHandlerStartedAtCrash},
#endif
{"url", required_argument, nullptr, kOptionURL},
#if defined(OS_CHROMEOS)
@@ -850,6 +859,10 @@
}
break;
}
+ case kOptionHandlerStartedAtCrash: {
+ options.handler_started_at_crash = true;
+ break;
+ }
#endif // defined(STARBOARD)
#endif // OS_LINUX || OS_ANDROID
case kOptionURL: {
@@ -1070,6 +1083,9 @@
#if defined(STARBOARD)
info.evergreen_information_address =
options.evergreen_information_address;
+ if (options.handler_started_at_crash) {
+ info.handler_start_type = ExceptionHandlerProtocol::kStartAtCrash;
+ }
#endif // defined(STARBOARD)
return exception_handler->HandleException(getppid(), geteuid(), info)
? EXIT_SUCCESS
diff --git a/third_party/crashpad/handler/linux/capture_snapshot.cc b/third_party/crashpad/handler/linux/capture_snapshot.cc
index 8fb0735..59350fd 100644
--- a/third_party/crashpad/handler/linux/capture_snapshot.cc
+++ b/third_party/crashpad/handler/linux/capture_snapshot.cc
@@ -31,19 +31,15 @@
VMAddress requesting_thread_stack_address,
pid_t* requesting_thread_id,
std::unique_ptr<ProcessSnapshotLinux>* snapshot,
- std::unique_ptr<ProcessSnapshotSanitized>* sanitized_snapshot
-#if defined(STARBOARD)
- ,
- VMAddress evergreen_information_address,
- VMAddress annotations_address
-#endif
- ) {
+ std::unique_ptr<ProcessSnapshotSanitized>* sanitized_snapshot) {
std::unique_ptr<ProcessSnapshotLinux> process_snapshot(
new ProcessSnapshotLinux());
#if defined(STARBOARD)
if (!process_snapshot->Initialize(connection,
info.evergreen_information_address,
- info.annotations_address)) {
+ info.serialized_annotations_address,
+ info.serialized_annotations_size,
+ info.handler_start_type)) {
#else
if (!process_snapshot->Initialize(connection)) {
#endif
diff --git a/third_party/crashpad/handler/linux/capture_snapshot.h b/third_party/crashpad/handler/linux/capture_snapshot.h
index 51eca35..b01e316 100644
--- a/third_party/crashpad/handler/linux/capture_snapshot.h
+++ b/third_party/crashpad/handler/linux/capture_snapshot.h
@@ -64,13 +64,7 @@
VMAddress requesting_thread_stack_address,
pid_t* requesting_thread_id,
std::unique_ptr<ProcessSnapshotLinux>* process_snapshot,
- std::unique_ptr<ProcessSnapshotSanitized>* sanitized_snapshot
-#if defined(STARBOARD)
- ,
- VMAddress evergreen_information_address,
- VMAddress annotations_address
-#endif
- );
+ std::unique_ptr<ProcessSnapshotSanitized>* sanitized_snapshot);
} // namespace crashpad
diff --git a/third_party/crashpad/handler/linux/crash_report_exception_handler.cc b/third_party/crashpad/handler/linux/crash_report_exception_handler.cc
index b0f68ce..9a86073 100644
--- a/third_party/crashpad/handler/linux/crash_report_exception_handler.cc
+++ b/third_party/crashpad/handler/linux/crash_report_exception_handler.cc
@@ -89,7 +89,8 @@
bool CrashReportExceptionHandler::AddAnnotations(
const ExceptionHandlerProtocol::ClientInformation& info) {
- annotations_address_ = info.annotations_address;
+ serialized_annotations_address_ = info.serialized_annotations_address;
+ serialized_annotations_size_ = info.serialized_annotations_size;
return true;
}
#endif
@@ -153,13 +154,7 @@
requesting_thread_stack_address,
requesting_thread_id,
&process_snapshot,
- &sanitized_snapshot
-#if defined(STARBOARD)
- ,
- evergreen_info_,
- annotations_address_
-#endif
- )) {
+ &sanitized_snapshot)) {
return false;
}
diff --git a/third_party/crashpad/handler/linux/crash_report_exception_handler.h b/third_party/crashpad/handler/linux/crash_report_exception_handler.h
index 5cca2ad..7a32ac0 100644
--- a/third_party/crashpad/handler/linux/crash_report_exception_handler.h
+++ b/third_party/crashpad/handler/linux/crash_report_exception_handler.h
@@ -122,7 +122,8 @@
const UserStreamDataSources* user_stream_data_sources_; // weak
#if defined(STARBOARD)
VMAddress evergreen_info_;
- VMAddress annotations_address_;
+ VMAddress serialized_annotations_address_;
+ int serialized_annotations_size_;
#endif
DISALLOW_COPY_AND_ASSIGN(CrashReportExceptionHandler);
diff --git a/third_party/crashpad/snapshot/linux/process_snapshot_linux.cc b/third_party/crashpad/snapshot/linux/process_snapshot_linux.cc
index 5fe900b..48fdb11 100644
--- a/third_party/crashpad/snapshot/linux/process_snapshot_linux.cc
+++ b/third_party/crashpad/snapshot/linux/process_snapshot_linux.cc
@@ -20,7 +20,16 @@
#include "util/linux/exception_information.h"
#if defined(STARBOARD)
-#include "third_party/crashpad/wrapper/annotations.h"
+#include "third_party/crashpad/util/linux/exception_handler_protocol.h"
+// TODO(b/201538792): resolve conflict between mini_chromium and base functions.
+#ifdef LogMessage
+#define LOG_MESSAGE_DEFINED
+#undef LogMessage
+#endif
+#include "third_party/crashpad/wrapper/proto/crashpad_annotations.pb.h"
+#ifdef LOG_MESSAGE_DEFINED
+#define LogMessage MLogMessage
+#endif
#endif
namespace crashpad {
@@ -56,7 +65,9 @@
#if defined(STARBOARD)
bool ProcessSnapshotLinux::Initialize(PtraceConnection* connection,
VMAddress evergreen_information_address,
- VMAddress annotations_address) {
+ VMAddress serialized_annotations_address,
+ int serialized_annotations_size,
+ ExceptionHandlerProtocol::HandlerStartType handler_start_type) {
INITIALIZATION_STATE_SET_INITIALIZING(initialized_);
if (gettimeofday(&snapshot_time_, nullptr) != 0) {
@@ -70,15 +81,10 @@
return false;
}
- CrashpadAnnotations annotations;
- if (!memory_range_.Read(
- annotations_address, sizeof(CrashpadAnnotations), &annotations)) {
- LOG(ERROR) << "Could not read annotations";
+ if (handler_start_type == ExceptionHandlerProtocol::kStartAtCrash) {
+ LOG(INFO) << "Annotations do not need to be read from client process";
} else {
- AddAnnotation("user_agent_string",
- std::string(annotations.user_agent_string));
- AddAnnotation("prod", std::string(annotations.product));
- AddAnnotation("ver", std::string(annotations.version));
+ AddAnnotations(serialized_annotations_address, serialized_annotations_size);
}
system_.Initialize(&process_reader_, &snapshot_time_);
@@ -90,6 +96,33 @@
INITIALIZATION_STATE_SET_VALID(initialized_);
return true;
}
+
+void ProcessSnapshotLinux::AddAnnotations(
+ VMAddress serialized_annotations_address, int serialized_annotations_size) {
+ std::vector<char> buffer(serialized_annotations_size);
+ if (!memory_range_.Read(serialized_annotations_address,
+ serialized_annotations_size,
+ buffer.data())) {
+ LOG(ERROR) << "Could not read annotations";
+ return;
+ }
+
+ crashpad::wrapper::CrashpadAnnotations annotations;
+ if (!annotations.ParseFromArray(buffer.data(), serialized_annotations_size)) {
+ LOG(ERROR) << "Could not parse annotations";
+ return;
+ }
+
+ AddAnnotation("user_agent_string",
+ std::string(annotations.user_agent_string()));
+ AddAnnotation("prod", std::string(annotations.prod()));
+ AddAnnotation("ver", std::string(annotations.ver()));
+
+ for (auto& runtime_annotation : annotations.runtime_annotations()) {
+ AddAnnotation(runtime_annotation.first, runtime_annotation.second);
+ }
+ LOG(INFO) << "Annotations successfully added from client process";
+}
#endif
pid_t ProcessSnapshotLinux::FindThreadWithStackAddress(
diff --git a/third_party/crashpad/snapshot/linux/process_snapshot_linux.h b/third_party/crashpad/snapshot/linux/process_snapshot_linux.h
index 8cd9ef5..0d20528 100644
--- a/third_party/crashpad/snapshot/linux/process_snapshot_linux.h
+++ b/third_party/crashpad/snapshot/linux/process_snapshot_linux.h
@@ -45,6 +45,7 @@
#if defined(STARBOARD)
#include "snapshot/module_snapshot_evergreen.h"
#include "starboard/elf_loader/evergreen_info.h"
+#include "third_party/crashpad/util/linux/exception_handler_protocol.h"
#endif
namespace crashpad {
@@ -77,7 +78,9 @@
//! an appropriate message logged.
bool Initialize(PtraceConnection* connnection,
VMAddress evergreen_information_address,
- VMAddress annotations_address);
+ VMAddress serialized_annotations_address,
+ int serialized_annotations_size,
+ ExceptionHandlerProtocol::HandlerStartType handler_start_type);
#endif
//! \brief Finds the thread whose stack contains \a stack_address.
@@ -158,6 +161,8 @@
void InitializeModules();
#if defined(STARBOARD)
void InitializeModules(VMAddress evergreen_information_address);
+ void AddAnnotations(VMAddress serialized_annotations_address,
+ int serialized_annotations_size);
#endif
void InitializeAnnotations();
diff --git a/third_party/crashpad/util/linux/exception_handler_protocol.cc b/third_party/crashpad/util/linux/exception_handler_protocol.cc
index b139017..5f58721 100644
--- a/third_party/crashpad/util/linux/exception_handler_protocol.cc
+++ b/third_party/crashpad/util/linux/exception_handler_protocol.cc
@@ -26,7 +26,9 @@
#if defined(STARBOARD)
,
evergreen_information_address(0),
- annotations_address(0)
+ serialized_annotations_address(0),
+ serialized_annotations_size(0),
+ handler_start_type(kStartAtLaunch)
#endif
{
}
diff --git a/third_party/crashpad/util/linux/exception_handler_protocol.h b/third_party/crashpad/util/linux/exception_handler_protocol.h
index 4cc1662..4f94bd9 100644
--- a/third_party/crashpad/util/linux/exception_handler_protocol.h
+++ b/third_party/crashpad/util/linux/exception_handler_protocol.h
@@ -38,6 +38,12 @@
//! \brief A boolean status suitable for communication between processes.
enum Bool : char { kBoolFalse, kBoolTrue };
+#if defined(STARBOARD)
+ //! \brief Describes when, in the client process lifecycle, the Crashpad
+ //! handler was or will be started.
+ enum HandlerStartType : char { kStartAtCrash, kStartAtLaunch };
+#endif
+
//! \brief Information about a client registered with an
//! ExceptionHandlerServer.
struct ClientInformation {
@@ -57,9 +63,15 @@
//! struct, or 0 if there is no such struct.
VMAddress evergreen_information_address;
- //! \brief The address in the client's address space of an
- //! CrashpadAnnotations struct, or 0 if there is no such struct.
- VMAddress annotations_address;
+ //! \brief The address in the client's address space of a character array
+ //! containing a serialized CrashpadAnnotations proto, or 0 if there is
+ //! no such address.
+ VMAddress serialized_annotations_address;
+
+ //! \brief The byte size of the serialized annotations.
+ int serialized_annotations_size;
+
+ HandlerStartType handler_start_type;
#endif
#if defined(OS_LINUX)
diff --git a/third_party/crashpad/wrapper/proto/crashpad_annotations.proto b/third_party/crashpad/wrapper/proto/crashpad_annotations.proto
index eb739bc..8eb6205 100644
--- a/third_party/crashpad/wrapper/proto/crashpad_annotations.proto
+++ b/third_party/crashpad/wrapper/proto/crashpad_annotations.proto
@@ -22,10 +22,10 @@
// Next id: 5
message CrashpadAnnotations {
// The product name.
- string product = 1;
+ string prod = 1;
// The product version.
- string version = 2;
+ string ver = 2;
// The User-Agent string that identifies brand, model, etc.
string user_agent_string = 3;
diff --git a/third_party/crashpad/wrapper/wrapper.cc b/third_party/crashpad/wrapper/wrapper.cc
index 8f19a70..700f9b7 100644
--- a/third_party/crashpad/wrapper/wrapper.cc
+++ b/third_party/crashpad/wrapper/wrapper.cc
@@ -33,8 +33,11 @@
namespace crashpad {
namespace wrapper {
-namespace {
+const char kCrashpadVersionKey[] = "ver";
+const char kCrashpadProductKey[] = "prod";
+const char kCrashpadUserAgentStringKey[] = "user_agent_string";
+namespace {
// TODO: Get evergreen information from installation.
const std::string kCrashpadVersion = "1.0.0.0";
#if defined(STARBOARD_BUILD_TYPE_GOLD)
@@ -215,9 +218,9 @@
return client->SendEvergreenInfoToHandler(evergreen_info);
}
-bool AddAnnotationsToCrashpad(CrashpadAnnotations annotations) {
+bool InsertCrashpadAnnotation(const char* key, const char* value) {
::crashpad::CrashpadClient* client = GetCrashpadClient();
- return client->SendAnnotationsToHandler(annotations);
+ return client->InsertAnnotationForHandler(key, value);
}
} // namespace wrapper
diff --git a/third_party/crashpad/wrapper/wrapper.h b/third_party/crashpad/wrapper/wrapper.h
index 4def1a8..be60fec 100644
--- a/third_party/crashpad/wrapper/wrapper.h
+++ b/third_party/crashpad/wrapper/wrapper.h
@@ -16,17 +16,28 @@
#define THIRD_PARTY_CRASHPAD_WRAPPER_WRAPPER_H_
#include "starboard/elf_loader/evergreen_info.h" // nogncheck
-#include "third_party/crashpad/wrapper/annotations.h"
namespace third_party {
namespace crashpad {
namespace wrapper {
+// The key name used in Crashpad for the version annotation.
+extern const char kCrashpadVersionKey[];
+
+// The key name used in Crashpad for the version annotation.
+extern const char kCrashpadProductKey[];
+
+// The key name used in Crashpad for the user_agent_string annotation.
+extern const char kCrashpadUserAgentStringKey[];
+
void InstallCrashpadHandler(bool start_at_crash);
bool AddEvergreenInfoToCrashpad(EvergreenInfo evergreen_info);
-bool AddAnnotationsToCrashpad(CrashpadAnnotations annotations);
+// Associates the given value with the given key in Crashpad's map of
+// annotations, updating the existing value if the map already contains the
+// key. Returns true on success and false on failure.
+bool InsertCrashpadAnnotation(const char* key, const char* value);
} // namespace wrapper
} // namespace crashpad
diff --git a/third_party/crashpad/wrapper/wrapper_stub.cc b/third_party/crashpad/wrapper/wrapper_stub.cc
index bf3c093..f96dd94 100644
--- a/third_party/crashpad/wrapper/wrapper_stub.cc
+++ b/third_party/crashpad/wrapper/wrapper_stub.cc
@@ -18,13 +18,17 @@
namespace crashpad {
namespace wrapper {
+const char kCrashpadVersionKey[] = "";
+const char kCrashpadProductKey[] = "";
+const char kCrashpadUserAgentStringKey[] = "";
+
void InstallCrashpadHandler(bool start_at_crash) {}
bool AddEvergreenInfoToCrashpad(EvergreenInfo evergreen_info) {
return false;
}
-bool AddAnnotationsToCrashpad(CrashpadAnnotations annotations) {
+bool InsertCrashpadAnnotation(const char* key, const char* value) {
return false;
}
