Merge //content/child/permissions into Blink's permissions module.

third_party/WebKit/Source/modules/quota/StorageManager.cpp

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "modules/quota/StorageManager.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "bindings/modules/v8/V8StorageEstimate.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/ExceptionCode.h"
 #include "modules/permissions/Permissions.h"
 #include "modules/quota/StorageEstimate.h"
 #include "platform/StorageQuotaCallbacks.h"
+#include "platform/UserGestureIndicator.h"
+#include "platform/mojo/MojoHelper.h"
 #include "public/platform/Platform.h"
-#include "public/platform/WebCallbacks.h"
-#include "public/platform/modules/permissions/WebPermissionClient.h"
-#include "public/platform/modules/permissions/WebPermissionStatus.h"
 
 namespace blink {
 
+using mojom::blink::PermissionName;
+using mojom::blink::PermissionService;
+using mojom::blink::PermissionStatus;
+
 namespace {
 
-class DurableStorageCallbacks final : public WebPermissionCallback {
-public:
-    DurableStorageCallbacks(ScriptPromiseResolver* resolver)
-        : m_resolver(resolver)
-    {
-    }
-
-    void onSuccess(WebPermissionStatus status) override
-    {
-        m_resolver->resolve(status == WebPermissionStatusGranted);
-    }
-    void onError() override
-    {
-        ASSERT_NOT_REACHED();
-    }
-
-private:
-    Persistent<ScriptPromiseResolver> m_resolver;
-};
-
 class EstimateCallbacks final : public StorageQuotaCallbacks {
     WTF_MAKE_NONCOPYABLE(EstimateCallbacks);
 public:
     explicit EstimateCallbacks(ScriptPromiseResolver* resolver)
         : m_resolver(resolver) {}
 
     ~EstimateCallbacks() override {}
 
     void didQueryStorageUsageAndQuota(unsigned long long usageInBytes, unsigned long long quotaInBytes) override
     {
@@ skipping 32 matching lines @@
     if (securityOrigin->isUnique()) {
         resolver->reject(DOMException::create(NotSupportedError));
         return promise;
     }
     String errorMessage;
     if (!executionContext->isSecureContext(errorMessage)) {
         resolver->reject(DOMException::create(SecurityError, errorMessage));
         return promise;
     }
     ASSERT(executionContext->isDocument());
-    WebPermissionClient* permissionClient = Permissions::getClient(executionContext);
-    if (!permissionClient) {
+    PermissionService* permissionService = getPermissionService(scriptState->getExecutionContext());
+    if (!permissionService) {
         resolver->reject(DOMException::create(InvalidStateError, "In its current state, the global scope can't request permissions."));
         return promise;
     }
-    permissionClient->requestPermission(WebPermissionTypeDurableStorage, KURL(KURL(), scriptState->getExecutionContext()->getSecurityOrigin()->toString()), new DurableStorageCallbacks(resolver));
+    permissionService->RequestPermission(PermissionName::DURABLE_STORAGE, scriptState->getExecutionContext()->getSecurityOrigin()->toString(), UserGestureIndicator::processingUserGesture(), createBaseCallback(bind(&StorageManager::permissionRequestComplete, wrapPersistent(this), wrapPersistent(resolver))));
 
     return promise;
 }
 
 ScriptPromise StorageManager::persisted(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    WebPermissionClient* permissionClient = Permissions::getClient(scriptState->getExecutionContext());
-    if (!permissionClient) {
+    PermissionService* permissionService = getPermissionService(scriptState->getExecutionContext());
+    if (!permissionService) {
         resolver->reject(DOMException::create(InvalidStateError, "In its current state, the global scope can't query permissions."));
         return promise;
     }
-    permissionClient->queryPermission(WebPermissionTypeDurableStorage, KURL(KURL(), scriptState->getExecutionContext()->getSecurityOrigin()->toString()), new DurableStorageCallbacks(resolver));
+    permissionService->HasPermission(PermissionName::DURABLE_STORAGE, scriptState->getExecutionContext()->getSecurityOrigin()->toString(), createBaseCallback(bind(&StorageManager::permissionRequestComplete, wrapPersistent(this), wrapPersistent(resolver))));
     return promise;
 }
 
 ScriptPromise StorageManager::estimate(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     ExecutionContext* executionContext = scriptState->getExecutionContext();
     SecurityOrigin* securityOrigin = executionContext->getSecurityOrigin();
     if (securityOrigin->isUnique()) {
         resolver->reject(DOMException::create(NotSupportedError));
         return promise;
     }
     // IDL has: [SecureContext]
     String errorMessage;
     if (!executionContext->isSecureContext(errorMessage)) {
         resolver->reject(DOMException::create(SecurityError, errorMessage));
         return promise;
     }
 
     KURL storagePartition = KURL(KURL(), securityOrigin->toString());
     Platform::current()->queryStorageUsageAndQuota(storagePartition, WebStorageQuotaTypeTemporary, new EstimateCallbacks(resolver));
     return promise;
 }
 
 DEFINE_TRACE(StorageManager)
 {
 }
 
+mojom::blink::PermissionService* StorageManager::getPermissionService(ExecutionContext* executionContext)
+{
+    if (!m_permissionService) {
+        if (Permissions::connectToService(executionContext, mojo::GetProxy(&m_permissionService)))
+            m_permissionService.set_connection_error_handler(createBaseCallback(bind(&StorageManager::permissionServiceConnectionError, wrapWeakPersistent(this))));

[mlamouri (slow - plz ping), 2016/07/18 10:25:57]

It's a bit odd because you don't handle a branch.

either you do something like:
```
if (Permissions::connectToService(...))
  m_permissionService.set_connection_error_handler(...);
else
  return nullptr;
```

or you merge the two conditions:
```
if (!m_permissionService && Permissions::connectToService(...))
  m_permissionService.set_connection_error_handler(...);
```

(Note: I know that the result would be the same, it's a clarity issue.)

[Reilly Grant (use Gerrit), 2016/07/19 20:10:28]

I took the second option.

+    }
+    return m_permissionService.get();
+}
+
+void StorageManager::permissionServiceConnectionError()
+{
+    m_permissionService.reset();
+}
+
+void StorageManager::permissionRequestComplete(ScriptPromiseResolver* resolver, PermissionStatus status)
+{
+    if (!resolver->getExecutionContext() || resolver->getExecutionContext()->activeDOMObjectsAreStopped())
+        return;
+    resolver->resolve(status == PermissionStatus::GRANTED);
+}
+
 } // namespace blink