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)))); }