Attachment #8852841 for bug #1286717

Attachment #8852841: interdiff-v4v5.patch for bug #1286717

View | Details | Raw Unified | Return to bug 1286717
Collapse All | Expand All




++ a/dom/permission/moz.build

# file, You can obtain one at http://mozilla.org/MPL/2.0/.

with Files("**"):
    BUG_COMPONENT = ("Core", "DOM")

EXPORTS.mozilla.dom += [
    'Permissions.h',
    'PermissionStatus.h',
    'PermissionUtils.h',
]

UNIFIED_SOURCES += [
    'PermissionObserver.cpp',
    'Permissions.cpp',
    'PermissionStatus.cpp',
    'PermissionUtils.cpp',
]






#include "StorageManager.h"

#include "mozilla/dom/PermissionUtils.h"
#include "mozilla/dom/PromiseWorkerProxy.h"
#include "mozilla/dom/quota/QuotaManagerService.h"
#include "mozilla/dom/StorageManagerBinding.h"

private:
  ~RequestResolver()
  { }

  nsresult
  HandleRequest();
};

// This class is used to return promise on worker thread.

  nsCOMPtr<nsPIDOMWindowInner> mWindow;
  RefPtr<Promise> mPromise;
  nsCOMPtr<nsIContentPermissionRequester> mRequester;
  PermissionState mPermission;

public:
  PersistentStoragePermissionRequest(nsIPrincipal* aPrincipal,

    : mPrincipal(aPrincipal)
    , mWindow(aWindow)
    , mPromise(aPromise)
    , mPermission(PermissionState::Prompt)
  {
    MOZ_ASSERT(aPrincipal);
    MOZ_ASSERT(aWindow);

private:
  ~PersistentStoragePermissionRequest()
  { }

  nsresult
  ResolvePromise();
};

NS_IMPL_ISUPPORTS(PersistentStoragePermissionRequest,

}

nsresult
Persisted(nsIPrincipal* aPrincipal,
          nsIQuotaCallback* aCallback,
          nsIQuotaRequest** aRequest)
  MOZ_ASSERT(aRequest);

  nsCOMPtr<nsIQuotaManagerService> qms = QuotaManagerService::GetOrCreate();
  if (NS_WARN_IF(!qms)) {
    return NS_ERROR_FAILURE;
  }

  nsresult rv = qms->Persist(aPrincipal, aRequest);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }

  return NS_OK;
};

nsresult
Persisted(nsIPrincipal* aPrincipal, nsIQuotaRequest** aRequest)
{
  MOZ_ASSERT(aPrincipal);
  MOZ_ASSERT(aRequest);

    return rv;
  }

  // All the methods in nsIQuotaManagerService shouldn't synchronously fire
  // any callbacks when they are being executed. Even when a result is ready,
  // a new runnable should be dispatched to current thread to fire the callback
  // asynchronously. It's safe to set the callback after we call Persisted().
  MOZ_ALWAYS_SUCCEEDS((*aRequest)->SetCallback(aCallback));

  return NS_OK;
};


    nsCOMPtr<nsIPrincipal> principal = doc->NodePrincipal();
    MOZ_ASSERT(principal);

    nsresult rv = NS_OK;

    switch (aType) {
      case RequestResolver::Type::Persisted: {
        RefPtr<RequestResolver> resolver =
          new RequestResolver(RequestResolver::Type::Persisted, promise);

        RefPtr<nsIQuotaRequest> request;
        aRv = Persisted(principal, resolver, getter_AddRefs(request));
        if (NS_SUCCEEDED(rv)) {
          request->SetCallback(resolver);
        }

        break;
      }

        RefPtr<PersistentStoragePermissionRequest> request =
          new PersistentStoragePermissionRequest(principal, window, promise);

        aRv = request->Start();

        break;
      }

          new RequestResolver(RequestResolver::Type::Estimate, promise);

        RefPtr<nsIQuotaUsageRequest> request;
        aRv = GetUsageForPrincipal(principal,
                                   resolver,
                                   getter_AddRefs(request));

        break;
      }

        MOZ_CRASH("Invalid aRequest type!");
    }

    if (NS_WARN_IF(aRv.Failed())) {
      aRv.Throw(rv);
      return nullptr;
    }


  return promise.forget();
};

PermissionState
TestPermission(nsIPrincipal* aPrincipal)
{
  MOZ_ASSERT(NS_IsMainThread());
  MOZ_ASSERT(aPrincipal);

  uint32_t permission = nsIPermissionManager::UNKNOWN_ACTION;

  nsCOMPtr<nsIPermissionManager> permissionManager =
    services::GetPermissionManager();
  if (!permissionManager) {
    return PermissionState::Prompt;
  }

  nsresult rv =
    permissionManager->TestExactPermissionFromPrincipal(aPrincipal,
                                                        "persistent-storage",
                                                        &permission);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return PermissionState::Denied;
  }

  return ActionToPermissionState(permission);
}

} // namespace

