src/third_party/WebKit/Source/modules/credentialmanager/CredentialsContainer.cpp

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "config.h"
   6 #include "modules/credentialmanager/CredentialsContainer.h"
   7
   8 #include "bindings/core/v8/Dictionary.h"
   9 #include "bindings/core/v8/ScriptPromise.h"
  10 #include "bindings/core/v8/ScriptPromiseResolver.h"
  11 #include "core/dom/DOMException.h"
  12 #include "core/dom/ExceptionCode.h"
  13 #include "core/dom/ExecutionContext.h"
  14 #include "modules/credentialmanager/Credential.h"
  15 #include "modules/credentialmanager/CredentialManagerClient.h"
  16 #include "modules/credentialmanager/FederatedCredential.h"
  17 #include "modules/credentialmanager/LocalCredential.h"
  18 #include "platform/weborigin/SecurityOrigin.h"
  19 #include "public/platform/Platform.h"
  20 #include "public/platform/WebCredential.h"
  21 #include "public/platform/WebCredentialManagerClient.h"
  22 #include "public/platform/WebCredentialManagerError.h"
  23 #include "public/platform/WebFederatedCredential.h"
  24 #include "public/platform/WebLocalCredential.h"
  25
  26 namespace blink {
  27
  28 static void rejectDueToCredentialManagerError(PassRefPtr<ScriptPromiseResolver> resolver, WebCredentialManagerError* reason)
  29 {
  30     switch (reason->errorType) {
  31     case WebCredentialManagerError::ErrorTypeDisabled:
  32         resolver->reject(DOMException::create(InvalidStateError, "The credential manager is disabled."));
  33         break;
  34     case WebCredentialManagerError::ErrorTypeUnknown:
  35     default:
  36         resolver->reject(DOMException::create(NotReadableError, "An unknown error occured while talking to the credential manager."));
  37         break;
  38     }
  39 }
  40
  41 class NotificationCallbacks : public WebCredentialManagerClient::NotificationCallbacks {
  42     WTF_MAKE_NONCOPYABLE(NotificationCallbacks);
  43 public:
  44     explicit NotificationCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) : m_resolver(resolver) { }
  45     virtual ~NotificationCallbacks() { }
  46
  47     virtual void onSuccess() override
  48     {
  49         m_resolver->resolve();
  50     }
  51
  52     virtual void onError(WebCredentialManagerError* reason) override
  53     {
  54         rejectDueToCredentialManagerError(m_resolver, reason);
  55     }
  56
  57 private:
  58     const RefPtr<ScriptPromiseResolver> m_resolver;
  59 };
  60
  61 class RequestCallbacks : public WebCredentialManagerClient::RequestCallbacks {
  62     WTF_MAKE_NONCOPYABLE(RequestCallbacks);
  63 public:
  64     explicit RequestCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) : m_resolver(resolver) { }
  65     virtual ~RequestCallbacks() { }
  66
  67     virtual void onSuccess(WebCredential* credential) override
  68     {
  69         if (!credential) {
  70             m_resolver->resolve();
  71             return;
  72         }
  73
  74         ASSERT(credential->isLocalCredential() || credential->isFederatedCredential());
  75         if (credential->isLocalCredential())
  76             m_resolver->resolve(LocalCredential::create(static_cast<WebLocalCredential*>(credential)));
  77         else
  78             m_resolver->resolve(FederatedCredential::create(static_cast<WebFederatedCredential*>(credential)));
  79     }
  80
  81     virtual void onError(WebCredentialManagerError* reason) override
  82     {
  83         rejectDueToCredentialManagerError(m_resolver, reason);
  84     }
  85
  86 private:
  87     const RefPtr<ScriptPromiseResolver> m_resolver;
  88 };
  89
  90
  91 CredentialsContainer* CredentialsContainer::create()
  92 {
  93     return new CredentialsContainer();
  94 }
  95
  96 CredentialsContainer::CredentialsContainer()
  97 {
  98 }
  99
 100 static bool checkBoilerplate(PassRefPtr<ScriptPromiseResolver> resolver)
 101 {
 102     CredentialManagerClient* client = CredentialManagerClient::from(resolver->scriptState()->executionContext());
 103     if (!client) {
 104         resolver->reject(DOMException::create(InvalidStateError, "Could not establish connection to the credential manager."));
 105         return false;
 106     }
 107
 108     SecurityOrigin* securityOrigin = resolver->scriptState()->executionContext()->securityOrigin();
 109     String errorMessage;
 110     if (!securityOrigin->canAccessFeatureRequiringSecureOrigin(errorMessage)) {
 111         resolver->reject(DOMException::create(SecurityError, errorMessage));
 112         return false;
 113     }
 114
 115     return true;
 116 }
 117
 118 ScriptPromise CredentialsContainer::request(ScriptState* scriptState, const Dictionary&)
 119 {
 120     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
 121     ScriptPromise promise = resolver->promise();
 122     if (!checkBoilerplate(resolver))
 123         return promise;
 124
 125     WebVector<WebURL> tempVector;
 126     CredentialManagerClient::from(scriptState->executionContext())->dispatchRequest(false, tempVector, new RequestCallbacks(resolver));
 127     return promise;
 128 }
 129
 130 ScriptPromise CredentialsContainer::notifySignedIn(ScriptState* scriptState, Credential* credential)
 131 {
 132     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
 133     ScriptPromise promise = resolver->promise();
 134     if (!checkBoilerplate(resolver))
 135         return promise;
 136
 137     CredentialManagerClient::from(scriptState->executionContext())->dispatchSignedIn(WebCredential::create(credential->platformCredential()), new NotificationCallbacks(resolver));
 138     return promise;
 139 }
 140
 141 ScriptPromise CredentialsContainer::notifyFailedSignIn(ScriptState* scriptState, Credential* credential)
 142 {
 143     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
 144     ScriptPromise promise = resolver->promise();
 145     if (!checkBoilerplate(resolver))
 146         return promise;
 147
 148     CredentialManagerClient::from(scriptState->executionContext())->dispatchFailedSignIn(WebCredential::create(credential->platformCredential()), new NotificationCallbacks(resolver));
 149     return promise;
 150 }
 151
 152 ScriptPromise CredentialsContainer::notifySignedOut(ScriptState* scriptState)
 153 {
 154     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
 155     ScriptPromise promise = resolver->promise();
 156     if (!checkBoilerplate(resolver))
 157         return promise;
 158
 159     CredentialManagerClient::from(scriptState->executionContext())->dispatchSignedOut(new NotificationCallbacks(resolver));
 160     return promise;
 161 }
 162
 163 } // namespace blink