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 "platform/weborigin/SecurityOrigin.h"
  16 #include "public/platform/Platform.h"
  17 #include "public/platform/WebCredential.h"
  18 #include "public/platform/WebCredentialManager.h"
  19 #include "public/platform/WebCredentialManagerError.h"
  20
  21 namespace blink {
  22
  23 static void rejectDueToCredentialManagerError(PassRefPtr<ScriptPromiseResolver> resolver, WebCredentialManagerError* reason)
  24 {
  25
  26     switch (reason->errorType) {
  27     case WebCredentialManagerError::ErrorTypeDisabled:
  28         resolver->reject(DOMException::create(InvalidStateError, "The credential manager is disabled."));
  29         break;
  30     case WebCredentialManagerError::ErrorTypeUnknown:
  31     default:
  32         resolver->reject(DOMException::create(NotReadableError, "An unknown error occured while talking to the credential manager."));
  33         break;
  34     }
  35 }
  36
  37 class NotificationCallbacks : public WebCredentialManager::NotificationCallbacks {
  38     WTF_MAKE_NONCOPYABLE(NotificationCallbacks);
  39 public:
  40     explicit NotificationCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) : m_resolver(resolver) { }
  41     virtual ~NotificationCallbacks() { }
  42
  43     virtual void onSuccess() OVERRIDE
  44     {
  45         m_resolver->resolve();
  46     }
  47
  48     virtual void onError(WebCredentialManagerError* reason) OVERRIDE
  49     {
  50         rejectDueToCredentialManagerError(m_resolver, reason);
  51     }
  52
  53 private:
  54     const RefPtr<ScriptPromiseResolver> m_resolver;
  55 };
  56
  57 class RequestCallbacks : public WebCredentialManager::RequestCallbacks {
  58     WTF_MAKE_NONCOPYABLE(RequestCallbacks);
  59 public:
  60     explicit RequestCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) : m_resolver(resolver) { }
  61     virtual ~RequestCallbacks() { }
  62
  63     virtual void onSuccess(WebCredential* credential) OVERRIDE
  64     {
  65         // FIXME: Split this into Local/Federated types.
  66         m_resolver->resolve(Credential::create(credential->id(), credential->name(), credential->avatarURL()));
  67     }
  68
  69     virtual void onError(WebCredentialManagerError* reason) OVERRIDE
  70     {
  71         rejectDueToCredentialManagerError(m_resolver, reason);
  72     }
  73
  74 private:
  75     const RefPtr<ScriptPromiseResolver> m_resolver;
  76 };
  77
  78
  79 CredentialsContainer* CredentialsContainer::create()
  80 {
  81     return new CredentialsContainer();
  82 }
  83
  84 CredentialsContainer::CredentialsContainer()
  85 {
  86     ScriptWrappable::init(this);
  87 }
  88
  89 static bool canAccessCredentialManagerAPI(ScriptState* scriptState, PassRefPtr<ScriptPromiseResolver> resolver)
  90 {
  91     SecurityOrigin* securityOrigin = scriptState->executionContext()->securityOrigin();
  92     String errorMessage;
  93     if (!securityOrigin->canAccessFeatureRequiringSecureOrigin(errorMessage)) {
  94         resolver->reject(DOMException::create(SecurityError, errorMessage));
  95         return false;
  96     }
  97     return true;
  98 }
  99
 100 static ScriptPromise stubImplementation(ScriptState* scriptState)
 101 {
 102     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
 103     ScriptPromise promise = resolver->promise();
 104
 105     if (!canAccessCredentialManagerAPI(scriptState, resolver))
 106         return promise;
 107
 108     resolver->resolve();
 109     return promise;
 110 }
 111
 112 ScriptPromise CredentialsContainer::request(ScriptState* scriptState, const Dictionary&)
 113 {
 114     return stubImplementation(scriptState);
 115 }
 116
 117 ScriptPromise CredentialsContainer::notifySignedIn(ScriptState* scriptState, Credential* credential)
 118 {
 119     return stubImplementation(scriptState);
 120 }
 121
 122 ScriptPromise CredentialsContainer::notifyFailedSignIn(ScriptState* scriptState, Credential* credential)
 123 {
 124     return stubImplementation(scriptState);
 125 }
 126
 127 ScriptPromise CredentialsContainer::notifySignedOut(ScriptState* scriptState)
 128 {
 129     return stubImplementation(scriptState);
 130 }
 131
 132 } // namespace blink