Upstream version 10.39.225.0

[platform/framework/web/crosswalk.git] / src / third_party / WebKit / Source / modules / credentialmanager / CredentialsContainer.cpp

diff --git a/src/third_party/WebKit/Source/modules/credentialmanager/CredentialsContainer.cpp b/src/third_party/WebKit/Source/modules/credentialmanager/CredentialsContainer.cpp
index 34e5d6b..3cdab4a 100644 (file)
--- a/src/third_party/WebKit/Source/modules/credentialmanager/CredentialsContainer.cpp
+++ b/src/third_party/WebKit/Source/modules/credentialmanager/CredentialsContainer.cpp
@@ -12,17 +12,19 @@
 #include "core/dom/ExceptionCode.h"
 #include "core/dom/ExecutionContext.h"
 #include "modules/credentialmanager/Credential.h"
+#include "modules/credentialmanager/CredentialManagerClient.h"
+#include "modules/credentialmanager/LocalCredential.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebCredential.h"
-#include "public/platform/WebCredentialManager.h"
+#include "public/platform/WebCredentialManagerClient.h"
 #include "public/platform/WebCredentialManagerError.h"
+#include "public/platform/WebLocalCredential.h"
 
 namespace blink {
 
 static void rejectDueToCredentialManagerError(PassRefPtr<ScriptPromiseResolver> resolver, WebCredentialManagerError* reason)
 {
-
     switch (reason->errorType) {
     case WebCredentialManagerError::ErrorTypeDisabled:
         resolver->reject(DOMException::create(InvalidStateError, "The credential manager is disabled."));
@@ -34,7 +36,7 @@ static void rejectDueToCredentialManagerError(PassRefPtr<ScriptPromiseResolver>
     }
 }
 
-class NotificationCallbacks : public WebCredentialManager::NotificationCallbacks {
+class NotificationCallbacks : public WebCredentialManagerClient::NotificationCallbacks {
     WTF_MAKE_NONCOPYABLE(NotificationCallbacks);
 public:
     explicit NotificationCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) : m_resolver(resolver) { }
@@ -54,7 +56,7 @@ private:
     const RefPtr<ScriptPromiseResolver> m_resolver;
 };
 
-class RequestCallbacks : public WebCredentialManager::RequestCallbacks {
+class RequestCallbacks : public WebCredentialManagerClient::RequestCallbacks {
     WTF_MAKE_NONCOPYABLE(RequestCallbacks);
 public:
     explicit RequestCallbacks(PassRefPtr<ScriptPromiseResolver> resolver) : m_resolver(resolver) { }
@@ -62,8 +64,13 @@ public:
 
     virtual void onSuccess(WebCredential* credential) OVERRIDE
     {
-        // FIXME: Split this into Local/Federated types.
-        m_resolver->resolve(Credential::create(credential->id(), credential->name(), credential->avatarURL()));
+        if (!credential) {
+            m_resolver->resolve();
+            return;
+        }
+
+        // FIXME: Split this into Local/Federated types. Right now it's hard-coded to be a LocalCredential. :(
+        m_resolver->resolve(LocalCredential::create(static_cast<WebLocalCredential*>(credential)));
     }
 
     virtual void onError(WebCredentialManagerError* reason) OVERRIDE
@@ -83,50 +90,69 @@ CredentialsContainer* CredentialsContainer::create()
 
 CredentialsContainer::CredentialsContainer()
 {
-    ScriptWrappable::init(this);
 }
 
-static bool canAccessCredentialManagerAPI(ScriptState* scriptState, PassRefPtr<ScriptPromiseResolver> resolver)
+static bool checkBoilerplate(PassRefPtr<ScriptPromiseResolver> resolver)
 {
-    SecurityOrigin* securityOrigin = scriptState->executionContext()->securityOrigin();
+    CredentialManagerClient* client = CredentialManagerClient::from(resolver->scriptState()->executionContext());
+    if (!client) {
+        resolver->reject(DOMException::create(InvalidStateError, "Could not establish connection to the credential manager."));
+        return false;
+    }
+
+    SecurityOrigin* securityOrigin = resolver->scriptState()->executionContext()->securityOrigin();
     String errorMessage;
     if (!securityOrigin->canAccessFeatureRequiringSecureOrigin(errorMessage)) {
         resolver->reject(DOMException::create(SecurityError, errorMessage));
         return false;
     }
+
     return true;
 }
 
-static ScriptPromise stubImplementation(ScriptState* scriptState)
+ScriptPromise CredentialsContainer::request(ScriptState* scriptState, const Dictionary&)
 {
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-
-    if (!canAccessCredentialManagerAPI(scriptState, resolver))
+    if (!checkBoilerplate(resolver))
         return promise;
 
-    resolver->resolve();
+    WebVector<WebURL> tempVector;
+    CredentialManagerClient::from(scriptState->executionContext())->dispatchRequest(false, tempVector, new RequestCallbacks(resolver));
     return promise;
 }
 
-ScriptPromise CredentialsContainer::request(ScriptState* scriptState, const Dictionary&)
-{
-    return stubImplementation(scriptState);
-}
-
 ScriptPromise CredentialsContainer::notifySignedIn(ScriptState* scriptState, Credential* credential)
 {
-    return stubImplementation(scriptState);
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+    if (!checkBoilerplate(resolver))
+        return promise;
+
+    CredentialManagerClient::from(scriptState->executionContext())->dispatchSignedIn(WebCredential(credential->platformCredential()), new NotificationCallbacks(resolver));
+    return promise;
 }
 
 ScriptPromise CredentialsContainer::notifyFailedSignIn(ScriptState* scriptState, Credential* credential)
 {
-    return stubImplementation(scriptState);
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+    if (!checkBoilerplate(resolver))
+        return promise;
+
+    CredentialManagerClient::from(scriptState->executionContext())->dispatchFailedSignIn(WebCredential(credential->platformCredential()), new NotificationCallbacks(resolver));
+    return promise;
 }
 
 ScriptPromise CredentialsContainer::notifySignedOut(ScriptState* scriptState)
 {
-    return stubImplementation(scriptState);
+    RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+    if (!checkBoilerplate(resolver))
+        return promise;
+
+    CredentialManagerClient::from(scriptState->executionContext())->dispatchSignedOut(new NotificationCallbacks(resolver));
+    return promise;
 }
 
 } // namespace blink