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

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

Index: third_party/WebKit/Source/modules/quota/StorageManager.cpp
diff --git a/third_party/WebKit/Source/modules/quota/StorageManager.cpp b/third_party/WebKit/Source/modules/quota/StorageManager.cpp
index 06bdb6b4abab10bb23d250e16ab592d0eba26067..828a4d09f797afb8ebde87834210fb563d76cd62 100644
--- a/third_party/WebKit/Source/modules/quota/StorageManager.cpp
+++ b/third_party/WebKit/Source/modules/quota/StorageManager.cpp
@@ -12,34 +12,17 @@
 #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 {
 
-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();
-    }
+using mojom::blink::PermissionName;
+using mojom::blink::PermissionService;
+using mojom::blink::PermissionStatus;
 
-private:
-    Persistent<ScriptPromiseResolver> m_resolver;
-};
+namespace {
 
 class EstimateCallbacks final : public StorageQuotaCallbacks {
     WTF_MAKE_NONCOPYABLE(EstimateCallbacks);
@@ -93,12 +76,12 @@ ScriptPromise StorageManager::persist(ScriptState* scriptState)
         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;
 }
@@ -107,12 +90,12 @@ 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;
 }
 
@@ -142,4 +125,25 @@ 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