/*******************************************************************************

        mProxy->CleanUp();
      }
    }
  };

  Maybe<CleanupProxy> autoCleanup;
  if (proxy) {
    autoCleanup.emplace(proxy);
  }

  if (mType == Type::Estimate) {
    if (NS_SUCCEEDED(mResultCode)) {

  promise->MaybeResolve(mPersisted);
}

nsresult
RequestResolver::HandleRequest()
{
  MOZ_ASSERT(NS_IsMainThread());
  MOZ_ASSERT(aRequest);

  nsresult rv = aRequest->GetResultCode(&mResultCode);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    mResultCode = rv;
  } else if (NS_SUCCEEDED(mResultCode)) {
    rv = GetStorageEstimate(aRequest, mStorageEstimate);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      mResultCode = rv;
    }
  }

  // In a main thread request.
  if (!mProxy) {
    MOZ_ASSERT(mPromise);

    return NS_OK;
  }

  {
    // In a worker thread request.
    MutexAutoLock lock(mProxy->Lock());

    if (NS_WARN_IF(mProxy->CleanedUp())) {
      return NS_ERROR_FAILURE;
    }

    RefPtr<FinishWorkerRunnable> runnable = new FinishWorkerRunnable(this);
    if (NS_WARN_IF(!runnable->Dispatch())) {
      return NS_ERROR_FAILURE;
    }
  }

  return NS_OK;
}

NS_IMPL_ISUPPORTS(RequestResolver, nsIQuotaUsageCallback, nsIQuotaCallback)

NS_IMETHODIMP
RequestResolver::OnComplete(nsIQuotaRequest *aRequest)
{

    return rv;
  }

  auto result = static_cast<RequestResolver*>(callback.get());

  Type type = result->GetType();
  nsresult resultCode;

      MOZ_CRASH("Invalid callback type!");
  }

  return HandleRequest();
}
    MOZ_ASSERT(mPromise);

    ResolveOrReject();
    return NS_OK;
  }

  {
    // In a worker thread request.
    MutexAutoLock lock(mProxy->Lock());

NS_IMETHODIMP
RequestResolver::OnUsageResult(nsIQuotaUsageRequest *aRequest)
{
  MOZ_ASSERT(NS_IsMainThread());
  MOZ_ASSERT(aRequest);

  nsresult rv = aRequest->GetResultCode(&mResultCode);
  if (NS_WARN_IF(NS_FAILED(rv))) {
    mResultCode = rv;
  } else if (NS_SUCCEEDED(mResultCode)) {
    rv = GetStorageEstimate(aRequest, mStorageEstimate);
    if (NS_WARN_IF(NS_FAILED(rv))) {
      mResultCode = rv;
    }
  }

  return HandleRequest();
}

NS_IMPL_ISUPPORTS(RequestResolver, nsIQuotaUsageCallback, nsIQuotaCallback)

bool
RequestResolver::
FinishWorkerRunnable::WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)

    new RequestResolver(RequestResolver::Type::Persisted, mProxy);

  RefPtr<nsIQuotaRequest> request;
  nsresult rv = Persisted(principal, resolver, getter_AddRefs(request));
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return false;
  }

  // All the methods in nsIQuotaManagerService shouldn't synchronously fire
  // any callbacks when they are being executed. Even when a result is ready,
  // a new runnable should be dispatched to current thread to fire the callback
  // asynchronously.
  request->SetCallback(resolver);

  return true;
}


  if (Preferences::GetBool("dom.storageManager.prompt.testing", false)) {
    if (Preferences::GetBool("dom.storageManager.prompt.testing.allow",
                             false)) {
      mPermission = PermissionState::Granted;
      return Allow(JS::UndefinedHandleValue);
    }

    return Cancel();
    return ResolvePromise();
  }

  return nsContentPermissionUtils::AskPermission(this, mWindow);

{
  MOZ_ASSERT(NS_IsMainThread());

  mPromise->MaybeResolve(false);
  return NS_OK;
  // permission to "prompt" and query the permission manager in
  // `ResolvePromise`.
  mPermission = PermissionState::Prompt;

  return ResolvePromise();
}

NS_IMETHODIMP

{
  MOZ_ASSERT(NS_IsMainThread());

  mPermission = PermissionState::Granted;
  RefPtr<RequestResolver> resolver =
    new RequestResolver(RequestResolver::Type::Persist, mPromise);

  nsCOMPtr<nsIQuotaManagerService> qms = QuotaManagerService::GetOrCreate();
  if (NS_WARN_IF(!qms)) {
    return NS_ERROR_FAILURE;
  }

  RefPtr<nsIQuotaRequest> request;

  nsresult rv = qms->Persist(mPrincipal, getter_AddRefs(request));
  if (NS_WARN_IF(NS_FAILED(rv))) {
    return rv;
  }

  MOZ_ALWAYS_SUCCEEDS(request->SetCallback(resolver));

  return NS_OK;
}

NS_IMETHODIMP

  return NS_OK;
}

nsresult
PersistentStoragePermissionRequest::ResolvePromise()
{
  MOZ_ASSERT(NS_IsMainThread());

  nsresult rv = NS_OK;
  if (mPermission == PermissionState::Prompt) {
    // This will still be "prompt" if the user dismissed the doorhanger, or
    // "denied" otherwise.
    mPermission = TestPermission(mPrincipal);
  }

  mPromise->MaybeResolve(mPermission == PermissionState::Granted);

  return rv;
}

NS_IMETHODIMP
PersistentStoragePermissionRequest::GetTypes(nsIArray** aTypes)
{

Return to bug 1286717