コード例 #1
0
ファイル: Sensor.cpp プロジェクト: mirror/chromium
void Sensor::reportError(ExceptionCode code,
                         const String& sanitizedMessage,
                         const String& unsanitizedMessage) {
  updateState(Sensor::SensorState::ERRORED);
  if (getExecutionContext()) {
    auto error =
        DOMException::create(code, sanitizedMessage, unsanitizedMessage);
    getExecutionContext()->postTask(
        BLINK_FROM_HERE,
        createSameThreadTask(&Sensor::notifyError, wrapWeakPersistent(this),
                             wrapPersistent(error)));
  }
}
コード例 #2
0
ファイル: USB.cpp プロジェクト: mirror/chromium
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;
}
コード例 #3
0
ファイル: BudgetService.cpp プロジェクト: mirror/chromium
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;
}
コード例 #4
0
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))));
  }
}
コード例 #5
0
ファイル: SearchInputType.cpp プロジェクト: mirror/chromium
void SearchInputType::startSearchEventTimer() {
  DCHECK(element().layoutObject());
  unsigned length = element().innerEditorValue().length();

  if (!length) {
    m_searchEventTimer.stop();
    element().document().postTask(
        BLINK_FROM_HERE, createSameThreadTask(&HTMLInputElement::onSearch,
                                              wrapPersistent(&element())));
    return;
  }

  // After typing the first key, we wait 0.5 seconds.
  // After the second key, 0.4 seconds, then 0.3, then 0.2 from then on.
  m_searchEventTimer.startOneShot(max(0.2, 0.6 - 0.1 * length),
                                  BLINK_FROM_HERE);
}
コード例 #6
0
ファイル: NavigatorShare.cpp プロジェクト: mirror/chromium
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;
}
コード例 #7
0
ファイル: Geolocation.cpp プロジェクト: mirror/chromium
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))));
}
コード例 #8
0
ファイル: DirectoryReader.cpp プロジェクト: mirror/chromium
void DirectoryReader::readEntries(EntriesCallback* entriesCallback,
                                  ErrorCallback* errorCallback) {
  if (!m_isReading) {
    m_isReading = true;
    filesystem()->readDirectory(this, m_fullPath,
                                new EntriesCallbackHelper(this),
                                new ErrorCallbackHelper(this));
  }

  if (m_error) {
    filesystem()->reportError(ScriptErrorCallback::wrap(errorCallback),
                              m_error);
    return;
  }

  if (m_entriesCallback) {
    // Non-null m_entriesCallback means multiple readEntries() calls are made
    // concurrently. We don't allow doing it.
    filesystem()->reportError(ScriptErrorCallback::wrap(errorCallback),
                              FileError::kInvalidStateErr);
    return;
  }

  if (!m_hasMoreEntries || !m_entries.isEmpty()) {
    if (entriesCallback)
      DOMFileSystem::scheduleCallback(
          filesystem()->getExecutionContext(),
          createSameThreadTask(&EntriesCallback::handleEvent,
                               wrapPersistent(entriesCallback),
                               PersistentHeapVector<Member<Entry>>(m_entries)));
    m_entries.clear();
    return;
  }

  m_entriesCallback = entriesCallback;
  m_errorCallback = errorCallback;
}
コード例 #9
0
ファイル: Notification.cpp プロジェクト: ollie314/chromium
void Notification::close() {
  if (m_state != State::Showing)
    return;

  // Schedule the "close" event to be fired for non-persistent notifications.
  // Persistent notifications won't get such events for programmatic closes.
  if (m_type == Type::NonPersistent) {
    getExecutionContext()->postTask(
        BLINK_FROM_HERE, createSameThreadTask(&Notification::dispatchCloseEvent,
                                              wrapPersistent(this)));
    m_state = State::Closing;

    notificationManager()->close(this);
    return;
  }

  m_state = State::Closed;

  SecurityOrigin* origin = getExecutionContext()->getSecurityOrigin();
  DCHECK(origin);

  notificationManager()->closePersistent(WebSecurityOrigin(origin), m_data.tag,
                                         m_notificationId);
}
コード例 #10
0
void LocalFileSystem::requestFileSystem(ExecutionContext* context, FileSystemType type, long long size, std::unique_ptr<AsyncFileSystemCallbacks> callbacks)
{
    CallbackWrapper* wrapper = new CallbackWrapper(std::move(callbacks));
    requestFileSystemAccessInternal(context,
                                    WTF::bind(&LocalFileSystem::fileSystemAllowedInternal, wrapPersistent(this), wrapPersistent(context), type, wrapPersistent(wrapper)),
                                    WTF::bind(&LocalFileSystem::fileSystemNotAllowedInternal, wrapPersistent(this), wrapPersistent(context), wrapPersistent(wrapper)));
}
コード例 #11
0
void LocalFileSystem::deleteFileSystem(ExecutionContext* context, FileSystemType type, std::unique_ptr<AsyncFileSystemCallbacks> callbacks)
{
    ASSERT(context);
    ASSERT_WITH_SECURITY_IMPLICATION(context->isDocument());

    CallbackWrapper* wrapper = new CallbackWrapper(std::move(callbacks));
    requestFileSystemAccessInternal(context,
                                    WTF::bind(&LocalFileSystem::deleteFileSystemInternal, wrapPersistent(this), wrapPersistent(context), type, wrapPersistent(wrapper)),
                                    WTF::bind(&LocalFileSystem::fileSystemNotAllowedInternal, wrapPersistent(this), wrapPersistent(context), wrapPersistent(wrapper)));
}
コード例 #12
0
std::unique_ptr<ExecutionContextTask>
StorageErrorCallback::createSameThreadTask(StorageErrorCallback* callback,
                                           ExceptionCode ec) {
  return blink::createSameThreadTask(&StorageErrorCallback::run,
                                     wrapPersistent(callback), ec);
}
コード例 #13
0
ファイル: Geolocation.cpp プロジェクト: mirror/chromium
void Geolocation::queryNextPosition() {
  m_geolocationService->QueryNextPosition(convertToBaseCallback(
      WTF::bind(&Geolocation::onPositionUpdated, wrapPersistent(this))));
}
コード例 #14
0
Database* DatabaseManager::openDatabase(ExecutionContext* context,
    const String& name, const String& expectedVersion, const String& displayName,
    unsigned estimatedSize, DatabaseCallback* creationCallback,
    DatabaseError& error, String& errorMessage)
{
    ASSERT(error == DatabaseError::None);

    bool setVersionInNewDatabase = !creationCallback;
    Database* database = openDatabaseInternal(context, name,
        expectedVersion, displayName, estimatedSize, setVersionInNewDatabase, error, errorMessage);
    if (!database)
        return nullptr;

    databaseContextFor(context)->setHasOpenDatabases();
    DatabaseClient::from(context)->didOpenDatabase(database, context->getSecurityOrigin()->host(), name, expectedVersion);

    if (database->isNew() && creationCallback) {
        WTF_LOG(StorageAPI, "Scheduling DatabaseCreationCallbackTask for database %p\n", database);
        database->getExecutionContext()->postTask(BLINK_FROM_HERE, createSameThreadTask(&databaseCallbackHandleEvent, wrapPersistent(creationCallback), wrapPersistent(database)), "openDatabase");
    }

    ASSERT(database);
    return database;
}
void ContentDecryptionModuleResultPromise::reject(ExceptionCode code, const String& errorMessage)
{
    // Reject the promise asynchronously. This avoids problems when gc is
    // destroying objects that result in unfulfilled promises being rejected.
    // (Resolving promises is still done synchronously as there may be events
    // already posted that need to happen only after the promise is resolved.)
    // TODO(jrummell): Make resolving a promise asynchronous as well (including
    // making sure events still happen after the promise is resolved).
    getExecutionContext()->postTask(BLINK_FROM_HERE, createSameThreadTask(&ContentDecryptionModuleResultPromise::rejectInternal, wrapPersistent(this), code, errorMessage));
}
コード例 #16
0
void VRController::getDisplays(std::unique_ptr<VRGetDevicesCallback> callback)
{
    if (!m_service) {
        callback->onError();
        return;
    }

    m_pendingGetDevicesCallbacks.append(std::move(callback));
    m_service->GetDisplays(createBaseCallback(WTF::bind(&VRController::onGetDisplays, wrapPersistent(this))));
}