Add PermissionDescriptor to the permissions Mojo interface.

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/permissions/PermissionUtils.h"
 #include "modules/quota/StorageEstimate.h"
 #include "platform/StorageQuotaCallbacks.h"
 #include "platform/UserGestureIndicator.h"
 #include "public/platform/Platform.h"
 #include "wtf/Functional.h"
 
 namespace blink {
 
 using mojom::blink::PermissionName;
 using mojom::blink::PermissionService;
@@ skipping 51 matching lines @@
     if (!executionContext->isSecureContext(errorMessage)) {
         resolver->reject(DOMException::create(SecurityError, errorMessage));
         return promise;
     }
     ASSERT(executionContext->isDocument());
     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;
     }
-    permissionService->RequestPermission(PermissionName::DURABLE_STORAGE, scriptState->getExecutionContext()->getSecurityOrigin(), UserGestureIndicator::processingUserGesture(), convertToBaseCallback(WTF::bind(&StorageManager::permissionRequestComplete, wrapPersistent(this), wrapPersistent(resolver))));
+    permissionService->RequestPermission(createPermissionDescriptor(PermissionName::DURABLE_STORAGE), scriptState->getExecutionContext()->getSecurityOrigin(), UserGestureIndicator::processingUserGesture(), convertToBaseCallback(WTF::bind(&StorageManager::permissionRequestComplete, wrapPersistent(this), wrapPersistent(resolver))));
 
     return promise;
 }
 
 ScriptPromise StorageManager::persisted(ScriptState* scriptState)
 {
     ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
     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;
     }
-    permissionService->HasPermission(PermissionName::DURABLE_STORAGE, scriptState->getExecutionContext()->getSecurityOrigin(), convertToBaseCallback(WTF::bind(&StorageManager::permissionRequestComplete, wrapPersistent(this), wrapPersistent(resolver))));
+    permissionService->HasPermission(createPermissionDescriptor(PermissionName::DURABLE_STORAGE), scriptState->getExecutionContext()->getSecurityOrigin(), convertToBaseCallback(WTF::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)
+PermissionService* StorageManager::getPermissionService(ExecutionContext* executionContext)
 {
-    if (!m_permissionService && Permissions::connectToService(executionContext, mojo::GetProxy(&m_permissionService)))
+    if (!m_permissionService && connectToPermissionService(executionContext, mojo::GetProxy(&m_permissionService)))
         m_permissionService.set_connection_error_handler(convertToBaseCallback(WTF::bind(&StorageManager::permissionServiceConnectionError, wrapWeakPersistent(this))));
     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