$(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-request-interceptor-task-queue.cpp \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-security-origin.cpp \
$(extension_src_dir)/web-engine-chromium/tizen-web-engine-settings.cpp
#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-settings.h"
#include <Ecore_Evas.h>
, mClient(client)
, mWidth(width)
, mHeight(height)
- , mWebEngineSettings(0)
- , mWebEngineContext(0)
- , mWebEngineCookieManager(0)
- , mWebEngineBackForwardList(0)
+ , mWebEngineSettings(nullptr)
+ , mWebEngineContext(nullptr)
+ , mWebEngineCookieManager(nullptr)
+ , mWebEngineBackForwardList(nullptr)
{
- InitWebView(0, 0);
+ InitWebView(0, nullptr);
WebEngineManager::Get().AddContainerClient(&mClient, mWebView);
}
, mClient(client)
, mWidth(width)
, mHeight(height)
- , mWebEngineSettings(0)
- , mWebEngineContext(0)
- , mWebEngineCookieManager(0)
- , mWebEngineBackForwardList(0)
+ , mWebEngineSettings(nullptr)
+ , mWebEngineContext(nullptr)
+ , mWebEngineCookieManager(nullptr)
+ , mWebEngineBackForwardList(nullptr)
{
InitWebView(argc, argv);
ewk_view_ime_window_set(mWebView, win);
Ewk_Settings* settings = ewk_view_settings_get(mWebView);
- mWebEngineSettings = TizenWebEngineSettings(settings);
+ mWebEngineSettings.reset(new TizenWebEngineSettings(settings));
context = ewk_view_context_get(mWebView);
- mWebEngineContext = TizenWebEngineContext(context);
+ mWebEngineContext.reset(new TizenWebEngineContext(context));
Ewk_Cookie_Manager* manager = ewk_context_cookie_manager_get(context);
- mWebEngineCookieManager = TizenWebEngineCookieManager(manager);
+ mWebEngineCookieManager.reset(new TizenWebEngineCookieManager(manager));
Ewk_Back_Forward_List* backForwardList = ewk_view_back_forward_list_get(mWebView);
- mWebEngineBackForwardList = TizenWebEngineBackForwardList(backForwardList);
+ mWebEngineBackForwardList.reset(new TizenWebEngineBackForwardList(backForwardList));
ewk_settings_viewport_meta_tag_set(settings, false);
Dali::WebEngineSettings& GetSettings()
{
- return mWebEngineSettings;
+ static TizenWebEngineSettings dummy(nullptr);
+ return mWebEngineSettings ? *mWebEngineSettings : dummy;
}
Dali::WebEngineContext& GetContext()
{
- return mWebEngineContext;
+ static TizenWebEngineContext dummy(nullptr);
+ return mWebEngineContext ? *mWebEngineContext : dummy;
}
Dali::WebEngineCookieManager& GetCookieManager()
{
- return mWebEngineCookieManager;
+ static TizenWebEngineCookieManager dummy(nullptr);
+ return mWebEngineCookieManager ? *mWebEngineCookieManager : dummy;
}
Dali::WebEngineBackForwardList& GetBackForwardList()
{
- return mWebEngineBackForwardList;
+ static TizenWebEngineBackForwardList dummy(nullptr);
+ return mWebEngineBackForwardList ? *mWebEngineBackForwardList : dummy;
}
std::unique_ptr<Dali::WebEngineHitTest> CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
ewk_view_geolocation_permission_callback_set(mWebView, &WebViewContainerForDali::OnGeolocationPermission, &mClient);
}
- void RegisterRequestInterceptorCallback(bool isRegistered)
- {
- Ewk_Context* context = ewk_view_context_get(mWebView);
- if (isRegistered)
- {
- ewk_context_intercept_request_callback_set(context, &WebViewContainerForDali::OnRequestIntercepted, &mClient);
- }
- else
- {
- ewk_context_intercept_request_callback_set(context, nullptr, nullptr);
- }
- }
-
void UpdateDisplayArea(Dali::Rect<int32_t> displayArea)
{
evas_object_move(mWebView, displayArea.x, displayArea.y);
client->LoadError(std::move(loadError));
}
- static void OnRequestIntercepted(Ewk_Context*, Ewk_Intercept_Request* request, void* data)
- {
- auto client = static_cast<WebViewContainerClient*>(data);
- std::unique_ptr<Dali::WebEngineRequestInterceptor> webInterceptor(new TizenWebEngineRequestInterceptor(request));
- client->RequestIntercepted(std::move(webInterceptor));
- }
-
static void OnUrlChanged(void* data, Evas_Object*, void* newUrl)
{
auto client = static_cast<WebViewContainerClient*>(data);
uint32_t mWidth;
uint32_t mHeight;
- TizenWebEngineSettings mWebEngineSettings;
- TizenWebEngineContext mWebEngineContext;
- TizenWebEngineCookieManager mWebEngineCookieManager;
- TizenWebEngineBackForwardList mWebEngineBackForwardList;
+ std::unique_ptr<WebEngineSettings> mWebEngineSettings;
+ std::unique_ptr<WebEngineContext> mWebEngineContext;
+ std::unique_ptr<WebEngineCookieManager> mWebEngineCookieManager;
+ std::unique_ptr<WebEngineBackForwardList> mWebEngineBackForwardList;
};
class TBMSurfaceSourceInitializer
: mWebViewContainer(0)
, mJavaScriptEvaluationCount(0)
{
- EventThreadCallback* callback = new Dali::EventThreadCallback(Dali::MakeCallback(this, &TizenWebEngineChromium::OnRequestInterceptedEventCallback));
- mRequestInterceptorEventTrigger = std::unique_ptr<Dali::EventThreadCallback>(callback);
}
TizenWebEngineChromium::~TizenWebEngineChromium()
mFormRepostDecidedCallback = callback;
}
-void TizenWebEngineChromium::RegisterRequestInterceptorCallback(WebEngineRequestInterceptorCallback callback)
-{
- mRequestInterceptedCallback = callback;
- if (mWebViewContainer)
- {
- bool isRegistered = mRequestInterceptedCallback ? true : false;
- mWebViewContainer->RegisterRequestInterceptorCallback(isRegistered);
- }
-}
-
void TizenWebEngineChromium::RegisterConsoleMessageReceivedCallback(WebEngineConsoleMessageReceivedCallback callback)
{
mConsoleMessageReceivedCallback = callback;
ExecuteCallback(mScrollEdgeReachedCallback, edge);
}
-void TizenWebEngineChromium::RequestIntercepted(std::unique_ptr<Dali::WebEngineRequestInterceptor> interceptor)
-{
- {
- Mutex::ScopedLock lock(mMutex);
- mRequestInterceptorQueue.push(std::move(interceptor));
- // Trigger an event on main thread.
- mRequestInterceptorEventTrigger->Trigger();
- }
-
- // Wait for tasks on main thread and execute tasks.
- TizenWebEngineRequestInterceptor* requestInterceptor = static_cast<TizenWebEngineRequestInterceptor*>(interceptor.get());
- requestInterceptor->WaitAndRunTasks();
-}
-
-void TizenWebEngineChromium::OnRequestInterceptedEventCallback()
-{
- std::unique_ptr<Dali::WebEngineRequestInterceptor> interceptor;
- {
- Mutex::ScopedLock lock(mMutex);
- interceptor = std::move(mRequestInterceptorQueue.front());
- mRequestInterceptorQueue.pop();
- }
-
- ExecuteCallback(mRequestInterceptedCallback, std::move(interceptor));
-
- // Notify ui-thread tasks ready on main thread.
- TizenWebEngineRequestInterceptor* requestInterceptor = static_cast<TizenWebEngineRequestInterceptor*>(interceptor.get());
- requestInterceptor->NotifyTaskReady();
-}
-
void TizenWebEngineChromium::UrlChanged(const std::string& url)
{
DALI_LOG_RELEASE_INFO("#UrlChanged : %s\n", url.c_str());
// EXTERNAL INCLUDES
#include <dali-toolkit/dali-toolkit.h>
-#include <dali/devel-api/adaptor-framework/event-thread-callback.h>
#include <dali/devel-api/adaptor-framework/web-engine-plugin.h>
-#include <dali/devel-api/threading/mutex.h>
#include <dali/public-api/images/native-image-interface.h>
#include <functional>
#include <memory>
-#include <queue>
#include <unordered_map>
#include <tbm_surface.h>
virtual void RequestFormRepostDecided(std::unique_ptr<Dali::WebEngineFormRepostDecision> decision) = 0;
/**
- * @brief Callback function to be called by WebViewContainer when http request
- * need be intercepted.
- * @param [in] request The http request interceptor.
- */
- virtual void RequestIntercepted(std::unique_ptr<Dali::WebEngineRequestInterceptor> interceptor) = 0;
-
- /**
* @brief Callback function to be called by WebViewContainer when url is
* changed.
* @param [in] url New url after url is changed.
void RegisterFormRepostDecidedCallback(WebEngineFormRepostDecidedCallback callback) override;
/**
- * @copydoc Dali::WebEnginePlugin::RegisterRequestInterceptorCallback()
- */
- void RegisterRequestInterceptorCallback(WebEngineRequestInterceptorCallback callback) override;
-
- /**
* @copydoc Dali::WebEnginePlugin::RegisterConsoleMessageReceivedCallback()
*/
void RegisterConsoleMessageReceivedCallback(WebEngineConsoleMessageReceivedCallback callback) override;
void ResponsePolicyDecided(std::unique_ptr<Dali::WebEnginePolicyDecision> policy) override;
/**
- * @copydoc Dali::Plugin::WebViewContainerClient::RequestIntercepted()
- */
- void RequestIntercepted(std::unique_ptr<Dali::WebEngineRequestInterceptor> interceptor) override;
-
- /**
* @copydoc Dali::Plugin::WebViewContainerClient::UrlChanged()
*/
void UrlChanged(const std::string& url) override;
void PlainTextRecieved(const std::string& plainText) override;
private:
- /**
- * @brief Event callback for request interceptor is called on main thread.
- */
- void OnRequestInterceptedEventCallback();
-
-private:
WebViewContainerForDali* mWebViewContainer;
Dali::NativeImageSourcePtr mDaliImageSrc;
size_t mJavaScriptEvaluationCount;
WebEngineUrlChangedCallback mUrlChangedCallback;
WebEngineScrollEdgeReachedCallback mScrollEdgeReachedCallback;
WebEngineFormRepostDecidedCallback mFormRepostDecidedCallback;
- WebEngineRequestInterceptorCallback mRequestInterceptedCallback;
WebEngineConsoleMessageReceivedCallback mConsoleMessageReceivedCallback;
WebEngineResponsePolicyDecidedCallback mResponsePolicyDecidedCallback;
WebEngineCertificateCallback mCertificateConfirmedCallback;
std::unordered_map<size_t, JavaScriptMessageHandlerCallback> mJavaScriptEvaluationResultHandlers;
std::unordered_map<std::string, JavaScriptMessageHandlerCallback> mJavaScriptMessageHandlers;
-
- Dali::Mutex mMutex;
- std::unique_ptr<Dali::EventThreadCallback> mRequestInterceptorEventTrigger;
- std::queue<std::unique_ptr<Dali::WebEngineRequestInterceptor>> mRequestInterceptorQueue;
};
} // namespace Plugin
} // namespace Dali
*/
#include "tizen-web-engine-context.h"
+#include "tizen-web-engine-request-interceptor.h"
#include "tizen-web-engine-security-origin.h"
#include <ewk_context.h>
{
TizenWebEngineContext::TizenWebEngineContext(Ewk_Context* context)
- : webSecurityOriginAcquiredCallback(nullptr)
- , webStorageUsageAcquiredCallback(nullptr)
- , webFormPasswordAcquiredCallback(nullptr)
- , webDownloadStartedCallback(nullptr)
- , webMimeOverriddenCallback(nullptr)
- , ewkContext(context)
+ : mWebSecurityOriginAcquiredCallback(nullptr)
+ , mWebStorageUsageAcquiredCallback(nullptr)
+ , mWebFormPasswordAcquiredCallback(nullptr)
+ , mWebDownloadStartedCallback(nullptr)
+ , mWebMimeOverriddenCallback(nullptr)
+ , mWebRequestInterceptedCallback(nullptr)
+ , mEwkContext(context)
{
+ EventThreadCallback* callback = new Dali::EventThreadCallback(Dali::MakeCallback(this, &TizenWebEngineContext::OnRequestInterceptedEventCallback));
+ mRequestInterceptorEventTrigger = std::unique_ptr<Dali::EventThreadCallback>(callback);
}
TizenWebEngineContext::~TizenWebEngineContext()
Dali::WebEngineContext::CacheModel TizenWebEngineContext::GetCacheModel() const
{
- return static_cast<Dali::WebEngineContext::CacheModel>(ewk_context_cache_model_get(ewkContext));
+ return static_cast<Dali::WebEngineContext::CacheModel>(ewk_context_cache_model_get(mEwkContext));
}
void TizenWebEngineContext::SetCacheModel(Dali::WebEngineContext::CacheModel cacheModel)
{
- ewk_context_cache_model_set(ewkContext, static_cast<Ewk_Cache_Model>(cacheModel));
+ ewk_context_cache_model_set(mEwkContext, static_cast<Ewk_Cache_Model>(cacheModel));
}
void TizenWebEngineContext::SetProxyUri(const std::string& uri)
{
- ewk_context_proxy_uri_set(ewkContext, uri.c_str());
+ ewk_context_proxy_uri_set(mEwkContext, uri.c_str());
}
std::string TizenWebEngineContext::GetProxyUri() const
{
- const char* uri = ewk_context_proxy_uri_get(ewkContext);
+ const char* uri = ewk_context_proxy_uri_get(mEwkContext);
return uri ? std::string(uri) : std::string();
}
void TizenWebEngineContext::SetProxyBypassRule(const std::string& proxy, const std::string& bypass)
{
- ewk_context_proxy_set(ewkContext, proxy.c_str(), bypass.c_str());
+ ewk_context_proxy_set(mEwkContext, proxy.c_str(), bypass.c_str());
}
std::string TizenWebEngineContext::GetProxyBypassRule() const
{
- const char* rule = ewk_context_proxy_bypass_rule_get(ewkContext);
+ const char* rule = ewk_context_proxy_bypass_rule_get(mEwkContext);
return rule ? std::string(rule) : std::string();
}
void TizenWebEngineContext::SetDefaultProxyAuth(const std::string& username, const std::string& password)
{
- ewk_context_proxy_default_auth_set(ewkContext, username.c_str(), password.c_str());
+ ewk_context_proxy_default_auth_set(mEwkContext, username.c_str(), password.c_str());
}
void TizenWebEngineContext::SetCertificateFilePath(const std::string& certificatePath)
{
- ewk_context_certificate_file_set(ewkContext, certificatePath.c_str());
+ ewk_context_certificate_file_set(mEwkContext, certificatePath.c_str());
}
std::string TizenWebEngineContext::GetCertificateFilePath() const
{
- const char* path = ewk_context_certificate_file_get(ewkContext);
+ const char* path = ewk_context_certificate_file_get(mEwkContext);
return path ? std::string(path) : std::string();
}
void TizenWebEngineContext::DeleteAllWebDatabase()
{
- ewk_context_web_database_delete_all(ewkContext);
+ ewk_context_web_database_delete_all(mEwkContext);
}
bool TizenWebEngineContext::GetWebDatabaseOrigins(Dali::WebEngineContext::WebEngineSecurityOriginAcquiredCallback callback)
{
- webSecurityOriginAcquiredCallback = callback;
- return ewk_context_web_database_origins_get(ewkContext, &TizenWebEngineContext::OnSecurityOriginsAcquired, this);
+ mWebSecurityOriginAcquiredCallback = callback;
+ return ewk_context_web_database_origins_get(mEwkContext, &TizenWebEngineContext::OnSecurityOriginsAcquired, this);
}
bool TizenWebEngineContext::DeleteWebDatabase(WebEngineSecurityOrigin& origin)
{
TizenWebEngineSecurityOrigin* engineOrigin = static_cast<TizenWebEngineSecurityOrigin*>(&origin);
- return ewk_context_web_database_delete(ewkContext, engineOrigin->GetSecurityOrigin());
+ return ewk_context_web_database_delete(mEwkContext, engineOrigin->GetSecurityOrigin());
}
bool TizenWebEngineContext::GetWebStorageOrigins(Dali::WebEngineContext::WebEngineSecurityOriginAcquiredCallback callback)
{
- webSecurityOriginAcquiredCallback = callback;
- return ewk_context_web_storage_origins_get(ewkContext, &TizenWebEngineContext::OnSecurityOriginsAcquired, this);
+ mWebSecurityOriginAcquiredCallback = callback;
+ return ewk_context_web_storage_origins_get(mEwkContext, &TizenWebEngineContext::OnSecurityOriginsAcquired, this);
}
bool TizenWebEngineContext::GetWebStorageUsageForOrigin(WebEngineSecurityOrigin& origin, Dali::WebEngineContext::WebEngineStorageUsageAcquiredCallback callback)
{
- webStorageUsageAcquiredCallback = callback;
+ mWebStorageUsageAcquiredCallback = callback;
TizenWebEngineSecurityOrigin* engineOrigin = static_cast<TizenWebEngineSecurityOrigin*>(&origin);
- return ewk_context_web_storage_usage_for_origin_get(ewkContext, engineOrigin->GetSecurityOrigin(), &TizenWebEngineContext::OnStorageUsageAcquired, this);
+ return ewk_context_web_storage_usage_for_origin_get(mEwkContext, engineOrigin->GetSecurityOrigin(), &TizenWebEngineContext::OnStorageUsageAcquired, this);
}
void TizenWebEngineContext::DeleteAllWebStorage()
{
- ewk_context_web_storage_delete_all(ewkContext);
+ ewk_context_web_storage_delete_all(mEwkContext);
}
bool TizenWebEngineContext::DeleteWebStorage(WebEngineSecurityOrigin& origin)
{
TizenWebEngineSecurityOrigin* engineOrigin = static_cast<TizenWebEngineSecurityOrigin*>(&origin);
- return ewk_context_web_storage_origin_delete(ewkContext, engineOrigin->GetSecurityOrigin());
+ return ewk_context_web_storage_origin_delete(mEwkContext, engineOrigin->GetSecurityOrigin());
}
void TizenWebEngineContext::DeleteLocalFileSystem()
{
- ewk_context_local_file_system_all_delete(ewkContext);
+ ewk_context_local_file_system_all_delete(mEwkContext);
}
void TizenWebEngineContext::ClearCache()
{
- ewk_context_cache_clear(ewkContext);
+ ewk_context_cache_clear(mEwkContext);
}
bool TizenWebEngineContext::DeleteApplicationCache(WebEngineSecurityOrigin& origin)
{
TizenWebEngineSecurityOrigin* engineOrigin = static_cast<TizenWebEngineSecurityOrigin*>(&origin);
- return ewk_context_application_cache_delete(ewkContext, engineOrigin->GetSecurityOrigin());
+ return ewk_context_application_cache_delete(mEwkContext, engineOrigin->GetSecurityOrigin());
}
void TizenWebEngineContext::GetFormPasswordList(Dali::WebEngineContext::WebEngineFormPasswordAcquiredCallback callback)
{
- webFormPasswordAcquiredCallback = callback;
- ewk_context_form_password_data_list_get(ewkContext, &TizenWebEngineContext::OnFormPasswordsAcquired, this);
+ mWebFormPasswordAcquiredCallback = callback;
+ ewk_context_form_password_data_list_get(mEwkContext, &TizenWebEngineContext::OnFormPasswordsAcquired, this);
}
void TizenWebEngineContext::RegisterDownloadStartedCallback(Dali::WebEngineContext::WebEngineDownloadStartedCallback callback)
{
- webDownloadStartedCallback = callback;
- ewk_context_did_start_download_callback_set(ewkContext, &TizenWebEngineContext::OnDownloadStarted, this);
+ mWebDownloadStartedCallback = callback;
+ ewk_context_did_start_download_callback_set(mEwkContext, &TizenWebEngineContext::OnDownloadStarted, this);
}
void TizenWebEngineContext::RegisterMimeOverriddenCallback(Dali::WebEngineContext::WebEngineMimeOverriddenCallback callback)
{
- webMimeOverriddenCallback = callback;
- ewk_context_mime_override_callback_set(ewkContext, &TizenWebEngineContext::OnMimeOverridden, this);
+ mWebMimeOverriddenCallback = callback;
+ ewk_context_mime_override_callback_set(mEwkContext, &TizenWebEngineContext::OnMimeOverridden, this);
}
-void TizenWebEngineContext::OnSecurityOriginsAcquired(Eina_List* origins, void* userData)
+void TizenWebEngineContext::RegisterRequestInterceptedCallback(Dali::WebEngineContext::WebEngineRequestInterceptedCallback callback)
{
- TizenWebEngineContext* pThis = static_cast<TizenWebEngineContext*>(userData);
- std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>> originsList;
-
- Eina_List* it = nullptr;
- void* data = nullptr;
- EINA_LIST_FOREACH(origins, it, data)
+ mWebRequestInterceptedCallback = callback;
+ if (callback)
{
- if (data)
- {
- Ewk_Security_Origin* securityOrigin = static_cast<Ewk_Security_Origin*>(data);
- std::unique_ptr<Dali::WebEngineSecurityOrigin> origin(new TizenWebEngineSecurityOrigin(securityOrigin));
- originsList.push_back(std::move(origin));
- }
+ ewk_context_intercept_request_callback_set(mEwkContext, &TizenWebEngineContext::OnRequestIntercepted, this);
}
-
- pThis->webSecurityOriginAcquiredCallback(originsList);
-}
-
-void TizenWebEngineContext::OnStorageUsageAcquired(uint64_t usage, void* userData)
-{
- TizenWebEngineContext* pThis = static_cast<TizenWebEngineContext*>(userData);
- pThis->webStorageUsageAcquiredCallback(usage);
-}
-
-void TizenWebEngineContext::OnFormPasswordsAcquired(Eina_List* list, void* userData)
-{
- TizenWebEngineContext* pThis = static_cast<TizenWebEngineContext*>(userData);
- std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>> passwordDataList;
-
- Eina_List* it = nullptr;
- void* data = nullptr;
- EINA_LIST_FOREACH(list, it, data)
+ else
{
- if (data)
- {
- Ewk_Password_Data* ewkPassword = static_cast<Ewk_Password_Data*>(data);
- std::unique_ptr<Dali::WebEngineContext::PasswordData> passwordData(new Dali::WebEngineContext::PasswordData());
- passwordData->url = ewkPassword->url;
- passwordData->useFingerprint = ewkPassword->useFingerprint;
- passwordDataList.push_back(std::move(passwordData));
- }
+ ewk_context_intercept_request_callback_set(mEwkContext, nullptr, nullptr);
}
-
- pThis->webFormPasswordAcquiredCallback(passwordDataList);
-}
-
-void TizenWebEngineContext::OnDownloadStarted(const char* downloadUrl, void* userData)
-{
- TizenWebEngineContext* pThis = static_cast<TizenWebEngineContext*>(userData);
- pThis->webDownloadStartedCallback(downloadUrl);
-}
-
-Eina_Bool TizenWebEngineContext::OnMimeOverridden(const char* url, const char* defaultMime, char** newMime, void* userData)
-{
- TizenWebEngineContext* pThis = static_cast<TizenWebEngineContext*>(userData);
- std::string newOverridingMime;
- bool result = pThis->webMimeOverriddenCallback(url, defaultMime, newOverridingMime);
- if (result)
- {
- // this memory would be freed by chromium-efl if mime-overridden-callback returns true.
- *newMime = strdup(newOverridingMime.c_str());
- }
- return result;
}
void TizenWebEngineContext::EnableCache(bool cacheEnabled)
{
- ewk_context_cache_disabled_set(ewkContext, !cacheEnabled);
+ ewk_context_cache_disabled_set(mEwkContext, !cacheEnabled);
}
bool TizenWebEngineContext::IsCacheEnabled() const
{
- return !ewk_context_cache_disabled_get(ewkContext);
+ return !ewk_context_cache_disabled_get(mEwkContext);
}
void TizenWebEngineContext::SetAppId(const std::string& appId)
{
- ewk_context_tizen_app_id_set(ewkContext, appId.c_str());
+ ewk_context_tizen_app_id_set(mEwkContext, appId.c_str());
}
bool TizenWebEngineContext::SetAppVersion(const std::string& appVersion)
{
- return ewk_context_tizen_app_version_set(ewkContext, appVersion.c_str());
+ return ewk_context_tizen_app_version_set(mEwkContext, appVersion.c_str());
}
void TizenWebEngineContext::SetApplicationType(const ApplicationType applicationType)
{
- ewk_context_application_type_set(ewkContext, static_cast<Ewk_Application_Type>(applicationType));
+ ewk_context_application_type_set(mEwkContext, static_cast<Ewk_Application_Type>(applicationType));
}
void TizenWebEngineContext::SetTimeOffset(float timeOffset)
{
- ewk_context_time_offset_set(ewkContext, double(timeOffset));
+ ewk_context_time_offset_set(mEwkContext, double(timeOffset));
}
void TizenWebEngineContext::SetTimeZoneOffset(float timeZoneOffset, float daylightSavingTime)
{
- ewk_context_timezone_offset_set(ewkContext, double(timeZoneOffset), double(daylightSavingTime));
+ ewk_context_timezone_offset_set(mEwkContext, double(timeZoneOffset), double(daylightSavingTime));
}
void TizenWebEngineContext::SetDefaultZoomFactor(float zoomFactor)
{
- ewk_context_default_zoom_factor_set(ewkContext, double(zoomFactor));
+ ewk_context_default_zoom_factor_set(mEwkContext, double(zoomFactor));
}
float TizenWebEngineContext::GetDefaultZoomFactor() const
{
- return (float)ewk_context_default_zoom_factor_get(ewkContext);
+ return (float)ewk_context_default_zoom_factor_get(mEwkContext);
}
void TizenWebEngineContext::RegisterUrlSchemesAsCorsEnabled(const std::vector<std::string>& schemes)
list = eina_list_append(list, (*it).c_str());
}
- ewk_context_register_url_schemes_as_cors_enabled(ewkContext, list);
+ ewk_context_register_url_schemes_as_cors_enabled(mEwkContext, list);
}
void TizenWebEngineContext::RegisterJsPluginMimeTypes(const std::vector<std::string>& mimeTypes)
list = eina_list_append(list, (*it).c_str());
}
- ewk_context_register_jsplugin_mime_types(ewkContext, list);
+ ewk_context_register_jsplugin_mime_types(mEwkContext, list);
}
bool TizenWebEngineContext::DeleteAllApplicationCache()
{
- return ewk_context_application_cache_delete_all(ewkContext);
+ return ewk_context_application_cache_delete_all(mEwkContext);
}
bool TizenWebEngineContext::DeleteAllWebIndexedDatabase()
{
- return ewk_context_web_indexed_database_delete_all(ewkContext);
+ return ewk_context_web_indexed_database_delete_all(mEwkContext);
}
void TizenWebEngineContext::DeleteFormPasswordDataList(const std::vector<std::string>& list)
eList = eina_list_append(eList, (*it).c_str());
}
- ewk_context_form_password_data_list_free(ewkContext, eList);
+ ewk_context_form_password_data_list_free(mEwkContext, eList);
}
void TizenWebEngineContext::DeleteAllFormPasswordData()
{
- ewk_context_form_password_data_delete_all(ewkContext);
+ ewk_context_form_password_data_delete_all(mEwkContext);
}
void TizenWebEngineContext::DeleteAllFormCandidateData()
{
- ewk_context_form_candidate_data_delete_all(ewkContext);
+ ewk_context_form_candidate_data_delete_all(mEwkContext);
}
bool TizenWebEngineContext::FreeUnusedMemory()
{
- return ewk_context_notify_low_memory(ewkContext);
+ return ewk_context_notify_low_memory(mEwkContext);
+}
+
+void TizenWebEngineContext::RequestIntercepted(Dali::WebEngineRequestInterceptorPtr interceptor)
+{
+ {
+ Mutex::ScopedLock lock(mMutex);
+ mRequestInterceptorQueue.push(interceptor);
+ // Trigger an event on main thread.
+ mRequestInterceptorEventTrigger->Trigger();
+ }
+
+ // Wait for tasks from main thread and execute tasks.
+ TizenWebEngineRequestInterceptor* requestInterceptor = static_cast<TizenWebEngineRequestInterceptor*>(interceptor.Get());
+ requestInterceptor->WaitAndRunTasks();
+}
+
+void TizenWebEngineContext::OnRequestInterceptedEventCallback()
+{
+ Dali::WebEngineRequestInterceptorPtr interceptor;
+ {
+ Mutex::ScopedLock lock(mMutex);
+ interceptor = mRequestInterceptorQueue.front();
+ mRequestInterceptorQueue.pop();
+ }
+
+ // Execuate callback.
+ mWebRequestInterceptedCallback(interceptor);
+
+ // Notify io thread that tasks are ready on main thread.
+ TizenWebEngineRequestInterceptor* requestInterceptor = static_cast<TizenWebEngineRequestInterceptor*>(interceptor.Get());
+ requestInterceptor->NotifyTaskReady();
+}
+
+void TizenWebEngineContext::OnRequestIntercepted(Ewk_Context*, Ewk_Intercept_Request* request, void* userData)
+{
+ TizenWebEngineContext* pThis = static_cast<TizenWebEngineContext*>(userData);
+ Dali::WebEngineRequestInterceptorPtr webInterceptor = new TizenWebEngineRequestInterceptor(request);
+ pThis->RequestIntercepted(webInterceptor);
+}
+
+void TizenWebEngineContext::OnSecurityOriginsAcquired(Eina_List* origins, void* userData)
+{
+ TizenWebEngineContext* pThis = static_cast<TizenWebEngineContext*>(userData);
+ std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>> originsList;
+
+ Eina_List* it = nullptr;
+ void* data = nullptr;
+ EINA_LIST_FOREACH(origins, it, data)
+ {
+ if (data)
+ {
+ Ewk_Security_Origin* securityOrigin = static_cast<Ewk_Security_Origin*>(data);
+ std::unique_ptr<Dali::WebEngineSecurityOrigin> origin(new TizenWebEngineSecurityOrigin(securityOrigin));
+ originsList.push_back(std::move(origin));
+ }
+ }
+
+ pThis->mWebSecurityOriginAcquiredCallback(originsList);
+}
+
+void TizenWebEngineContext::OnStorageUsageAcquired(uint64_t usage, void* userData)
+{
+ TizenWebEngineContext* pThis = static_cast<TizenWebEngineContext*>(userData);
+ pThis->mWebStorageUsageAcquiredCallback(usage);
+}
+
+void TizenWebEngineContext::OnFormPasswordsAcquired(Eina_List* list, void* userData)
+{
+ TizenWebEngineContext* pThis = static_cast<TizenWebEngineContext*>(userData);
+ std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>> passwordDataList;
+
+ Eina_List* it = nullptr;
+ void* data = nullptr;
+ EINA_LIST_FOREACH(list, it, data)
+ {
+ if (data)
+ {
+ Ewk_Password_Data* ewkPassword = static_cast<Ewk_Password_Data*>(data);
+ std::unique_ptr<Dali::WebEngineContext::PasswordData> passwordData(new Dali::WebEngineContext::PasswordData());
+ passwordData->url = ewkPassword->url;
+ passwordData->useFingerprint = ewkPassword->useFingerprint;
+ passwordDataList.push_back(std::move(passwordData));
+ }
+ }
+
+ pThis->mWebFormPasswordAcquiredCallback(passwordDataList);
+}
+
+void TizenWebEngineContext::OnDownloadStarted(const char* downloadUrl, void* userData)
+{
+ TizenWebEngineContext* pThis = static_cast<TizenWebEngineContext*>(userData);
+ pThis->mWebDownloadStartedCallback(downloadUrl);
+}
+
+Eina_Bool TizenWebEngineContext::OnMimeOverridden(const char* url, const char* defaultMime, char** newMime, void* userData)
+{
+ TizenWebEngineContext* pThis = static_cast<TizenWebEngineContext*>(userData);
+ std::string newOverridingMime;
+ bool result = pThis->mWebMimeOverriddenCallback(url, defaultMime, newOverridingMime);
+ if (result)
+ {
+ // this memory would be freed by chromium-efl if mime-overridden-callback returns true.
+ *newMime = strdup(newOverridingMime.c_str());
+ }
+ return result;
}
} // namespace Plugin
// EXTERNAL INCLUDES
#include <Eina.h>
+
+#include <dali/devel-api/adaptor-framework/event-thread-callback.h>
#include <dali/devel-api/adaptor-framework/web-engine-context.h>
+#include <dali/devel-api/threading/mutex.h>
+
+#include <memory>
+#include <queue>
#include <string>
+#include <ewk_intercept_request.h>
+
struct Ewk_Context;
namespace Dali
void RegisterMimeOverriddenCallback(WebEngineMimeOverriddenCallback callback) override;
/**
+ * @copydoc Dali::WebEngineContext::RegisterRequestInterceptedCallback()
+ */
+ void RegisterRequestInterceptedCallback(WebEngineRequestInterceptedCallback callback) override;
+
+ /**
* @copydoc Dali::WebEngineContext::EnableCache()
*/
void EnableCache(bool cacheEnabled) override;
private:
/**
+ * @brief Callback to be called when http request need be intercepted.
+ * @param [in] interceptor The http request interceptor.
+ */
+ void RequestIntercepted(Dali::WebEngineRequestInterceptorPtr interceptor);
+
+ /**
+ * @brief Event callback for request interceptor is called on main thread.
+ */
+ void OnRequestInterceptedEventCallback();
+
+ /**
+ * @brief Callback for intercepting http request.
+ *
+ * @param[in] context context of web engine
+ * @param[in] request http request
+ * @param[in] data data for callback
+ */
+ static void OnRequestIntercepted(Ewk_Context* context, Ewk_Intercept_Request* request, void* data);
+
+ /**
* @brief Callback for getting security origins.
*
* @param[in] origins security origins list
static Eina_Bool OnMimeOverridden(const char* url, const char* mime, char** newMime, void* data);
private:
- WebEngineSecurityOriginAcquiredCallback webSecurityOriginAcquiredCallback;
- WebEngineStorageUsageAcquiredCallback webStorageUsageAcquiredCallback;
- WebEngineFormPasswordAcquiredCallback webFormPasswordAcquiredCallback;
- WebEngineDownloadStartedCallback webDownloadStartedCallback;
- WebEngineMimeOverriddenCallback webMimeOverriddenCallback;
-
- Ewk_Context* ewkContext;
+ WebEngineSecurityOriginAcquiredCallback mWebSecurityOriginAcquiredCallback;
+ WebEngineStorageUsageAcquiredCallback mWebStorageUsageAcquiredCallback;
+ WebEngineFormPasswordAcquiredCallback mWebFormPasswordAcquiredCallback;
+ WebEngineDownloadStartedCallback mWebDownloadStartedCallback;
+ WebEngineMimeOverriddenCallback mWebMimeOverriddenCallback;
+ WebEngineRequestInterceptedCallback mWebRequestInterceptedCallback;
+
+ Ewk_Context* mEwkContext;
+ Dali::Mutex mMutex;
+ std::unique_ptr<Dali::EventThreadCallback> mRequestInterceptorEventTrigger;
+ std::queue<WebEngineRequestInterceptorPtr> mRequestInterceptorQueue;
};
} // namespace Plugin
return value ? std::string(value) : std::string();
}
-Dali::Property::Map& TizenWebEngineHitTest::GetAttributes() const
+Dali::Property::Map TizenWebEngineHitTest::GetAttributes() const
{
Eina_Hash* hash = ewk_hit_test_attribute_hash_get(ewkHitTest);
attributes.Clear();
- eina_hash_foreach(hash, &TizenWebEngineHitTest::IterateAttribute, &attributes);
+ eina_hash_foreach(hash, &TizenWebEngineHitTest::IterateAttributes, this);
return attributes;
}
Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
}
-Eina_Bool TizenWebEngineHitTest::IterateAttribute(const Eina_Hash*, const void* key, void* data, void* fdata)
+Eina_Bool TizenWebEngineHitTest::IterateAttributes(const Eina_Hash*, const void* key, void* data, void* fdata)
{
- Dali::Property::Map* hashMap = (Dali::Property::Map*)fdata;
- const char* attributeKey = (const char*)key;
- hashMap->Insert(attributeKey, (char*)data);
+ TizenWebEngineHitTest* pThis = (TizenWebEngineHitTest*)fdata;
+ pThis->attributes.Insert((const char*)key, (char*)data);
return true;
}
/**
* @copydoc Dali::WebEngineHitTest::GetAttributes()
*/
- Dali::Property::Map& GetAttributes() const override;
+ Dali::Property::Map GetAttributes() const override;
/**
* @copydoc Dali::WebEngineHitTest::GetImageFileNameExtension()
*
* @return true if succeeded, false otherwise
*/
- static Eina_Bool IterateAttribute(const Eina_Hash* hash, const void* key, void* data, void* fdata);
+ static Eina_Bool IterateAttributes(const Eina_Hash* hash, const void* key, void* data, void* fdata);
private:
Ewk_Hit_Test* ewkHitTest;
+++ /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-request-interceptor-task-queue.h"
-
-namespace Dali
-{
-namespace Plugin
-{
-
-std::atomic<TaskQueue*> TaskQueue::mInstance { nullptr };
-std::mutex TaskQueue::mInstanceMutex;
-
-TaskQueue* TaskQueue::GetInstance()
-{
- if(mInstance == nullptr)
- {
- std::lock_guard<std::mutex> lock(mInstanceMutex);
- if(mInstance == nullptr)
- {
- mInstance = new TaskQueue();
- }
- }
- return mInstance;
-}
-
-TaskQueue::TaskQueue()
- : mIsThreadWaiting(true)
-{
-}
-
-void TaskQueue::AddTask(TaskCallback task)
-{
- std::unique_lock<std::mutex> lock(mMutex);
- mTaskQueue.push_back(task);
-}
-
-void TaskQueue::NotifyTaskReady()
-{
- std::unique_lock<std::mutex> lock(mMutex);
- mIsThreadWaiting = false;
-
- // wake up the request interceptor thread
- mCondition.notify_all();
-}
-
-void TaskQueue::WaitAndRunTasks()
-{
- // wait for tasks.
- std::unique_lock<std::mutex> lock(mMutex);
- while(mIsThreadWaiting)
- {
- mCondition.wait(lock);
- }
- mIsThreadWaiting = true;
-
- // execute tasks.
- for(std::vector<TaskCallback>::iterator iter = mTaskQueue.begin(); iter != mTaskQueue.end(); iter++)
- {
- (*iter)();
- }
- mTaskQueue.clear();
-}
-
-} // namespace Plugin
-} // namespace Dali
+++ /dev/null
-#ifndef DALI_PLUGIN_TIZEN_WEB_ENGINE_REQUEST_INTERCEPTOR_TASK_QUEUE_H
-#define DALI_PLUGIN_TIZEN_WEB_ENGINE_REQUEST_INTERCEPTOR_TASK_QUEUE_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 <atomic>
-#include <condition_variable>
-#include <functional>
-#include <mutex>
-#include <vector>
-
-namespace Dali
-{
-namespace Plugin
-{
-
-/**
- * @brief A class TaskQueue for running tasks. It is thread-safe.
- */
-class TaskQueue
-{
-public:
- static TaskQueue* GetInstance();
-
- /**
- * @brief Task callback.
- */
- using TaskCallback = std::function<bool(void)>;
-
- /**
- * @brief Add task.
- */
- void AddTask(TaskCallback taskQueue);
-
- /**
- * @brief Notify that tasks are ready.
- */
- void NotifyTaskReady();
-
- /**
- * @brief Wait for and run tasks.
- */
- void WaitAndRunTasks();
-
-private:
- TaskQueue();
-
- static std::atomic<TaskQueue*> mInstance;
- static std::mutex mInstanceMutex;
-
- bool mIsThreadWaiting;
- std::vector<TaskCallback> mTaskQueue;
- std::mutex mMutex;
- std::condition_variable mCondition;\r
-};
-
-} // namespace Plugin
-} // namespace Dali
-
-#endif // DALI_PLUGIN_TIZEN_WEB_ENGINE_REQUEST_INTERCEPTOR_TASK_QUEUE_H
*/
#include "tizen-web-engine-request-interceptor.h"
-#include "tizen-web-engine-request-interceptor-task-queue.h"
namespace Dali
{
{
requestUrl = std::string(url);
}
+
+ const char* method = ewk_intercept_request_http_method_get(ewkRequestInterceptor);
+ if (method)
+ {
+ requestMethod = std::string(method);
+ }
+
+ const Eina_Hash* hash = ewk_intercept_request_headers_get(ewkRequestInterceptor);
+ if (hash)
+ {
+ eina_hash_foreach(hash, &TizenWebEngineRequestInterceptor::IterateRequestHeaders, this);
+ }
+
+ mIsThreadWaiting = true;
}
TizenWebEngineRequestInterceptor::~TizenWebEngineRequestInterceptor()
return requestUrl;
}
+Dali::Property::Map TizenWebEngineRequestInterceptor::GetHeaders() const
+{
+ return requestHeaders;
+}
+
+std::string TizenWebEngineRequestInterceptor::GetMethod() const
+{
+ return requestMethod;
+}
+
bool TizenWebEngineRequestInterceptor::Ignore()
{
- TaskQueue::GetInstance()->AddTask(std::bind(&TizenWebEngineRequestInterceptor::IgnoreUi, this));
+ std::unique_lock<std::mutex> lock(mMutex);
+ mTaskQueue.push_back(std::bind(&TizenWebEngineRequestInterceptor::IgnoreUi, this));
return true;
}
+bool TizenWebEngineRequestInterceptor::IgnoreUi()
+{
+ return ewk_intercept_request_ignore(ewkRequestInterceptor);
+}
+
bool TizenWebEngineRequestInterceptor::SetResponseStatus(int statusCode, const std::string& customStatusText)
{
- TaskQueue::GetInstance()->AddTask(std::bind(&TizenWebEngineRequestInterceptor::SetResponseStatusUi, this, statusCode, customStatusText));
- return true;
+ return ewk_intercept_request_response_status_set(ewkRequestInterceptor, statusCode, customStatusText.c_str());
}
bool TizenWebEngineRequestInterceptor::AddResponseHeader(const std::string& fieldName, const std::string& fieldValue)
{
- TaskQueue::GetInstance()->AddTask(std::bind(&TizenWebEngineRequestInterceptor::AddResponseHeaderUi, this, fieldName, fieldValue));
- return true;
+ return ewk_intercept_request_response_header_add(ewkRequestInterceptor, fieldName.c_str(), fieldValue.c_str());
}
-bool TizenWebEngineRequestInterceptor::AddResponseBody(const std::string& body, uint32_t length)
+bool TizenWebEngineRequestInterceptor::AddResponseHeaders(const Dali::Property::Map& headers)
{
- TaskQueue::GetInstance()->AddTask(std::bind(&TizenWebEngineRequestInterceptor::AddResponseBodyUi, this, body, length));
- return true;
+ Eina_Hash* headerMap = eina_hash_string_small_new(nullptr);
+ Dali::Property::Map::SizeType count = headers.Count();
+ for(uint32_t i = 0; i < count; i++)
+ {
+ Dali::Property::Key key = headers.GetKeyAt(i);
+ if(key.type == Dali::Property::Key::STRING)
+ {
+ std::string value;
+ if(headers.GetValue(i).Get(value))
+ {
+ eina_hash_add(headerMap, key.stringKey.c_str(), value.c_str());
+ }
+ }
+ }
+ return ewk_intercept_request_response_header_map_add(ewkRequestInterceptor, headerMap);
}
-void TizenWebEngineRequestInterceptor::WaitAndRunTasks()
+bool TizenWebEngineRequestInterceptor::AddResponseBody(const std::string& body, uint32_t length)
{
- TaskQueue::GetInstance()->WaitAndRunTasks();
+ return ewk_intercept_request_response_body_set(ewkRequestInterceptor, body.c_str(), length);
}
-void TizenWebEngineRequestInterceptor::NotifyTaskReady()
+bool TizenWebEngineRequestInterceptor::AddResponse(const std::string& headers, const std::string& body, uint32_t length)
{
- TaskQueue::GetInstance()->NotifyTaskReady();
+ return ewk_intercept_request_response_set(ewkRequestInterceptor, headers.c_str(), body.c_str(), length);
}
-bool TizenWebEngineRequestInterceptor::IgnoreUi()
+bool TizenWebEngineRequestInterceptor::WriteResponseChunk(const std::string& chunk, uint32_t length)
{
- return ewk_intercept_request_ignore(ewkRequestInterceptor);
+ return ewk_intercept_request_response_write_chunk(ewkRequestInterceptor, chunk.c_str(), length);
}
-bool TizenWebEngineRequestInterceptor::SetResponseStatusUi(int statusCode, const std::string& customStatusText)
+void TizenWebEngineRequestInterceptor::WaitAndRunTasks()
{
- return ewk_intercept_request_response_status_set(ewkRequestInterceptor, statusCode, customStatusText.c_str());
+ // wait for tasks from main thread.
+ std::unique_lock<std::mutex> lock(mMutex);
+ while(mIsThreadWaiting)
+ {
+ mCondition.wait(lock);
+ }
+ mIsThreadWaiting = true;
+
+ // execute tasks on io thread.
+ for(std::vector<TaskCallback>::iterator iter = mTaskQueue.begin(); iter != mTaskQueue.end(); iter++)
+ {
+ (*iter)();
+ }
+ mTaskQueue.clear();
}
-bool TizenWebEngineRequestInterceptor::AddResponseHeaderUi(const std::string& fieldName, const std::string& fieldValue)
+void TizenWebEngineRequestInterceptor::NotifyTaskReady()
{
- return ewk_intercept_request_response_header_add(ewkRequestInterceptor, fieldName.c_str(), fieldValue.c_str());
+ std::unique_lock<std::mutex> lock(mMutex);
+ mIsThreadWaiting = false;
+
+ // wake up the io thread
+ mCondition.notify_all();
}
-bool TizenWebEngineRequestInterceptor::AddResponseBodyUi(const std::string& body, uint32_t length)
+Eina_Bool TizenWebEngineRequestInterceptor::IterateRequestHeaders(const Eina_Hash*, const void* key, void* data, void* fdata)
{
- return ewk_intercept_request_response_body_set(ewkRequestInterceptor, body.c_str(), length);
+ TizenWebEngineRequestInterceptor* pThis = (TizenWebEngineRequestInterceptor*)fdata;
+ pThis->requestHeaders.Insert((const char*)key, (char*)data);
+ return true;
}
} // namespace Plugin
// EXTERNAL INCLUDES
#include <dali/devel-api/adaptor-framework/web-engine-request-interceptor.h>
+#include <atomic>
+#include <condition_variable>
#include <functional>
+#include <mutex>
#include <string>
#include <vector>
std::string GetUrl() const override;
/**
+ * @copydoc Dali::WebEngineRequestInterceptor::GetHeaders()
+ */
+ Dali::Property::Map GetHeaders() const override;
+
+ /**
+ * @copydoc Dali::WebEngineRequestInterceptor::GetMethod()
+ */
+ std::string GetMethod() const override;
+
+ /**
* @copydoc Dali::WebEngineRequestInterceptor::Ignore()
*/
bool Ignore() override;
bool AddResponseHeader(const std::string& fieldName, const std::string& fieldValue) override;
/**
+ * @copydoc Dali::WebEngineRequestInterceptor::AddResponseHeaders()
+ */
+ bool AddResponseHeaders(const Dali::Property::Map& headers) override;
+
+ /**
* @copydoc Dali::WebEngineRequestInterceptor::AddResponseBody()
*/
bool AddResponseBody(const std::string& body, uint32_t length) override;
/**
- * @brief Wait for and run tasks on ui-thread.
+ * @copydoc Dali::WebEngineRequestInterceptor::AddResponse()
+ */
+ bool AddResponse(const std::string& headers, const std::string& body, uint32_t length) override;
+
+ /**
+ * @copydoc Dali::WebEngineRequestInterceptor::WriteResponseChunk()
+ */
+ bool WriteResponseChunk(const std::string& chunk, uint32_t length) override;
+
+ /**
+ * @brief Wait for and run tasks on io-thread.
*/
void WaitAndRunTasks();
private:
/**
- * @copydoc Dali::WebEngineRequestInterceptor::Ignore()
- * @note It is run on ui thread
+ * @brief Task callback.
*/
- bool IgnoreUi();
+ using TaskCallback = std::function<bool(void)>;
/**
- * @copydoc Dali::WebEngineRequestInterceptor::SetResponseStatus()
- * @note It is run on ui thread
- */
- bool SetResponseStatusUi(int statusCode, const std::string& customStatusText);
-
- /**
- * @copydoc Dali::WebEngineRequestInterceptor::AddResponseHeader()
- * @note It is run on ui thread
+ * @copydoc Dali::WebEngineRequestInterceptor::Ignore()
+ * @note It is run on IO thread
*/
- bool AddResponseHeaderUi(const std::string& fieldName, const std::string& fieldValue);
+ bool IgnoreUi();
/**
- * @copydoc Dali::WebEngineRequestInterceptor::AddResponseBody()
- * @note It is run on ui thread
+ * @brief Iterator attributes.
+ *
+ * @param[in] hash Hash map that need be iterated
+ * @param[in] key Key of hash map
+ * @param[in] data Value of hash map
+ * @param[in] fdata User data for iterating hash map
+ *
+ * @return true if succeeded, false otherwise
*/
- bool AddResponseBodyUi(const std::string& body, uint32_t length);
+ static Eina_Bool IterateRequestHeaders(const Eina_Hash* hash, const void* key, void* data, void* fdata);
private:
Ewk_Intercept_Request* ewkRequestInterceptor;
std::string requestUrl;
+ std::string requestMethod;
+ Dali::Property::Map requestHeaders;
+
+ bool mIsThreadWaiting;
+ std::vector<TaskCallback> mTaskQueue;
+ std::mutex mMutex;
+ std::condition_variable mCondition;
};
} // namespace Plugin
void GetFormPasswordList(WebEngineFormPasswordAcquiredCallback callback) override {}
void RegisterDownloadStartedCallback(WebEngineDownloadStartedCallback callback) override {}
void RegisterMimeOverriddenCallback(WebEngineMimeOverriddenCallback callback) override {}
+ void RegisterRequestInterceptedCallback(WebEngineRequestInterceptedCallback callback) override {}
void EnableCache(bool cacheDisabled) override {}
bool IsCacheEnabled() const override { return false; }
void SetAppId(const std::string& appId) override { }
// NOT IMPLEMENTED
}
-void TizenWebEngineLWE::RegisterRequestInterceptorCallback(WebEngineRequestInterceptorCallback callback)
-{
- // NOT IMPLEMENTED
-}
-
void TizenWebEngineLWE::RegisterConsoleMessageReceivedCallback(WebEngineConsoleMessageReceivedCallback callback)
{
// NOT IMPLEMENTED
void RegisterFormRepostDecidedCallback(WebEngineFormRepostDecidedCallback callback) override;
/**
- * @copydoc Dali::WebEnginePlugin::RegisterRequestInterceptorCallback()
- */
- void RegisterRequestInterceptorCallback(WebEngineRequestInterceptorCallback callback) override;
-
- /**
* @copydoc Dali::WebEnginePlugin::RegisterConsoleMessageReceivedCallback()
*/
void RegisterConsoleMessageReceivedCallback(WebEngineConsoleMessageReceivedCallback callback) override;
projects / platform / core / uifw / dali-extension.git / commitdiff