void WebTaskRunner::postDelayedTask(const WebTraceLocation& location,
std::unique_ptr<WTF::Closure> task,
long long delayMs) {
toSingleThreadTaskRunner()->PostDelayedTask(
location, convertToBaseCallback(std::move(task)),
base::TimeDelta::FromMilliseconds(delayMs));
}
ScriptPromise BudgetService::reserve(ScriptState* scriptState,
const AtomicString& operation) {
DCHECK(m_service);
mojom::blink::BudgetOperationType type = stringToOperationType(operation);
if (type == mojom::blink::BudgetOperationType::INVALID_OPERATION)
return ScriptPromise::rejectWithDOMException(
scriptState, DOMException::create(NotSupportedError,
"Invalid operation type specified"));
String errorMessage;
if (!scriptState->getExecutionContext()->isSecureContext(errorMessage))
return ScriptPromise::rejectWithDOMException(
scriptState, DOMException::create(SecurityError, errorMessage));
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
ScriptPromise promise = resolver->promise();
// Call to the BudgetService to place the reservation.
RefPtr<SecurityOrigin> origin(
scriptState->getExecutionContext()->getSecurityOrigin());
m_service->Reserve(origin, type,
convertToBaseCallback(WTF::bind(
&BudgetService::gotReservation, wrapPersistent(this),
wrapPersistent(resolver))));
return promise;
}
ScriptPromise SyncManager::registerFunction(ScriptState* scriptState,
const String& tag) {
// TODO(jkarlin): Wait for the registration to become active instead of
// rejecting. See crbug.com/542437.
if (!m_registration->active())
return ScriptPromise::rejectWithDOMException(
scriptState,
DOMException::create(AbortError,
"Registration failed - no active Service Worker"));
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
ScriptPromise promise = resolver->promise();
mojom::blink::SyncRegistrationPtr syncRegistration =
mojom::blink::SyncRegistration::New();
syncRegistration->id = SyncManager::kUnregisteredSyncID;
syncRegistration->tag = tag;
syncRegistration->network_state =
blink::mojom::BackgroundSyncNetworkState::ONLINE;
getBackgroundSyncServicePtr()->Register(
std::move(syncRegistration),
m_registration->webRegistration()->registrationId(),
convertToBaseCallback(
WTF::bind(SyncManager::registerCallback, wrapPersistent(resolver))));
return promise;
}
void SensorProxy::removeConfiguration(
SensorConfigurationPtr configuration,
std::unique_ptr<Function<void(bool)>> callback) {
DCHECK(isInitialized());
m_sensor->RemoveConfiguration(std::move(configuration),
convertToBaseCallback(std::move(callback)));
}
void BackgroundTaskRunner::postOnBackgroundThread(
const WebTraceLocation& location,
std::unique_ptr<CrossThreadClosure> closure,
TaskSize taskSize) {
base::WorkerPool::PostTask(location,
convertToBaseCallback(std::move(closure)),
taskSize == TaskSizeLongRunningTask);
}
USB::USB(LocalFrame& frame)
: ContextLifecycleObserver(frame.document()), m_clientBinding(this) {
ThreadState::current()->registerPreFinalizer(this);
frame.interfaceProvider()->getInterface(mojo::GetProxy(&m_deviceManager));
m_deviceManager.set_connection_error_handler(convertToBaseCallback(WTF::bind(
&USB::onDeviceManagerConnectionError, wrapWeakPersistent(this))));
m_deviceManager->SetClient(m_clientBinding.CreateInterfacePtrAndBind());
}
void PermissionStatus::startListening() {
DCHECK(!m_service);
connectToPermissionService(getExecutionContext(), mojo::GetProxy(&m_service));
m_service->GetNextPermissionChange(
m_descriptor->Clone(), getExecutionContext()->getSecurityOrigin(),
m_status,
convertToBaseCallback(WTF::bind(&PermissionStatus::permissionChanged,
wrapWeakPersistent(this))));
}
ScriptPromise USB::requestDevice(ScriptState* scriptState,
const USBDeviceRequestOptions& options) {
ExecutionContext* executionContext = scriptState->getExecutionContext();
UseCounter::count(executionContext, UseCounter::UsbRequestDevice);
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
ScriptPromise promise = resolver->promise();
if (!m_chooserService) {
LocalFrame* frame = executionContext->isDocument()
? toDocument(executionContext)->frame()
: nullptr;
if (!frame) {
resolver->reject(DOMException::create(NotSupportedError));
return promise;
}
frame->interfaceProvider()->getInterface(mojo::GetProxy(&m_chooserService));
m_chooserService.set_connection_error_handler(
convertToBaseCallback(WTF::bind(&USB::onChooserServiceConnectionError,
wrapWeakPersistent(this))));
}
String errorMessage;
if (!executionContext->isSecureContext(errorMessage)) {
resolver->reject(DOMException::create(SecurityError, errorMessage));
} else if (!UserGestureIndicator::consumeUserGesture()) {
resolver->reject(DOMException::create(
SecurityError,
"Must be handling a user gesture to show a permission request."));
} else {
Vector<usb::DeviceFilterPtr> filters;
if (options.hasFilters()) {
filters.reserveCapacity(options.filters().size());
for (const auto& filter : options.filters())
filters.append(convertDeviceFilter(filter));
}
m_chooserServiceRequests.add(resolver);
m_chooserService->GetPermission(
std::move(filters), convertToBaseCallback(WTF::bind(
&USB::onGetPermission, wrapPersistent(this),
wrapPersistent(resolver))));
}
return promise;
}
BudgetService::BudgetService() {
Platform::current()->interfaceProvider()->getInterface(
mojo::GetProxy(&m_service));
// Set a connection error handler, so that if an embedder doesn't
// implement a BudgetSerice mojo service, the developer will get a
// actionable information.
m_service.set_connection_error_handler(convertToBaseCallback(
WTF::bind(&BudgetService::onConnectionError, wrapWeakPersistent(this))));
}
ScriptPromise SyncManager::getTags(ScriptState* scriptState) {
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
ScriptPromise promise = resolver->promise();
getBackgroundSyncServicePtr()->GetRegistrations(
m_registration->webRegistration()->registrationId(),
convertToBaseCallback(WTF::bind(&SyncManager::getRegistrationsCallback,
wrapPersistent(resolver))));
return promise;
}
void VibrationController::cancel() {
m_pattern.clear();
m_timerDoVibrate.stop();
if (m_isRunning && !m_isCallingCancel && m_service) {
m_isCallingCancel = true;
m_service->Cancel(convertToBaseCallback(
WTF::bind(&VibrationController::didCancel, wrapPersistent(this))));
}
m_isRunning = false;
}
void PermissionStatus::permissionChanged(MojoPermissionStatus status) {
if (m_status == status)
return;
m_status = status;
dispatchEvent(Event::create(EventTypeNames::change));
m_service->GetNextPermissionChange(
m_descriptor->Clone(), getExecutionContext()->getSecurityOrigin(),
m_status,
convertToBaseCallback(WTF::bind(&PermissionStatus::permissionChanged,
wrapWeakPersistent(this))));
}
void VRController::getDisplays(ScriptPromiseResolver* resolver) {
if (!m_service) {
DOMException* exception = DOMException::create(
InvalidStateError, "The service is no longer active.");
resolver->reject(exception);
return;
}
m_pendingGetDevicesCallbacks.append(
WTF::wrapUnique(new VRGetDevicesCallback(resolver)));
m_service->GetDisplays(convertToBaseCallback(
WTF::bind(&VRController::onGetDisplays, wrapPersistent(this))));
}
ScriptPromise NavigatorShare::share(ScriptState* scriptState,
const ShareData& shareData) {
String errorMessage;
if (!scriptState->getExecutionContext()->isSecureContext(errorMessage)) {
DOMException* error = DOMException::create(SecurityError, errorMessage);
return ScriptPromise::rejectWithDOMException(scriptState, error);
}
if (!UserGestureIndicator::utilizeUserGesture()) {
DOMException* error = DOMException::create(
SecurityError,
"Must be handling a user gesture to perform a share request.");
return ScriptPromise::rejectWithDOMException(scriptState, error);
}
Document* doc = toDocument(scriptState->getExecutionContext());
DCHECK(doc);
if (!m_service) {
LocalFrame* frame = doc->frame();
DCHECK(frame);
frame->interfaceProvider()->getInterface(mojo::GetProxy(&m_service));
m_service.set_connection_error_handler(convertToBaseCallback(WTF::bind(
&NavigatorShare::onConnectionError, wrapWeakPersistent(this))));
DCHECK(m_service);
}
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
ShareClientImpl* client = new ShareClientImpl(this, resolver);
m_clients.add(client);
ScriptPromise promise = resolver->promise();
m_service->Share(shareData.hasTitle() ? shareData.title() : emptyString(),
shareData.hasText() ? shareData.text() : emptyString(),
doc->completeURL(shareData.url()),
convertToBaseCallback(WTF::bind(&ShareClientImpl::callback,
wrapPersistent(client))));
return promise;
}
void Geolocation::requestPermission() {
if (m_geolocationPermission != PermissionUnknown)
return;
LocalFrame* frame = this->frame();
if (!frame)
return;
m_geolocationPermission = PermissionRequested;
frame->interfaceProvider()->getInterface(
mojo::GetProxy(&m_permissionService));
m_permissionService.set_connection_error_handler(
convertToBaseCallback(WTF::bind(&Geolocation::onPermissionConnectionError,
wrapWeakPersistent(this))));
// Ask the embedder: it maintains the geolocation challenge policy itself.
m_permissionService->RequestPermission(
createPermissionDescriptor(mojom::blink::PermissionName::GEOLOCATION),
getExecutionContext()->getSecurityOrigin(),
UserGestureIndicator::processingUserGesture(),
convertToBaseCallback(WTF::bind(
&Geolocation::onGeolocationPermissionUpdated, wrapPersistent(this))));
}
void SensorProxy::initialize() {
if (m_state != Uninitialized)
return;
if (!m_provider->sensorProvider()) {
handleSensorError();
return;
}
m_state = Initializing;
auto callback = convertToBaseCallback(
WTF::bind(&SensorProxy::onSensorCreated, wrapWeakPersistent(this)));
m_provider->sensorProvider()->GetSensor(m_type, mojo::GetProxy(&m_sensor),
callback);
}
void VRController::requestPresent(ScriptPromiseResolver* resolver,
unsigned index,
bool secureOrigin) {
if (!m_service) {
DOMException* exception = DOMException::create(
InvalidStateError, "The service is no longer active.");
resolver->reject(exception);
ReportPresentationResult(PresentationResult::ServiceInactive);
return;
}
m_service->RequestPresent(
index, secureOrigin,
convertToBaseCallback(WTF::bind(&VRController::onPresentComplete,
wrapPersistent(this),
wrapPersistent(resolver), index)));
}
void VibrationController::doVibrate(TimerBase* timer) {
DCHECK(timer == &m_timerDoVibrate);
if (m_pattern.isEmpty())
m_isRunning = false;
if (!m_isRunning || m_isCallingCancel || m_isCallingVibrate ||
!getExecutionContext() || !page()->isPageVisible())
return;
if (m_service) {
m_isCallingVibrate = true;
m_service->Vibrate(m_pattern[0], convertToBaseCallback(WTF::bind(
&VibrationController::didVibrate,
wrapPersistent(this))));
}
}
void Geolocation::updateGeolocationServiceConnection() {
if (!getExecutionContext() || !page() || !page()->isPageVisible() ||
!m_updating) {
m_geolocationService.reset();
m_disconnectedGeolocationService = true;
return;
}
if (m_geolocationService)
return;
frame()->interfaceProvider()->getInterface(
mojo::GetProxy(&m_geolocationService));
m_geolocationService.set_connection_error_handler(convertToBaseCallback(
WTF::bind(&Geolocation::onGeolocationConnectionError,
wrapWeakPersistent(this))));
if (m_enableHighAccuracy)
m_geolocationService->SetHighAccuracy(true);
queryNextPosition();
}
ScriptPromise BudgetService::getBudget(ScriptState* scriptState) {
DCHECK(m_service);
String errorMessage;
if (!scriptState->getExecutionContext()->isSecureContext(errorMessage))
return ScriptPromise::rejectWithDOMException(
scriptState, DOMException::create(SecurityError, errorMessage));
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
ScriptPromise promise = resolver->promise();
// Get the budget from the browser BudgetService.
RefPtr<SecurityOrigin> origin(
scriptState->getExecutionContext()->getSecurityOrigin());
m_service->GetBudget(
origin, convertToBaseCallback(WTF::bind(&BudgetService::gotBudget,
wrapPersistent(this),
wrapPersistent(resolver))));
return promise;
}
void SensorProxy::onSensorCreated(SensorInitParamsPtr params,
SensorClientRequest clientRequest) {
DCHECK_EQ(Initializing, m_state);
if (!params) {
handleSensorError(NotFoundError, "Sensor is not present on the platform.");
return;
}
const size_t kReadBufferSize = sizeof(ReadingBuffer);
DCHECK_EQ(0u, params->buffer_offset % kReadBufferSize);
m_mode = params->mode;
m_defaultConfig = std::move(params->default_configuration);
if (!m_defaultConfig) {
handleSensorError();
return;
}
DCHECK(m_sensor.is_bound());
m_clientBinding.Bind(std::move(clientRequest));
m_sharedBufferHandle = std::move(params->memory);
DCHECK(!m_sharedBuffer);
m_sharedBuffer =
m_sharedBufferHandle->MapAtOffset(kReadBufferSize, params->buffer_offset);
if (!m_sharedBuffer) {
handleSensorError();
return;
}
auto errorCallback =
WTF::bind(&SensorProxy::handleSensorError, wrapWeakPersistent(this),
UnknownError, String("Internal error"), String());
m_sensor.set_connection_error_handler(
convertToBaseCallback(std::move(errorCallback)));
m_state = Initialized;
for (Observer* observer : m_observers)
observer->onSensorInitialized();
}
ScriptPromise USB::getDevices(ScriptState* scriptState) {
ExecutionContext* executionContext = scriptState->getExecutionContext();
UseCounter::count(executionContext, UseCounter::UsbGetDevices);
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
ScriptPromise promise = resolver->promise();
if (!m_deviceManager) {
resolver->reject(DOMException::create(NotSupportedError));
} else {
String errorMessage;
if (!executionContext->isSecureContext(errorMessage)) {
resolver->reject(DOMException::create(SecurityError, errorMessage));
} else {
m_deviceManagerRequests.add(resolver);
m_deviceManager->GetDevices(
nullptr, convertToBaseCallback(WTF::bind(&USB::onGetDevices,
wrapPersistent(this),
wrapPersistent(resolver))));
}
}
return promise;
}
ScriptPromise BudgetService::getCost(ScriptState* scriptState,
const AtomicString& operation) {
DCHECK(m_service);
String errorMessage;
if (!scriptState->getExecutionContext()->isSecureContext(errorMessage))
return ScriptPromise::rejectWithDOMException(
scriptState, DOMException::create(SecurityError, errorMessage));
mojom::blink::BudgetOperationType type = stringToOperationType(operation);
if (type == mojom::blink::BudgetOperationType::INVALID_OPERATION)
return ScriptPromise::rejectWithDOMException(
scriptState, DOMException::create(NotSupportedError,
"Invalid operation type specified"));
ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
ScriptPromise promise = resolver->promise();
// Get the cost for the action from the browser BudgetService.
m_service->GetCost(type, convertToBaseCallback(WTF::bind(
&BudgetService::gotCost, wrapPersistent(this),
wrapPersistent(resolver))));
return promise;
}
void WebTaskRunner::postTask(const WebTraceLocation& location,
std::unique_ptr<CrossThreadClosure> task) {
toSingleThreadTaskRunner()->PostTask(location,
convertToBaseCallback(std::move(task)));
}
void Geolocation::queryNextPosition() {
m_geolocationService->QueryNextPosition(convertToBaseCallback(
WTF::bind(&Geolocation::onPositionUpdated, wrapPersistent(this))));
}
// SensorProviderProxy
SensorProviderProxy::SensorProviderProxy(LocalFrame* frame) {
frame->interfaceProvider()->getInterface(mojo::GetProxy(&m_sensorProvider));
m_sensorProvider.set_connection_error_handler(convertToBaseCallback(
WTF::bind(&SensorProviderProxy::onSensorProviderConnectionError,
wrapWeakPersistent(this))));
}
