web_engine_chromium_plugin_src_files = \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-back-forward-list.cpp \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-back-forward-list-item.cpp \
+ $(extension_src_dir)/web-engine-chromium/tizen-web-engine-certificate.cpp \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-chromium.cpp \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-console-message.cpp \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-context.cpp \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-cookie-manager.cpp \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-form-repost-decision.cpp \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-frame.cpp \
+ $(extension_src_dir)/web-engine-chromium/tizen-web-engine-http-auth-handler.cpp \
+ $(extension_src_dir)/web-engine-chromium/tizen-web-engine-load-error.cpp \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-policy-decision.cpp \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-request-interceptor.cpp \
- $(extension_src_dir)/web-engine-chromium/tizen-web-engine-load-error.cpp \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-settings.cpp
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "tizen-web-engine-certificate.h"
+
+namespace Dali
+{
+namespace Plugin
+{
+
+namespace
+{
+const std::string EMPTY_STRING;
+} // namespace
+
+TizenWebEngineCertificate::TizenWebEngineCertificate(Ewk_Certificate_Policy_Decision* decision)
+ : ewkCertificatePolicyDecision(decision)
+ , ewkCertificateInfo(0)
+{
+}
+
+TizenWebEngineCertificate::TizenWebEngineCertificate(Ewk_Certificate_Info* info)
+ : ewkCertificatePolicyDecision(0)
+ , ewkCertificateInfo(info)
+{
+}
+
+TizenWebEngineCertificate::~TizenWebEngineCertificate()
+{
+}
+
+void TizenWebEngineCertificate::Allow(bool allowed)
+{
+ if (ewkCertificatePolicyDecision)
+ {
+ ewk_certificate_policy_decision_allowed_set(ewkCertificatePolicyDecision, allowed);
+ }
+}
+
+bool TizenWebEngineCertificate::IsFromMainFrame() const
+{
+ return ewkCertificatePolicyDecision ? ewk_certificate_policy_decision_from_main_frame_get(ewkCertificatePolicyDecision) : false;
+}
+
+std::string TizenWebEngineCertificate::GetPem() const
+{
+ return ewkCertificateInfo ? std::string(ewk_certificate_info_pem_get(ewkCertificateInfo)) : EMPTY_STRING;
+}
+
+bool TizenWebEngineCertificate::IsContextSecure() const
+{
+ return ewkCertificateInfo ? ewk_certificate_info_is_context_secure(ewkCertificateInfo) : false;
+}
+
+} // namespace Plugin
+} // namespace Dali
--- /dev/null
+#ifndef DALI_PLUGIN_TIZEN_WEB_ENGINE_CERTIFICATE_H
+#define DALI_PLUGIN_TIZEN_WEB_ENGINE_CERTIFICATE_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <ewk_certificate_internal.h>
+#include <string>
+
+#include <dali/devel-api/adaptor-framework/web-engine-certificate.h>
+
+namespace Dali
+{
+namespace Plugin
+{
+
+/**
+ * @brief A class TizenWebEngineCertificate for ssl certificate.
+ */
+class TizenWebEngineCertificate : public Dali::WebEngineCertificate
+{
+public:
+ /**
+ * @brief Constructor.
+ */
+ TizenWebEngineCertificate(Ewk_Certificate_Policy_Decision*);
+
+ /**
+ * @brief Constructor.
+ */
+ TizenWebEngineCertificate(Ewk_Certificate_Info*);
+
+ /**
+ * @brief Destructor.
+ */
+ ~TizenWebEngineCertificate();
+
+ /**
+ * @copydoc Dali::WebEngineCertificate::Allow()
+ */
+ void Allow(bool allowed) override;
+
+ /**
+ * @copydoc Dali::WebEngineCertificate::IsFromMainFrame()
+ */
+ bool IsFromMainFrame() const override;
+
+ /**
+ * @copydoc Dali::WebEngineCertificate::GetPem()
+ */
+ std::string GetPem() const override;
+
+ /**
+ * @copydoc Dali::WebEngineCertificate::IsContextSecure()
+ */
+ bool IsContextSecure() const override;
+
+private:
+ Ewk_Certificate_Policy_Decision* ewkCertificatePolicyDecision;
+ Ewk_Certificate_Info* ewkCertificateInfo;
+};
+
+} // namespace Plugin
+} // namespace Dali
+
+#endif // DALI_PLUGIN_TIZEN_WEB_ENGINE_CERTIFICATE_H
#include "tizen-web-engine-chromium.h"
#include "tizen-web-engine-back-forward-list.h"
+#include "tizen-web-engine-certificate.h"
#include "tizen-web-engine-console-message.h"
#include "tizen-web-engine-context.h"
#include "tizen-web-engine-cookie-manager.h"
#include "tizen-web-engine-form-repost-decision.h"
+#include "tizen-web-engine-http-auth-handler.h"
+#include "tizen-web-engine-load-error.h"
#include "tizen-web-engine-policy-decision.h"
#include "tizen-web-engine-request-interceptor.h"
-#include "tizen-web-engine-load-error.h"
#include "tizen-web-engine-settings.h"
#include <Ecore.h>
&WebViewContainerForDali::OnFormRepostDecisionRequest,
&mClient);
evas_object_smart_callback_add(mWebView, "policy,newwindow,decide",
- &WebViewContainerForDali::OnNewWindowPolicyDecide,
+ &WebViewContainerForDali::OnNewWindowPolicyDecided,
+ &mClient);
+ evas_object_smart_callback_add(mWebView, "request,certificate,confirm",
+ &WebViewContainerForDali::OnCertificateConfirmRequest,
&mClient);
+ evas_object_smart_callback_add(mWebView, "ssl,certificate,changed",
+ &WebViewContainerForDali::OnSslCertificateChanged,
+ &mClient);
+
+ ewk_view_authentication_callback_set(mWebView, &WebViewContainerForDali::OnAuthenticationChallenge, &mClient);
evas_object_resize(mWebView, mWidth, mHeight);
evas_object_show(mWebView);
return client->GeolocationPermission(host, protocol);
}
- static void OnNewWindowPolicyDecide(void* data, Evas_Object*, void* policy)
+ static void OnNewWindowPolicyDecided(void* data, Evas_Object*, void* policy)
{
auto client = static_cast<WebViewContainerClient*>(data);
Ewk_Policy_Decision* policyDecision = static_cast<Ewk_Policy_Decision*>(policy);
client->NewWindowPolicyDecided(webPolicyDecision);
}
+ static void OnCertificateConfirmRequest(void* data, Evas_Object*, void* eventInfo)
+ {
+ auto client = static_cast<WebViewContainerClient*>(data);
+ Ewk_Certificate_Policy_Decision* policyDecision = static_cast<Ewk_Certificate_Policy_Decision*>(eventInfo);
+ std::shared_ptr<Dali::WebEngineCertificate> webPolicyDecision(new TizenWebEngineCertificate(policyDecision));
+ client->CertificateConfirm(std::move(webPolicyDecision));
+ }
+
+ static void OnSslCertificateChanged(void* data, Evas_Object*, void* eventInfo)
+ {
+ auto client = static_cast<WebViewContainerClient*>(data);
+ Ewk_Certificate_Info* info = static_cast<Ewk_Certificate_Info*>(eventInfo);
+ std::shared_ptr<Dali::WebEngineCertificate> webCertiInfo(new TizenWebEngineCertificate(info));
+ client->SslCertificateChanged(std::move(webCertiInfo));
+ }
+
+ static void OnAuthenticationChallenge(Evas_Object*, Ewk_Auth_Challenge* authChallenge, void* data)
+ {
+ auto client = static_cast<WebViewContainerClient*>(data);
+ std::shared_ptr<Dali::WebEngineHttpAuthHandler> authHandler(new TizenWebEngineHttpAuthHandler(authChallenge));
+ client->AuthenticationChallenge(std::move(authHandler));
+ }
+
static void OnEvaluateJavaScript(Evas_Object* o, const char* result, void* data)
{
auto client = WebEngineManager::Get().FindContainerClient(o);
return mPolicyDecisionSignal;
}
+Dali::WebEnginePlugin::WebEngineCertificateSignalType& TizenWebEngineChromium::CertificateConfirmSignal()
+{
+ return mCertificateConfirmSignal;
+}
+
+Dali::WebEnginePlugin::WebEngineCertificateSignalType& TizenWebEngineChromium::SslCertificateChangedSignal()
+{
+ return mSslCertificateChangedSignal;
+}
+
+Dali::WebEnginePlugin::WebEngineHttpAuthHandlerSignalType& TizenWebEngineChromium::HttpAuthHandlerSignal()
+{
+ return mHttpAuthHandlerSignal;
+}
+
// WebViewContainerClient Interface
void TizenWebEngineChromium::UpdateImage(tbm_surface_h buffer)
{
}
}
+void TizenWebEngineChromium::CertificateConfirm(std::shared_ptr<Dali::WebEngineCertificate> confirm)
+{
+ DALI_LOG_RELEASE_INFO("#CertificateConfirm.\n");
+ if (!mCertificateConfirmSignal.Empty())
+ {
+ mCertificateConfirmSignal.Emit(std::move(confirm));
+ }
+}
+
+void TizenWebEngineChromium::SslCertificateChanged(std::shared_ptr<Dali::WebEngineCertificate> info)
+{
+ DALI_LOG_RELEASE_INFO("#SslCertificateChanged.\n");
+ if (!mSslCertificateChangedSignal.Empty())
+ {
+ mSslCertificateChangedSignal.Emit(std::move(info));
+ }
+}
+
+void TizenWebEngineChromium::AuthenticationChallenge(std::shared_ptr<Dali::WebEngineHttpAuthHandler> handler)
+{
+ DALI_LOG_RELEASE_INFO("#AuthenticationChallenge.\n");
+ if (!mHttpAuthHandlerSignal.Empty())
+ {
+ mHttpAuthHandlerSignal.Emit(std::move(handler));
+ }
+}
+
void TizenWebEngineChromium::RunJavaScriptEvaluationResultHandler(size_t key, const char* result)
{
auto handler = mJavaScriptEvaluationResultHandlers.find(key);
virtual void NewWindowPolicyDecided(std::shared_ptr<Dali::WebEnginePolicyDecision> decision) = 0;
/**
+ * @brief Callback function to be called by WebViewContainer when certificate
+ * need be confirmed.
+ * @param [in] confirm Policy confirm request.
+ */
+ virtual void CertificateConfirm(std::shared_ptr<Dali::WebEngineCertificate> confirm) = 0;
+
+ /**
+ * @brief Callback function to be called by WebViewContainer when certificate
+ * is changed.
+ * @param [in] info Certificate information.
+ */
+ virtual void SslCertificateChanged(std::shared_ptr<Dali::WebEngineCertificate> info) = 0;
+
+ /**
+ * @brief Callback function to be called by WebViewContainer when
+ * authentication need be confirmed.
+ * @param [in] handler Http authentication challenge handler.
+ */
+ virtual void AuthenticationChallenge(std::shared_ptr<Dali::WebEngineHttpAuthHandler> handler) = 0;
+
+ /**
* @brief Callback function to be called by WebViewContainer when it gets
* JavaScript evalution result.
* @param [in] key An unsigned integer representing the result handler
*/
Dali::WebEnginePlugin::WebEnginePolicyDecisionSignalType& PolicyDecisionSignal() override;
+ /**
+ * @copydoc Dali::WebEnginePlugin::CertificateConfirmSignal()
+ */
+ Dali::WebEnginePlugin::WebEngineCertificateSignalType& CertificateConfirmSignal() override;
+
+ /**
+ * @copydoc Dali::WebEnginePlugin::SslCertificateChangedSignal()
+ */
+ Dali::WebEnginePlugin::WebEngineCertificateSignalType& SslCertificateChangedSignal() override;
+
+ /**
+ * @copydoc Dali::WebEnginePlugin::HttpAuthHandlerSignal()
+ */
+ Dali::WebEnginePlugin::WebEngineHttpAuthHandlerSignalType& HttpAuthHandlerSignal() override;
+
// WebViewContainerClient Interface
/**
void OnConsoleMessage(std::shared_ptr<Dali::WebEngineConsoleMessage> message) override;
/**
+ * @copydoc Dali::Plugin::WebViewContainerClient::CertificateConfirm()
+ */
+ void CertificateConfirm(std::shared_ptr<Dali::WebEngineCertificate> confirm) override;
+
+ /**
+ * @copydoc Dali::Plugin::WebViewContainerClient::SslCertificateChanged()
+ */
+ void SslCertificateChanged(std::shared_ptr<Dali::WebEngineCertificate> info) override;
+
+ /**
+ * @copydoc Dali::Plugin::WebViewContainerClient::AuthenticationChallenge()
+ */
+ void AuthenticationChallenge(std::shared_ptr<Dali::WebEngineHttpAuthHandler> handler) override;
+
+ /**
* @copydoc
* Dali::Plugin::WebViewContainerClient::RunJavaScriptEvaluationResultHandler()
*/
Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType mRequestInterceptorSignal;
Dali::WebEnginePlugin::WebEngineConsoleMessageSignalType mConsoleMessageSignal;
Dali::WebEnginePlugin::WebEnginePolicyDecisionSignalType mPolicyDecisionSignal;
+ Dali::WebEnginePlugin::WebEngineCertificateSignalType mCertificateConfirmSignal;
+ Dali::WebEnginePlugin::WebEngineCertificateSignalType mSslCertificateChangedSignal;
+ Dali::WebEnginePlugin::WebEngineHttpAuthHandlerSignalType mHttpAuthHandlerSignal;
std::unordered_map<size_t, JavaScriptCallback> mJavaScriptEvaluationResultHandlers;
std::unordered_map<std::string, JavaScriptCallback> mJavaScriptMessageHandlers;
--- /dev/null
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include "tizen-web-engine-http-auth-handler.h"
+
+namespace Dali
+{
+namespace Plugin
+{
+
+TizenWebEngineHttpAuthHandler::TizenWebEngineHttpAuthHandler(Ewk_Auth_Challenge* challenge)
+ : ewkAuthChallenge(challenge)
+{
+}
+
+TizenWebEngineHttpAuthHandler::~TizenWebEngineHttpAuthHandler()
+{
+}
+
+std::string TizenWebEngineHttpAuthHandler::GetRealm() const
+{
+ return std::string(ewk_auth_challenge_realm_get(ewkAuthChallenge));
+}
+
+void TizenWebEngineHttpAuthHandler::Suspend()
+{
+ ewk_auth_challenge_suspend(ewkAuthChallenge);
+}
+
+void TizenWebEngineHttpAuthHandler::UseCredential(const std::string& user, const std::string& password)
+{
+ ewk_auth_challenge_credential_use(ewkAuthChallenge, user.c_str(), password.c_str());
+}
+
+void TizenWebEngineHttpAuthHandler::CancelCredential()
+{
+ ewk_auth_challenge_credential_cancel(ewkAuthChallenge);
+}
+
+} // namespace Plugin
+} // namespace Dali
--- /dev/null
+#ifndef DALI_PLUGIN_TIZEN_WEB_ENGINE_HTTP_AUTH_HANDLER_H
+#define DALI_PLUGIN_TIZEN_WEB_ENGINE_HTTP_AUTH_HANDLER_H
+
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// EXTERNAL INCLUDES
+#include <ewk_auth_challenge_internal.h>
+#include <string>
+
+#include <dali/devel-api/adaptor-framework/web-engine-http-auth-handler.h>
+
+namespace Dali
+{
+namespace Plugin
+{
+/**
+ * @brief A class TizenWebEngineHttpAuthHandler for http authentication.
+ */
+class TizenWebEngineHttpAuthHandler : public Dali::WebEngineHttpAuthHandler
+{
+public:
+ /**
+ * @brief Constructor.
+ */
+ TizenWebEngineHttpAuthHandler(Ewk_Auth_Challenge*);
+
+ /**
+ * @brief Destructor.
+ */
+ ~TizenWebEngineHttpAuthHandler();
+
+ /**
+ * @copydoc Dali::WebEngineHttpAuthHandler::GetRealm()
+ */
+ std::string GetRealm() const override;
+
+ /**
+ * @copydoc Dali::WebEngineHttpAuthHandler::Suspend()
+ */
+ void Suspend() override;
+
+ /**
+ * @copydoc Dali::WebEngineHttpAuthHandler::UseCredential()
+ */
+ void UseCredential(const std::string& user, const std::string& password) override;
+
+ /**
+ * @copydoc Dali::WebEngineHttpAuthHandler::CancelCredential()
+ */
+ void CancelCredential() override;
+
+private:
+ Ewk_Auth_Challenge* ewkAuthChallenge;
+};
+
+} // namespace Plugin
+} // namespace Dali
+
+#endif // DALI_PLUGIN_TIZEN_WEB_ENGINE_HTTP_AUTH_HANDLER_H
return mPolicyDecisionSignal;
}
+ /**
+ * @copydoc Dali::WebEnginePlugin::CertificateConfirmSignal()
+ */
+ Dali::WebEnginePlugin::WebEngineCertificateSignalType& CertificateConfirmSignal() override
+ {
+ return mCertificateConfirmSignal;
+ }
+
+ /**
+ * @copydoc Dali::WebEnginePlugin::SslCertificateChangedSignal()
+ */
+ Dali::WebEnginePlugin::WebEngineCertificateSignalType& SslCertificateChangedSignal() override
+ {
+ return mSslCertificateChangedSignal;
+ }
+
+ /**
+ * @copydoc Dali::WebEnginePlugin::HttpAuthHandlerSignal()
+ */
+ Dali::WebEnginePlugin::WebEngineHttpAuthHandlerSignalType& HttpAuthHandlerSignal() override
+ {
+ return mHttpAuthHandlerSignal;
+ }
+
private:
void UpdateBuffer();
Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType mRequestInterceptorSignal;
Dali::WebEnginePlugin::WebEngineConsoleMessageSignalType mConsoleMessageSignal;
Dali::WebEnginePlugin::WebEnginePolicyDecisionSignalType mPolicyDecisionSignal;
+ Dali::WebEnginePlugin::WebEngineCertificateSignalType mCertificateConfirmSignal;
+ Dali::WebEnginePlugin::WebEngineCertificateSignalType mSslCertificateChangedSignal;
+ Dali::WebEnginePlugin::WebEngineHttpAuthHandlerSignalType mHttpAuthHandlerSignal;
};
} // namespace Plugin
projects / platform / core / uifw / dali-extension.git / commitdiff