/*
- * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2022 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.
#include "toolkit-timer.h"
-#include <dali/devel-api/adaptor-framework/web-engine.h>
-#include <dali/devel-api/adaptor-framework/web-engine-back-forward-list.h>
-#include <dali/devel-api/adaptor-framework/web-engine-back-forward-list-item.h>
-#include <dali/devel-api/adaptor-framework/web-engine-context.h>
-#include <dali/devel-api/adaptor-framework/web-engine-cookie-manager.h>
-#include <dali/devel-api/adaptor-framework/web-engine-form-repost-decision.h>
-#include <dali/devel-api/adaptor-framework/web-engine-request-interceptor.h>
-#include <dali/devel-api/adaptor-framework/web-engine-settings.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-back-forward-list.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-back-forward-list-item.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-certificate.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-console-message.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-context.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-context-menu.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-context-menu-item.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-cookie-manager.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-form-repost-decision.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-frame.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-hit-test.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-http-auth-handler.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-load-error.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-policy-decision.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-request-interceptor.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-security-origin.h>
+#include <dali/devel-api/adaptor-framework/web-engine/web-engine-settings.h>
#include <dali/public-api/adaptor-framework/native-image-source.h>
#include <dali/public-api/images/pixel-data.h>
#include <dali/public-api/object/any.h>
#include <dali/public-api/object/base-object.h>
+#include <dali/public-api/object/property-map.h>
#include <memory>
#include <string.h>
#include <toolkit-application.h>
{
class WebEngine;
+class MockWebEngineContext;
+class MockWebEngineCookieManager;
namespace
{
-
// Generally only one WebEngine instance exists.
// If > 1, a new web engine has been created by CreateWindowSignal.
-static WebEngine* gInstance = 0;
-static int gInstanceCount = 0;
+WebEngine* gInstance = nullptr;
+int gInstanceCount = 0;
+MockWebEngineContext* gWebEngineContextInstance = nullptr;
+MockWebEngineCookieManager* gMockWebEngineCookieManager = nullptr;
bool OnGoBack();
bool OnGoForward();
bool OnJavaScriptAlert();
bool OnJavaScriptConfirm();
bool OnJavaScriptPrompt();
+bool OnHitTestCreated();
bool OnScrollEdge();
bool OnScreenshotCaptured();
bool OnVideoPlaying();
bool OnGeolocationPermission();
bool OnClearHistory();
+bool OnSecurityOriginAcquired();
+bool OnStorageUsageAcquired();
+bool OnFormPasswordAcquired();
+bool OnDownloadStarted();
+bool OnMimeOverridden();
+bool OnRequestIntercepted();
+bool OnChangesWatch();
+bool OnPlainTextReceived();
static void ConnectToGlobalSignal( bool ( *func )() )
{
void SetProxyUri( const std::string& uri ) override
{
+ mockProxyUri = uri;
+ }
+
+ std::string GetProxyUri() const override
+ {
+ return mockProxyUri;
+ }
+
+ void SetProxyBypassRule(const std::string& proxy, const std::string& bypass) override
+ {
+ mockBypassRule = bypass;
+ }
+
+ std::string GetProxyBypassRule() const override
+ {
+ return mockBypassRule;
}
void SetDefaultProxyAuth( const std::string& username, const std::string& password ) override
void SetCertificateFilePath( const std::string& certificatePath ) override
{
+ mockCertificateFilePath = certificatePath;
}
- void DeleteWebDatabase() override
+ std::string GetCertificateFilePath() const override
{
+ return mockCertificateFilePath;
}
- void DeleteWebStorage() override
+ void DeleteAllWebDatabase() override
{
}
- void DeleteLocalFileSystem() override
+ bool GetWebDatabaseOrigins(Dali::WebEngineContext::WebEngineSecurityOriginAcquiredCallback callback) override
+ {
+ if (callback)
+ {
+ ConnectToGlobalSignal(&OnSecurityOriginAcquired);
+ mSecurityOriginAcquiredCallback = callback;
+ }
+ return true;
+ }
+
+ bool DeleteWebDatabase(Dali::WebEngineSecurityOrigin& origin) override
+ {
+ return true;
+ }
+
+ bool GetWebStorageOrigins(Dali::WebEngineContext::WebEngineSecurityOriginAcquiredCallback callback) override
+ {
+ if (callback)
+ {
+ ConnectToGlobalSignal(&OnSecurityOriginAcquired);
+ mSecurityOriginAcquiredCallback = callback;
+ }
+ return true;
+ }
+
+ bool GetWebStorageUsageForOrigin(Dali::WebEngineSecurityOrigin& origin, Dali::WebEngineContext::WebEngineStorageUsageAcquiredCallback callback) override
+ {
+ if (callback)
+ {
+ ConnectToGlobalSignal(&OnStorageUsageAcquired);
+ mStorageUsageAcquiredCallback = callback;
+ }
+ return true;
+ }
+
+ void DeleteAllWebStorage() override
+ {
+ }
+
+ bool DeleteWebStorage(Dali::WebEngineSecurityOrigin& origin) override
{
+ return true;
}
- void DisableCache( bool cacheDisabled ) override
+ void DeleteLocalFileSystem() override
{
}
{
}
+ bool DeleteApplicationCache(Dali::WebEngineSecurityOrigin& origin) override
+ {
+ return true;
+ }
+
+ void GetFormPasswordList(Dali::WebEngineContext::WebEngineFormPasswordAcquiredCallback callback) override
+ {
+ if (callback)
+ {
+ ConnectToGlobalSignal(&OnFormPasswordAcquired);
+ mFormPasswordAcquiredCallback = callback;
+ }
+ }
+
+ void RegisterDownloadStartedCallback(Dali::WebEngineContext::WebEngineDownloadStartedCallback callback) override
+ {
+ if (callback)
+ {
+ ConnectToGlobalSignal(&OnDownloadStarted);
+ mDownloadStartedCallback = callback;
+ }
+ }
+
+ void RegisterMimeOverriddenCallback(Dali::WebEngineContext::WebEngineMimeOverriddenCallback callback) override
+ {
+ if (callback)
+ {
+ ConnectToGlobalSignal(&OnMimeOverridden);
+ mMimeOverriddenCallback = callback;
+ }
+ }
+
+ void RegisterRequestInterceptedCallback(Dali::WebEngineContext::WebEngineRequestInterceptedCallback callback) override
+ {
+ if (callback)
+ {
+ ConnectToGlobalSignal(&OnRequestIntercepted);
+ mRequestInterceptedCallback = callback;
+ }
+ }
+
+ void EnableCache( bool cacheEnabled ) override
+ {
+ mockCacheEnabled = cacheEnabled;
+ }
+
+ bool IsCacheEnabled() const override
+ {
+ return mockCacheEnabled;
+ }
+
+ void SetAppId(const std::string& appID) override
+ {
+ }
+
+ bool SetAppVersion(const std::string& appVersion) override
+ {
+ return true;
+ }
+
+ void SetApplicationType(const Dali::WebEngineContext::ApplicationType applicationType) override
+ {
+ }
+
+ void SetTimeOffset(float timeOffset) override
+ {
+ }
+
+ void SetTimeZoneOffset(float timeZoneOffset, float daylightSavingTime) override
+ {
+ }
+
+ void RegisterUrlSchemesAsCorsEnabled(const std::vector<std::string>& schemes) override
+ {
+ }
+
+ void RegisterJsPluginMimeTypes(const std::vector<std::string>& mimeTypes) override
+ {
+ }
+
+ void SetDefaultZoomFactor(float zoomFactor) override
+ {
+ mockZoomFactor = zoomFactor;
+ }
+
+ float GetDefaultZoomFactor() const override
+ {
+ return mockZoomFactor;
+ }
+
+ bool DeleteAllApplicationCache() override
+ {
+ return true;
+ }
+
+ bool DeleteAllWebIndexedDatabase() override
+ {
+ return true;
+ }
+
+ void DeleteFormPasswordDataList(const std::vector<std::string>& list) override
+ {
+ }
+
+ void DeleteAllFormPasswordData() override
+ {
+ }
+
+ void DeleteAllFormCandidateData() override
+ {
+ }
+
+ bool FreeUnusedMemory() override
+ {
+ return true;
+ }
+
+public:
+ Dali::WebEngineContext::WebEngineSecurityOriginAcquiredCallback mSecurityOriginAcquiredCallback;
+ Dali::WebEngineContext::WebEngineStorageUsageAcquiredCallback mStorageUsageAcquiredCallback;
+ Dali::WebEngineContext::WebEngineFormPasswordAcquiredCallback mFormPasswordAcquiredCallback;
+ Dali::WebEngineContext::WebEngineDownloadStartedCallback mDownloadStartedCallback;
+ Dali::WebEngineContext::WebEngineMimeOverriddenCallback mMimeOverriddenCallback;
+ Dali::WebEngineContext::WebEngineRequestInterceptedCallback mRequestInterceptedCallback;
+
private:
Dali::WebEngineContext::CacheModel mockModel;
+ std::string mockProxyUri;
+ std::string mockBypassRule;
+ std::string mockCertificateFilePath;
+ bool mockCacheEnabled;
+ float mockZoomFactor;
};
+Dali::WebEngineContext* GetContext()
+{
+ if (!gWebEngineContextInstance)
+ {
+ gWebEngineContextInstance = new MockWebEngineContext();
+ }
+ return gWebEngineContextInstance;
+}
+
class MockWebEngineCookieManager : public Dali::WebEngineCookieManager
{
public:
{
}
+ void ChangesWatch( Dali::WebEngineCookieManager::WebEngineCookieManagerChangesWatchCallback callback ) override
+ {
+ if ( callback )
+ {
+ ConnectToGlobalSignal( &OnChangesWatch );
+ mChangesWatchCallback = callback;
+ }
+ }
+
+public:
+ Dali::WebEngineCookieManager::WebEngineCookieManagerChangesWatchCallback mChangesWatchCallback;
+
private:
Dali::WebEngineCookieManager::CookieAcceptPolicy mockCookieAcceptPolicy;
};
+Dali::WebEngineCookieManager* GetCookieManager()
+{
+ if (!gMockWebEngineCookieManager)
+ {
+ gMockWebEngineCookieManager = new MockWebEngineCookieManager();
+ }
+ return gMockWebEngineCookieManager;
+}
+
class MockWebEngineBackForwardListItem : public Dali::WebEngineBackForwardListItem
{
public:
{
public:
MockWebEngineBackForwardList()
- : mockItem(),
- pMockItem( &mockItem )
{
}
- Dali::WebEngineBackForwardListItem& GetCurrentItem() const override
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> GetCurrentItem() const override
{
- return *pMockItem;
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> ret(new MockWebEngineBackForwardListItem());
+ return ret;
}
- Dali::WebEngineBackForwardListItem& GetItemAtIndex( uint32_t index ) const override
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> GetPreviousItem() const override
{
- return *pMockItem;
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> ret(new MockWebEngineBackForwardListItem());
+ return ret;
+ }
+
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> GetNextItem() const override
+ {
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> ret(new MockWebEngineBackForwardListItem());
+ return ret;
+ }
+
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> GetItemAtIndex( uint32_t index ) const override
+ {
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> ret(new MockWebEngineBackForwardListItem());
+ return ret;
}
uint32_t GetItemCount() const override
return 1;
}
-private:
- MockWebEngineBackForwardListItem mockItem;
- WebEngineBackForwardListItem* pMockItem;
+ std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> GetBackwardItems(int limit) override
+ {
+ std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> ret;
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> item(new MockWebEngineBackForwardListItem());
+ ret.push_back(std::move(item));
+ return ret;
+ }
+
+ std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> GetForwardItems(int limit) override
+ {
+ std::vector<std::unique_ptr<Dali::WebEngineBackForwardListItem>> ret;
+ std::unique_ptr<Dali::WebEngineBackForwardListItem> item(new MockWebEngineBackForwardListItem());
+ ret.push_back(std::move(item));
+ return ret;
+ }
+};
+
+class MockWebEngineCertificate : public Dali::WebEngineCertificate
+{
+public:
+ MockWebEngineCertificate()
+ {
+ }
+
+ void Allow(bool allowed) override
+ {
+ }
+
+ bool IsFromMainFrame() const override
+ {
+ return true;
+ }
+
+ std::string GetPem() const override
+ {
+ return "abc";
+ }
+
+ bool IsContextSecure() const override
+ {
+ return true;
+ }
+};
+
+class MockWebEngineHttpAuthHandler : public Dali::WebEngineHttpAuthHandler
+{
+public:
+ MockWebEngineHttpAuthHandler()
+ {
+ }
+
+ std::string GetRealm() const override
+ {
+ return "test";
+ }
+
+ void Suspend() override
+ {
+ }
+
+ void UseCredential(const std::string& user, const std::string& password) override
+ {
+ }
+
+ void CancelCredential() override
+ {
+ }
};
class MockWebEngineFormRepostDecision : public WebEngineFormRepostDecision
void Reply(bool allowed) override {}
};
-class MockWebEngineRequestInterceptor : public WebEngineRequestInterceptor
+class MockWebEngineFrame : public Dali::WebEngineFrame
{
public:
- MockWebEngineRequestInterceptor()
+ MockWebEngineFrame()
+ {
+ }
+
+ bool IsMainFrame() const override
+ {
+ return true;
+ }
+};
+
+class MockWebEnginePolicyDecision : public Dali::WebEnginePolicyDecision
+{
+public:
+ MockWebEnginePolicyDecision()
{
}
return "http://test.html";
}
- bool Ignore() override
+ std::string GetCookie() const override
+ {
+ return "test:abc";
+ }
+
+ Dali::WebEnginePolicyDecision::DecisionType GetDecisionType() const
+ {
+ return Dali::WebEnginePolicyDecision::DecisionType::USE;
+ }
+
+ std::string GetResponseMime() const
+ {
+ return "txt/xml";
+ }
+
+ int32_t GetResponseStatusCode() const
+ {
+ return 500;
+ }
+
+ Dali::WebEnginePolicyDecision::NavigationType GetNavigationType() const
+ {
+ return Dali::WebEnginePolicyDecision::NavigationType::LINK_CLICKED;
+ }
+
+ Dali::WebEngineFrame& GetFrame() const
+ {
+ return *(Dali::WebEngineFrame*)(&mockWebFrame);
+ }
+
+ std::string GetScheme() const
+ {
+ return "test";
+ }
+
+ bool Use()
+ {
+ return true;
+ }
+
+ bool Ignore()
+ {
+ return true;
+ }
+
+ bool Suspend()
+ {
+ return true;
+ }
+
+private:
+ MockWebEngineFrame mockWebFrame;
+};
+
+class MockWebEngineConsoleMessage : public Dali::WebEngineConsoleMessage
+{
+public:
+ MockWebEngineConsoleMessage()
+ {
+ }
+
+ std::string GetSource() const override
+ {
+ return "source";
+ }
+
+ uint32_t GetLine() const override
+ {
+ return 10;
+ }
+
+ SeverityLevel GetSeverityLevel() const override
+ {
+ return SeverityLevel::EMPTY;
+ }
+
+ std::string GetText() const override
+ {
+ return "This is a text.";
+ }
+};
+
+class MockWebEngineLoadError : public Dali::WebEngineLoadError
+{
+public:
+ MockWebEngineLoadError(const std::string& url)
+ : mockUrl(url)
+ {
+ }
+
+ std::string GetUrl() const override
+ {
+ return mockUrl;
+ }
+
+ ErrorCode GetCode() const override
+ {
+ return ErrorCode::UNKNOWN;
+ }
+
+ std::string GetDescription() const override
+ {
+ return "This is an error.";
+ }
+
+ ErrorType GetType() const override
+ {
+ return ErrorType::NONE;
+ }
+
+private:
+ std::string mockUrl;
+};
+
+class MockWebEngineContextMenuItem : public Dali::WebEngineContextMenuItem
+{
+public:
+ MockWebEngineContextMenuItem()
+ {
+ }
+
+ ItemTag GetTag() const override
+ {
+ return ItemTag::NO_ACTION;
+ }
+
+ ItemType GetType() const override
+ {
+ return ItemType::ACTION;
+ }
+
+ bool IsEnabled() const override
{
return true;
}
- bool SetResponseStatus(int statusCode, const std::string &customedStatusText) override
+ std::string GetLinkUrl() const override
+ {
+ return "http://test.html";
+ }
+
+ std::string GetImageUrl() const override
+ {
+ return "http://test.jpg";
+ }
+
+ std::string GetTitle() const override
+ {
+ return "title";
+ }
+
+ std::unique_ptr<Dali::WebEngineContextMenu> GetParentMenu() const override
+ {
+ std::unique_ptr<Dali::WebEngineContextMenu> result;
+ return result;
+ }
+};
+
+class MockWebEngineContextMenu : public Dali::WebEngineContextMenu
+{
+public:
+ MockWebEngineContextMenu()
+ {
+ }
+
+ uint32_t GetItemCount() const override
+ {
+ return 1;
+ }
+
+ std::unique_ptr<Dali::WebEngineContextMenuItem> GetItemAt(uint32_t index) const override
+ {
+ std::unique_ptr<Dali::WebEngineContextMenuItem> webitem(new MockWebEngineContextMenuItem());
+ return webitem;
+ }
+
+ std::vector<std::unique_ptr<WebEngineContextMenuItem>> GetItemList() const override
+ {
+ std::vector<std::unique_ptr<WebEngineContextMenuItem>> result;
+ std::unique_ptr<Dali::WebEngineContextMenuItem> webitem(new MockWebEngineContextMenuItem());
+ result.push_back(std::move(webitem));
+ return result;
+ }
+
+ bool RemoveItem(WebEngineContextMenuItem& item) override
+ {
+ return true;
+ }
+
+ bool AppendItemAsAction(WebEngineContextMenuItem::ItemTag tag, const std::string& title, bool enabled) override
{
return true;
}
- bool AddResponseHeader(const std::string &fieldName, const std::string &fieldValue) override
+ bool AppendItem(WebEngineContextMenuItem::ItemTag tag, const std::string& title, const std::string& iconFile, bool enabled) override
{
return true;
}
- bool AddResponseBody(const std::string &body, uint32_t length) override
+ bool SelectItem(WebEngineContextMenuItem& item) override
+ {
+ return true;
+ }
+
+ bool Hide() override
{
return true;
}
};
+class MockWebEngineHitTest : public Dali::WebEngineHitTest
+{
+public:
+ MockWebEngineHitTest()
+ {
+ }
+
+ ResultContext GetResultContext() const override
+ {
+ return ResultContext::DOCUMENT;
+ }
+
+ std::string GetLinkUri() const override
+ {
+ return "http://test.html";
+ }
+
+ std::string GetLinkTitle() const override
+ {
+ return "test";
+ }
+
+ std::string GetLinkLabel() const override
+ {
+ return "label";
+ }
+
+ std::string GetImageUri() const override
+ {
+ return "http://test.jpg";
+ }
+
+ std::string GetMediaUri() const override
+ {
+ return "http://test.mp4";
+ }
+
+ std::string GetTagName() const override
+ {
+ return "img";
+ }
+
+ std::string GetNodeValue() const override
+ {
+ return "test";
+ }
+
+ Dali::Property::Map GetAttributes() const override
+ {
+ return mockAttributesMap;
+ }
+
+ std::string GetImageFileNameExtension() const override
+ {
+ return "jpg";
+ }
+
+ Dali::PixelData GetImageBuffer() override
+ {
+ uint8_t* imageData = new uint8_t[16];
+ memset(imageData, 0xff, 16);
+ return Dali::PixelData::New(imageData, 16, 2, 2,
+ Dali::Pixel::Format::RGBA8888,
+ Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
+ }
+
+private:
+ mutable Dali::Property::Map mockAttributesMap;
+};
+
+class MockWebEngineSecurityOrigin : public Dali::WebEngineSecurityOrigin
+{
+public:
+ MockWebEngineSecurityOrigin()
+ : mockUrl("https://test.html")
+ , mockPotocol("https")
+ {
+ }
+
+ std::string GetHost() const
+ {
+ return mockUrl;
+ }
+
+ std::string GetProtocol() const
+ {
+ return mockPotocol;
+ }
+
+private:
+ std::string mockUrl;
+ std::string mockPotocol;
+};
+
class MockWebEngineSettings : public WebEngineSettings
{
public:
mockClipboardEnabled = enabled;
}
- bool IsImePanelEnabled() const override
- {
- return mockImePanelEnabled;
- }
+ bool IsImePanelEnabled() const override
+ {
+ return mockImePanelEnabled;
+ }
+
+ void EnableImePanel( bool enabled ) override
+ {
+ mockImePanelEnabled = enabled;
+ }
+
+ bool AreImagesLoadedAutomatically() const override
+ {
+ return mockImageLoadedAutomatically;
+ }
+
+ void AllowImagesLoadAutomatically( bool automatic ) override
+ {
+ mockImageLoadedAutomatically = automatic;
+ }
+
+ std::string GetDefaultTextEncodingName() const override
+ {
+ return mockDefaultTextEncodingName;
+ }
+
+ void SetDefaultTextEncodingName( const std::string& defaultTextEncodingName ) override
+ {
+ mockDefaultTextEncodingName = defaultTextEncodingName;
+ }
+
+ void AllowMixedContents( bool allowed ) override
+ {
+ }
+
+ void EnableSpatialNavigation( bool enabled ) override
+ {
+ }
+
+ void EnableWebSecurity( bool enabled ) override
+ {
+ }
+
+ void EnableCacheBuilder( bool enabled ) override
+ {
+ }
+
+ void UseScrollbarThumbFocusNotifications( bool used ) override
+ {
+ }
+
+ void EnableDoNotTrack( bool enabled ) override
+ {
+ }
+
+ void AllowFileAccessFromExternalUrl( bool allowed ) override
+ {
+ }
+
+ void AllowScriptsOpenWindows( bool allowed ) override
+ {
+ }
+
+ bool SetViewportMetaTag(bool enable) override
+ {
+ return true;
+ }
+
+ bool SetForceZoom(bool enable) override
+ {
+ return true;
+ }
+
+ bool IsZoomForced() const override
+ {
+ return true;
+ }
+
+ bool SetTextZoomEnabled(bool enable) override
+ {
+ return true;
+ }
+
+ bool IsTextZoomEnabled() const override
+ {
+ return true;
+ }
+
+ void SetExtraFeature(const std::string& feature, bool enable) override
+ {
+ }
+
+ bool IsExtraFeatureEnabled(const std::string& feature) const override
+ {
+ return true;
+ }
+
+private:
+ int mockDefaultFontSize;
+ bool mockJavaScriptEnabled;
+ bool mockAutoFittingEnabled;
+ bool mockPluginsEnabled;
+ bool mockPrivateBrowsingEnabled;
+ bool mockLinkMagnifierEnabled;
+ bool mockKeypadWithoutUserActionUsed;
+ bool mockAutofillPasswordFormEnabled;
+ bool mockFormCandidateDataEnabled;
+ bool mockTextSelectionEnabled;
+ bool mockTextAutosizingEnable;
+ bool mockArrowScrollEnable;
+ bool mockClipboardEnabled;
+ bool mockImePanelEnabled;
+ bool mockImageLoadedAutomatically;
+ std::string mockDefaultTextEncodingName;
+};
+
+class MockWebEnginePlugin : public Dali::WebEnginePlugin
+{
+public:
+ MockWebEnginePlugin(){}
+ void Create(uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneId) override {}
+ void Create(uint32_t width, uint32_t height, uint32_t argc, char** argv) override {}
+ void Destroy() override {}
+ WebEngineSettings& GetSettings() const override { return *((WebEngineSettings*)&settings); }
+ WebEngineBackForwardList& GetBackForwardList() const override { return *((WebEngineBackForwardList*)&backForwardList); }
+ void LoadUrl(const std::string& url) override {}
+ std::string GetTitle() const override { return std::string(); }
+ Dali::PixelData GetFavicon() const override { return Dali::PixelData(); }
+ NativeImageSourcePtr GetNativeImageSource() override { return nullptr; }
+ std::string GetUrl() const override { return std::string(); }
+ void LoadHtmlString(const std::string& htmlString) override {}
+ bool LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl) override { return false; }
+ bool LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri) override { return false; }
+ void Reload() override {}
+ bool ReloadWithoutCache() override { return false; }
+ void StopLoading() override {}
+ void Suspend() override {}
+ void Resume() override {}
+ void SuspendNetworkLoading() override {}
+ void ResumeNetworkLoading() override {}
+ bool AddCustomHeader(const std::string& name, const std::string& value) override { return false; }
+ bool RemoveCustomHeader(const std::string& name) override { return false; }
+ uint32_t StartInspectorServer(uint32_t port) override { return 0; }
+ bool StopInspectorServer() override { return false; }
+ void ScrollBy(int32_t deltaX, int32_t deltaY) override {}
+ bool ScrollEdgeBy(int32_t deltaX, int32_t deltaY) override { return false; }
+ void SetScrollPosition(int32_t x, int32_t y) override {}
+ Dali::Vector2 GetScrollPosition() const override { return Dali::Vector2(); }
+ Dali::Vector2 GetScrollSize() const override { return Dali::Vector2(); }
+ Dali::Vector2 GetContentSize() const override { return Dali::Vector2(); }
+ bool CanGoForward() override { return false; }
+ void GoForward() override {}
+ bool CanGoBack() override { return false; }
+ void GoBack() override {}
+ void EvaluateJavaScript(const std::string& script, JavaScriptMessageHandlerCallback resultHandler) override {}
+ void AddJavaScriptMessageHandler(const std::string& exposedObjectName, JavaScriptMessageHandlerCallback handler) override {}
+ void RegisterJavaScriptAlertCallback(JavaScriptAlertCallback callback) override {}
+ void JavaScriptAlertReply() override {}
+ void RegisterJavaScriptConfirmCallback(JavaScriptConfirmCallback callback) override {}
+ void JavaScriptConfirmReply(bool confirmed) override {}
+ void RegisterJavaScriptPromptCallback(JavaScriptPromptCallback callback) override {}
+ void JavaScriptPromptReply(const std::string& result) override {}
+ std::unique_ptr<Dali::WebEngineHitTest> CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode) override { return nullptr; }
+ bool CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, WebEngineHitTestCreatedCallback callback) override { return false; }
+ void ClearHistory() override {}
+ void ClearAllTilesResources() override {}
+ std::string GetUserAgent() const override { return std::string(); }
+ void SetUserAgent(const std::string& userAgent) override {}
+ void SetSize(uint32_t width, uint32_t height) override {}
+ void SetDocumentBackgroundColor(Dali::Vector4 color) override {}
+ void ClearTilesWhenHidden(bool cleared) override {}
+ void SetTileCoverAreaMultiplier(float multiplier) override {}
+ void EnableCursorByClient(bool enabled) override {}
+ std::string GetSelectedText() const override { return std::string(); }
+ bool SendTouchEvent(const TouchEvent& touch) override { return false; }
+ bool SendKeyEvent(const KeyEvent& event) override { return false; }
+ void EnableMouseEvents(bool enabled) override {}
+ void EnableKeyEvents(bool enabled) override {}
+ void SetFocus(bool focused) override {}
+ void SetPageZoomFactor(float zoomFactor) override {}
+ float GetPageZoomFactor() const override { return 0.0f; }
+ void SetTextZoomFactor(float zoomFactor) override {}
+ float GetTextZoomFactor() const override { return 0.0f; }
+ float GetLoadProgressPercentage() const override { return 0.0f; }
+ void SetScaleFactor(float scaleFactor, Dali::Vector2 point) override {}
+ float GetScaleFactor() const override { return 0.0f; }
+ void ActivateAccessibility(bool activated) override {}
+ Accessibility::Address GetAccessibilityAddress() override { return Accessibility::Address(); }
+ bool SetVisibility(bool visible) override { return false; }
+ bool HighlightText(const std::string& text, FindOption options, uint32_t maxMatchCount) override { return false; }
+ void AddDynamicCertificatePath(const std::string& host, const std::string& certPath) override {}
+ Dali::PixelData GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor) override { return Dali::PixelData(); }
+ bool GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, ScreenshotCapturedCallback callback) override { return false; }
+ bool CheckVideoPlayingAsynchronously(VideoPlayingCallback callback) override { return false; }
+ void RegisterGeolocationPermissionCallback(GeolocationPermissionCallback callback) override {}
+ void UpdateDisplayArea(Dali::Rect<int32_t> displayArea) override {}
+ void EnableVideoHole(bool enabled) override {}
+ bool SendHoverEvent(const HoverEvent& event) override { return false; }
+ bool SendWheelEvent(const WheelEvent& event) override { return false; }
+ WebEngineFrameRenderedSignalType& FrameRenderedSignal() override { return frameRenderedSignal; }
+ void RegisterPageLoadStartedCallback(WebEnginePageLoadCallback callback) override {}
+ void RegisterPageLoadInProgressCallback(WebEnginePageLoadCallback callback) override {}
+ void RegisterPageLoadFinishedCallback(WebEnginePageLoadCallback callback) override {}
+ void RegisterPageLoadErrorCallback(WebEnginePageLoadErrorCallback callback) override {}
+ void RegisterScrollEdgeReachedCallback(WebEngineScrollEdgeReachedCallback callback) override {}
+ void RegisterUrlChangedCallback(WebEngineUrlChangedCallback callback) override {}
+ void RegisterFormRepostDecidedCallback(WebEngineFormRepostDecidedCallback callback) override {}
+ void RegisterConsoleMessageReceivedCallback(WebEngineConsoleMessageReceivedCallback callback) override {}
+ void RegisterResponsePolicyDecidedCallback(WebEngineResponsePolicyDecidedCallback callback) override {}
+ void RegisterNavigationPolicyDecidedCallback(WebEngineNavigationPolicyDecidedCallback callback) override {}
+ void RegisterCertificateConfirmedCallback(WebEngineCertificateCallback callback) override {}
+ void RegisterSslCertificateChangedCallback(WebEngineCertificateCallback callback) override {}
+ void RegisterHttpAuthHandlerCallback(WebEngineHttpAuthHandlerCallback callback) override {}
+ void RegisterContextMenuShownCallback(WebEngineContextMenuShownCallback callback) override {}
+ void RegisterContextMenuHiddenCallback(WebEngineContextMenuHiddenCallback callback) override {}
+ void GetPlainTextAsynchronously(PlainTextReceivedCallback callback) override {}
+private:
+ MockWebEngineSettings settings;
+ MockWebEngineBackForwardList backForwardList;
+ WebEngineFrameRenderedSignalType frameRenderedSignal;
+};
- void EnableImePanel( bool enabled ) override
- {
- mockImePanelEnabled = enabled;
- }
+Dali::WebEnginePlugin* GetWebEnginePlugin()
+{
+ static MockWebEnginePlugin plugin;
+ return &plugin;
+}
- bool AreImagesLoadedAutomatically() const override
+class MockWebEngineRequestInterceptor : public WebEngineRequestInterceptor
+{
+public:
+ MockWebEngineRequestInterceptor()
{
- return mockImageLoadedAutomatically;
}
- void AllowImagesLoadAutomatically( bool automatic ) override
+ Dali::WebEnginePlugin* GetWebEngine() const
{
- mockImageLoadedAutomatically = automatic;
+ return GetWebEnginePlugin();
}
- std::string GetDefaultTextEncodingName() const override
+ std::string GetUrl() const override
{
- return mockDefaultTextEncodingName;
+ return "http://test.html";
}
- void SetDefaultTextEncodingName( const std::string& defaultTextEncodingName ) override
+ Dali::Property::Map GetHeaders() const override
{
- mockDefaultTextEncodingName = defaultTextEncodingName;
+ return mockHeadersMap;
}
- void AllowMixedContents( bool allowed ) override
+ std::string GetMethod() const override
{
+ return "GET";
}
- void EnableSpatialNavigation( bool enabled ) override
+ bool Ignore() override
{
+ return true;
}
- void EnableWebSecurity( bool enabled ) override
+ bool SetResponseStatus(int statusCode, const std::string& customedStatusText) override
{
+ return true;
}
- void EnableCacheBuilder( bool enabled ) override
+ bool AddResponseHeader(const std::string& fieldName, const std::string& fieldValue) override
{
+ mockHeadersMap.Add(fieldName, fieldValue);
+ return true;
}
- void UseScrollbarThumbFocusNotifications( bool used ) override
+ bool AddResponseHeaders(const Dali::Property::Map& headers) override
{
+ mockHeadersMap.Merge(headers);
+ return true;
}
- void EnableDoNotTrack( bool enabled ) override
+ bool AddResponseBody(const int8_t* body, uint32_t length) override
{
+ return true;
}
- void AllowFileAccessFromExternalUrl( bool allowed ) override
+ bool AddResponse(const std::string& headers, const int8_t* body, uint32_t length) override
{
+ return true;
}
- void AllowScriptsOpenWindows( bool allowed ) override
+ bool WriteResponseChunk(const int8_t* chunk, uint32_t length) override
{
+ return true;
}
private:
- int mockDefaultFontSize;
- bool mockJavaScriptEnabled;
- bool mockAutoFittingEnabled;
- bool mockPluginsEnabled;
- bool mockPrivateBrowsingEnabled;
- bool mockLinkMagnifierEnabled;
- bool mockKeypadWithoutUserActionUsed;
- bool mockAutofillPasswordFormEnabled;
- bool mockFormCandidateDataEnabled;
- bool mockTextSelectionEnabled;
- bool mockTextAutosizingEnable;
- bool mockArrowScrollEnable;
- bool mockClipboardEnabled;
- bool mockImePanelEnabled;
- bool mockImageLoadedAutomatically;
- std::string mockDefaultTextEncodingName;
+ Dali::Property::Map mockHeadersMap;
};
class WebEngine: public Dali::BaseObject
{
public:
- using JavaScriptEvaluatedResultCallback = std::function<void(const std::string&)>;
-
WebEngine()
: mUrl()
, mCurrentPlusOnePos( 0 )
}
mockWebEngineSettings = new MockWebEngineSettings();
- mockWebEngineContext = new MockWebEngineContext();
- mockWebEngineCookieManager = new MockWebEngineCookieManager();
mockWebEngineBackForwardList = new MockWebEngineBackForwardList();
}
gInstanceCount--;
if( !gInstanceCount )
{
- gInstance = 0;
+ gInstance = nullptr;
}
delete mockWebEngineSettings;
- delete mockWebEngineContext;
- delete mockWebEngineCookieManager;
delete mockWebEngineBackForwardList;
}
return *mockWebEngineSettings;
}
- Dali::WebEngineContext& GetContext() const
- {
- return *mockWebEngineContext;
- }
-
- Dali::WebEngineCookieManager& GetCookieManager() const
- {
- return *mockWebEngineCookieManager;
- }
-
Dali::WebEngineBackForwardList& GetBackForwardList() const
{
return *mockWebEngineBackForwardList;
ConnectToGlobalSignal( &OnLoadUrl );
}
- const std::string& GetUrl() const
+ std::string GetUrl() const
{
return mUrl;
}
Dali::PixelData GetFavicon() const
{
- uint8_t* faviconData = new uint8_t[ 16 ];
-
- faviconData[ 0 ] = 0xff;
- faviconData[ 1 ] = 0x00;
- faviconData[ 2 ] = 0x00;
- faviconData[ 3 ] = 0xff;
- faviconData[ 4 ] = 0xff;
- faviconData[ 5 ] = 0x00;
- faviconData[ 6 ] = 0x00;
- faviconData[ 7 ] = 0xff;
- faviconData[ 8 ] = 0xff;
- faviconData[ 9 ] = 0x00;
- faviconData[ 10 ] = 0x00;
- faviconData[ 11 ] = 0xff;
- faviconData[ 12 ] = 0xff;
- faviconData[ 13 ] = 0x00;
- faviconData[ 14 ] = 0x00;
- faviconData[ 15 ] = 0xff;
-
- return Dali::PixelData::New( faviconData, 16, 2, 2,
- Dali::Pixel::Format::RGBA8888,
- Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
+ static int testGetFaviconCount = 0;
+ if (testGetFaviconCount == 0)
+ {
+ testGetFaviconCount++;
+ uint8_t* faviconData = new uint8_t[16];
+ memset(faviconData, 0xff, 16);
+ return Dali::PixelData::New(faviconData, 16, 2, 2,
+ Dali::Pixel::Format::RGBA8888,
+ Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
+ }
+ else
+ {
+ return Dali::PixelData();
+ }
}
bool CanGoForward() const
}
}
+ std::unique_ptr<Dali::WebEngineHitTest> CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
+ {
+ std::unique_ptr<Dali::WebEngineHitTest> hitTest(new MockWebEngineHitTest());
+ return hitTest;
+ }
+
+ bool CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
+ {
+ if (callback)
+ {
+ ConnectToGlobalSignal( &OnHitTestCreated );
+ mHitTestCreatedCallback = callback;
+ }
+ return true;
+ }
+
void ClearHistory()
{
ConnectToGlobalSignal( &OnClearHistory );
}
- const std::string& GetUserAgent() const
+ std::string GetUserAgent() const
{
return mUserAgent;
}
mUserAgent = userAgent;
}
- void ScrollBy( int dx, int dy )
+ void ScrollBy( int32_t dx, int32_t dy )
{
mScrollPosition += Dali::Vector2( dx, dy );
if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
}
}
- bool ScrollEdgeBy( int dx, int dy )
+ bool ScrollEdgeBy( int32_t dx, int32_t dy )
{
mScrollPosition += Dali::Vector2( dx, dy );
if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
return true;
}
- void SetScrollPosition( int x, int y )
+ void SetScrollPosition( int32_t x, int32_t y )
{
mScrollPosition.x = x;
mScrollPosition.y = y;
return mScaleFactor;
}
- Dali::PixelData GetScreenshot(Dali::Rect<int> viewArea, float scaleFactor)
+ Dali::Accessibility::Address GetAccessibilityAddress()
+ {
+ return {":9.99", "root"};
+ }
+
+ Dali::PixelData GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
{
uint32_t bufferSize = viewArea.width * viewArea.height * 4 ;
uint8_t* pixel = new uint8_t[ bufferSize ];
Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
}
- bool GetScreenshotAsynchronously(Dali::Rect<int> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
+ bool GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
{
if ( callback )
{
}
}
- Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadStartedSignal()
+ Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& FrameRenderedSignal()
+ {
+ return mFrameRenderedSignal;
+ }
+
+ void RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
{
- return mPageLoadStartedSignal;
+ mPageLoadStartedCallback = callback;
}
- Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadInProgressSignal()
+ void RegisterPageLoadInProgressCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
{
- return mPageLoadInProgressSignal;
+ mPageLoadInProgressCallback = callback;
}
- Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadFinishedSignal()
+ void RegisterPageLoadFinishedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
{
- return mPageLoadFinishedSignal;
+ mPageLoadFinishedCallback = callback;
}
- Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& PageLoadErrorSignal()
+ void RegisterPageLoadErrorCallback(Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback callback)
{
- return mPageLoadErrorSignal;
+ mPageLoadErrorCallback = callback;
}
- Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType& ScrollEdgeReachedSignal()
+ void RegisterScrollEdgeReachedCallback(Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback callback)
{
- return mScrollEdgeReachedSignal;
+ mScrollEdgeReachedCallback = callback;
}
- Dali::WebEnginePlugin::WebEngineUrlChangedSignalType& UrlChangedSignal()
+ void RegisterUrlChangedCallback(Dali::WebEnginePlugin::WebEngineUrlChangedCallback callback)
{
- return mUrlChangedSignal;
+ mUrlChangedCallback = callback;
}
- Dali::WebEnginePlugin::WebEngineFormRepostDecisionSignalType& FormRepostDecisionSignal()
+ void RegisterFormRepostDecidedCallback(Dali::WebEnginePlugin::WebEngineFormRepostDecidedCallback callback)
{
- return mFormRepostDecisionSignal;
+ mFormRepostDecidedCallback = callback;
}
- Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& FrameRenderedSignal()
+ void RegisterConsoleMessageReceivedCallback(Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback callback)
{
- return mFrameRenderedSignal;
+ mConsoleMessageCallback = callback;
+ }
+
+ void RegisterResponsePolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback callback)
+ {
+ mResponsePolicyDecisionCallback = callback;
+ }
+
+ void RegisterNavigationPolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback callback)
+ {
+ mNavigationPolicyDecisionCallback = callback;
+ }
+
+ void RegisterCertificateConfirmedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
+ {
+ mCertificateConfirmCallback = callback;
+ }
+
+ void RegisterSslCertificateChangedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
+ {
+ mSslCertificateChangedCallback = callback;
+ }
+
+ void RegisterHttpAuthHandlerCallback(Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback callback)
+ {
+ mHttpAuthHandlerCallback = callback;
+ }
+
+ void RegisterContextMenuShownCallback(Dali::WebEnginePlugin::WebEngineContextMenuShownCallback callback)
+ {
+ mContextMenuShownCallback = callback;
}
- Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType& RequestInterceptorSignal()
+ void RegisterContextMenuHiddenCallback(Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback callback)
{
- return mRequestInterceptorSignal;
+ mContextMenuHiddenCallback = callback;
+ }
+
+ void GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
+ {
+ if (callback)
+ {
+ ConnectToGlobalSignal(&OnPlainTextReceived);
+ mPlainTextReceivedCallback = callback;
+ }
}
std::string mUrl;
size_t mCurrentPlusOnePos;
std::string mUserAgent;
- Dali::WebEnginePlugin::WebEnginePageLoadSignalType mPageLoadStartedSignal;
- Dali::WebEnginePlugin::WebEnginePageLoadSignalType mPageLoadInProgressSignal;
- Dali::WebEnginePlugin::WebEnginePageLoadSignalType mPageLoadFinishedSignal;
- Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType mPageLoadErrorSignal;
- Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType mScrollEdgeReachedSignal;
- Dali::WebEnginePlugin::WebEngineUrlChangedSignalType mUrlChangedSignal;
- Dali::WebEnginePlugin::WebEngineFormRepostDecisionSignalType mFormRepostDecisionSignal;
- Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType mFrameRenderedSignal;
- Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType mRequestInterceptorSignal;
+ Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType mFrameRenderedSignal;
bool mEvaluating;
float mPageZoomFactor;
Dali::Vector2 mScrollSize;
Dali::Vector2 mContentSize;
WebEngineBackForwardList* mockWebEngineBackForwardList;
- WebEngineContext* mockWebEngineContext;
- WebEngineCookieManager* mockWebEngineCookieManager;
WebEngineSettings* mockWebEngineSettings;
- std::vector<JavaScriptEvaluatedResultCallback> mResultCallbacks;
- Dali::WebEnginePlugin::JavaScriptAlertCallback mJavaScriptAlertCallback;
- Dali::WebEnginePlugin::JavaScriptConfirmCallback mJavaScriptConfirmCallback;
- Dali::WebEnginePlugin::JavaScriptPromptCallback mJavaScriptPromptCallback;
- Dali::WebEnginePlugin::ScreenshotCapturedCallback mScreenshotCapturedCallback;
- Dali::WebEnginePlugin::VideoPlayingCallback mVideoPlayingCallback;
- Dali::WebEnginePlugin::GeolocationPermissionCallback mGeolocationPermissionCallback;
+ std::vector<Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback> mResultCallbacks;
+
+ Dali::WebEnginePlugin::WebEnginePageLoadCallback mPageLoadStartedCallback;
+ Dali::WebEnginePlugin::WebEnginePageLoadCallback mPageLoadInProgressCallback;
+ Dali::WebEnginePlugin::WebEnginePageLoadCallback mPageLoadFinishedCallback;
+ Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback mPageLoadErrorCallback;
+ Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback mScrollEdgeReachedCallback;
+ Dali::WebEnginePlugin::WebEngineUrlChangedCallback mUrlChangedCallback;
+ Dali::WebEnginePlugin::WebEngineFormRepostDecidedCallback mFormRepostDecidedCallback;
+ Dali::WebEnginePlugin::WebEngineFrameRenderedCallback mFrameRenderedCallback;
+ Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback mConsoleMessageCallback;
+ Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback mResponsePolicyDecisionCallback;
+ Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback mNavigationPolicyDecisionCallback;
+ Dali::WebEnginePlugin::WebEngineCertificateCallback mCertificateConfirmCallback;
+ Dali::WebEnginePlugin::WebEngineCertificateCallback mSslCertificateChangedCallback;
+ Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback mHttpAuthHandlerCallback;
+ Dali::WebEnginePlugin::WebEngineContextMenuShownCallback mContextMenuShownCallback;
+ Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback mContextMenuHiddenCallback;
+ Dali::WebEnginePlugin::JavaScriptAlertCallback mJavaScriptAlertCallback;
+ Dali::WebEnginePlugin::JavaScriptConfirmCallback mJavaScriptConfirmCallback;
+ Dali::WebEnginePlugin::JavaScriptPromptCallback mJavaScriptPromptCallback;
+ Dali::WebEnginePlugin::ScreenshotCapturedCallback mScreenshotCapturedCallback;
+ Dali::WebEnginePlugin::VideoPlayingCallback mVideoPlayingCallback;
+ Dali::WebEnginePlugin::GeolocationPermissionCallback mGeolocationPermissionCallback;
+ Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback mHitTestCreatedCallback;
+ Dali::WebEnginePlugin::PlainTextReceivedCallback mPlainTextReceivedCallback;
};
}
gInstance->mHistory.push_back( gInstance->mUrl );
gInstance->mCurrentPlusOnePos++;
- gInstance->mPageLoadStartedSignal.Emit( gInstance->mUrl );
- gInstance->mPageLoadInProgressSignal.Emit( gInstance->mUrl );
- gInstance->mPageLoadFinishedSignal.Emit( gInstance->mUrl );
- gInstance->mUrlChangedSignal.Emit( "http://new-test" );
-
- std::shared_ptr<Dali::WebEngineFormRepostDecision> decision(new MockWebEngineFormRepostDecision());
- gInstance->mFormRepostDecisionSignal.Emit(std::move(decision));
+ if (gInstance->mPageLoadStartedCallback)
+ {
+ gInstance->mPageLoadStartedCallback( gInstance->mUrl );
+ }
+ if (gInstance->mPageLoadInProgressCallback)
+ {
+ gInstance->mPageLoadInProgressCallback( gInstance->mUrl );
+ }
+ if (gInstance->mPageLoadFinishedCallback)
+ {
+ gInstance->mPageLoadFinishedCallback( gInstance->mUrl );
+ }
+ if (gInstance->mPageLoadErrorCallback)
+ {
+ std::unique_ptr<Dali::WebEngineLoadError> error(new MockWebEngineLoadError(gInstance->mUrl));
+ gInstance->mPageLoadErrorCallback(std::move(error));
+ }
+ if (gInstance->mUrlChangedCallback)
+ {
+ gInstance->mUrlChangedCallback( "http://new-test" );
+ }
+ if (gInstance->mFormRepostDecidedCallback)
+ {
+ std::unique_ptr<Dali::WebEngineFormRepostDecision> repostDecision(new MockWebEngineFormRepostDecision());
+ gInstance->mFormRepostDecidedCallback(std::move(repostDecision));
+ }
gInstance->mFrameRenderedSignal.Emit();
- std::shared_ptr<Dali::WebEngineRequestInterceptor> interceptor(new MockWebEngineRequestInterceptor());
- gInstance->mRequestInterceptorSignal.Emit(std::move(interceptor));
+ if (gInstance->mFrameRenderedCallback)
+ {
+ gInstance->mFrameRenderedCallback();
+ }
+ if (gInstance->mConsoleMessageCallback)
+ {
+ std::unique_ptr<Dali::WebEngineConsoleMessage> message(new MockWebEngineConsoleMessage());
+ gInstance->mConsoleMessageCallback(std::move(message));
+ }
+ if (gInstance->mResponsePolicyDecisionCallback)
+ {
+ std::unique_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
+ gInstance->mResponsePolicyDecisionCallback(std::move(policyDecision));
+ }
+ if (gInstance->mNavigationPolicyDecisionCallback)
+ {
+ std::unique_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
+ gInstance->mNavigationPolicyDecisionCallback(std::move(policyDecision));
+ }
+ if (gInstance->mCertificateConfirmCallback)
+ {
+ std::unique_ptr<Dali::WebEngineCertificate> certificate(new MockWebEngineCertificate());
+ gInstance->mCertificateConfirmCallback(std::move(certificate));
+ }
+ if (gInstance->mSslCertificateChangedCallback)
+ {
+ std::unique_ptr<Dali::WebEngineCertificate> sslCertificate(new MockWebEngineCertificate());
+ gInstance->mSslCertificateChangedCallback(std::move(sslCertificate));
+ }
+ if (gInstance->mHttpAuthHandlerCallback)
+ {
+ std::unique_ptr<Dali::WebEngineHttpAuthHandler> handler(new MockWebEngineHttpAuthHandler());
+ gInstance->mHttpAuthHandlerCallback(std::move(handler));
+ }
+ if (gInstance->mContextMenuShownCallback)
+ {
+ std::unique_ptr<Dali::WebEngineContextMenu> menu(new MockWebEngineContextMenu());
+ gInstance->mContextMenuShownCallback(std::move(menu));
+ }
+ if (gInstance->mContextMenuHiddenCallback)
+ {
+ std::unique_ptr<Dali::WebEngineContextMenu> hiddenMenu(new MockWebEngineContextMenu());
+ gInstance->mContextMenuHiddenCallback(std::move(hiddenMenu));
+ }
}
return false;
}
{
DisconnectFromGlobalSignal( &OnScrollEdge );
- if( gInstance )
+ if( gInstance && gInstance->mScrollEdgeReachedCallback )
{
- gInstance->mScrollEdgeReachedSignal.Emit( Dali::WebEnginePlugin::ScrollEdge::BOTTOM );
+ gInstance->mScrollEdgeReachedCallback( Dali::WebEnginePlugin::ScrollEdge::BOTTOM );
}
return false;
return false;
}
+bool OnHitTestCreated()
+{
+ DisconnectFromGlobalSignal(&OnHitTestCreated);
+ if (gInstance)
+ {
+ std::unique_ptr<Dali::WebEngineHitTest> test(new MockWebEngineHitTest());
+ gInstance->mHitTestCreatedCallback(std::move(test));
+ }
+ return false;
+}
+
bool OnClearHistory()
{
DisconnectFromGlobalSignal( &OnClearHistory );
return false;
}
+bool OnSecurityOriginAcquired()
+{
+ DisconnectFromGlobalSignal(&OnSecurityOriginAcquired);
+ if (gWebEngineContextInstance)
+ {
+ std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>> securityOriginList;
+ std::unique_ptr<Dali::WebEngineSecurityOrigin> origin(new MockWebEngineSecurityOrigin());
+ securityOriginList.push_back(std::move(origin));
+ gWebEngineContextInstance->mSecurityOriginAcquiredCallback(securityOriginList);
+ }
+ return false;
+}
+
+bool OnStorageUsageAcquired()
+{
+ DisconnectFromGlobalSignal(&OnStorageUsageAcquired);
+ if (gWebEngineContextInstance)
+ {
+ gWebEngineContextInstance->mStorageUsageAcquiredCallback(0);
+ }
+ return false;
+}
+
+bool OnFormPasswordAcquired()
+{
+ DisconnectFromGlobalSignal(&OnFormPasswordAcquired);
+ if (gWebEngineContextInstance)
+ {
+ std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>> formPasswordList;
+ std::unique_ptr<Dali::WebEngineContext::PasswordData> data(new Dali::WebEngineContext::PasswordData());
+ data->url = "http://test.html";
+ data->useFingerprint = false;
+ formPasswordList.push_back(std::move(data));
+ gWebEngineContextInstance->mFormPasswordAcquiredCallback(formPasswordList);
+ }
+ return false;
+}
+
+bool OnDownloadStarted()
+{
+ DisconnectFromGlobalSignal(&OnDownloadStarted);
+ if (gWebEngineContextInstance)
+ {
+ gWebEngineContextInstance->mDownloadStartedCallback("http://test.html");
+ }
+ return false;
+}
+
+bool OnMimeOverridden()
+{
+ DisconnectFromGlobalSignal(&OnMimeOverridden);
+ if (gWebEngineContextInstance)
+ {
+ std::string newMime;
+ gWebEngineContextInstance->mMimeOverriddenCallback("http://test.html", "txt/xml", newMime);
+ }
+ return false;
+}
+
+bool OnRequestIntercepted()
+{
+ DisconnectFromGlobalSignal(&OnRequestIntercepted);
+ if (gWebEngineContextInstance)
+ {
+ Dali::WebEngineRequestInterceptorPtr interceptor = new MockWebEngineRequestInterceptor();
+ gWebEngineContextInstance->mRequestInterceptedCallback(interceptor);
+ }
+ return false;
+}
+
+bool OnChangesWatch()
+{
+ DisconnectFromGlobalSignal(&OnChangesWatch);
+ if (gMockWebEngineCookieManager)
+ {
+ gMockWebEngineCookieManager->mChangesWatchCallback();
+ }
+ return false;
+}
+
+bool OnPlainTextReceived()
+{
+ DisconnectFromGlobalSignal(&OnPlainTextReceived);
+ if (gInstance)
+ {
+ std::string dummyResultText;
+ gInstance->mPlainTextReceivedCallback(dummyResultText);
+ }
+ return false;
+}
+
} // namespace
inline WebEngine& GetImplementation( Dali::WebEngine& webEngine )
return WebEngine( baseObject );
}
+Dali::WebEngineContext* WebEngine::GetContext()
+{
+ return Internal::Adaptor::GetContext();
+}
+
+Dali::WebEngineCookieManager* WebEngine::GetCookieManager()
+{
+ return Internal::Adaptor::GetCookieManager();
+}
+
WebEngine::WebEngine( const WebEngine& WebEngine )
: BaseHandle( WebEngine )
{
return WebEngine( dynamic_cast< Internal::Adaptor::WebEngine* >( handle.GetObjectPtr() ) );
}
-void WebEngine::Create( int width, int height, const std::string& locale, const std::string& timezoneId )
+void WebEngine::Create( uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneId )
{
}
-void WebEngine::Create( int width, int height, int argc, char** argv )
+void WebEngine::Create( uint32_t width, uint32_t height, uint32_t argc, char** argv )
{
}
return Internal::Adaptor::GetImplementation( *this ).GetSettings();
}
-WebEngineContext& WebEngine::GetContext() const
-{
- return Internal::Adaptor::GetImplementation( *this ).GetContext();
-}
-
-WebEngineCookieManager& WebEngine::GetCookieManager() const
-{
- return Internal::Adaptor::GetImplementation( *this ).GetCookieManager();
-}
-
WebEngineBackForwardList& WebEngine::GetBackForwardList() const
{
return Internal::Adaptor::GetImplementation( *this ).GetBackForwardList();
return Internal::Adaptor::GetImplementation( *this ).GetFavicon();
}
-const std::string& WebEngine::GetUrl()
+std::string WebEngine::GetUrl() const
{
return Internal::Adaptor::GetImplementation( *this ).GetUrl();
}
-NativeImageInterfacePtr WebEngine::GetNativeImageSource()
+Dali::WebEnginePlugin* WebEngine::GetPlugin() const
+{
+ return Internal::Adaptor::GetWebEnginePlugin();
+}
+
+NativeImageSourcePtr WebEngine::GetNativeImageSource()
{
Any source;
Dali::NativeImageSourcePtr sourcePtr = Dali::NativeImageSource::New( source );
{
}
+std::unique_ptr<Dali::WebEngineHitTest> WebEngine::CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
+{
+ return Internal::Adaptor::GetImplementation(*this).CreateHitTest(x, y, mode);
+}
+
+bool WebEngine::CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
+{
+ return Internal::Adaptor::GetImplementation(*this).CreateHitTestAsynchronously(x, y, mode, callback);
+}
+
void WebEngine::ClearAllTilesResources()
{
}
{
}
+Accessibility::Address WebEngine::GetAccessibilityAddress()
+{
+ return Internal::Adaptor::GetImplementation(*this).GetAccessibilityAddress();
+}
+
bool WebEngine::HighlightText(const std::string& text, Dali::WebEnginePlugin::FindOption options, uint32_t maxMatchCount)
{
return true;
{
}
-Dali::PixelData WebEngine::GetScreenshot(Dali::Rect<int> viewArea, float scaleFactor)
+Dali::PixelData WebEngine::GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
{
return Internal::Adaptor::GetImplementation( *this ).GetScreenshot(viewArea, scaleFactor);
}
-bool WebEngine::GetScreenshotAsynchronously(Dali::Rect<int> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
+bool WebEngine::GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
{
return Internal::Adaptor::GetImplementation( *this ).GetScreenshotAsynchronously(viewArea, scaleFactor, callback);
}
Internal::Adaptor::GetImplementation( *this ).RegisterGeolocationPermissionCallback(callback);
}
-const std::string& WebEngine::GetUserAgent() const
+std::string WebEngine::GetUserAgent() const
{
return Internal::Adaptor::GetImplementation( *this ).GetUserAgent();
}
Internal::Adaptor::GetImplementation( *this ).SetUserAgent( userAgent );
}
-void WebEngine::ScrollBy( int dx, int dy )
+void WebEngine::ScrollBy( int32_t dx, int32_t dy )
{
Internal::Adaptor::GetImplementation( *this ).ScrollBy( dx, dy );
}
-bool WebEngine::ScrollEdgeBy( int dx, int dy )
+bool WebEngine::ScrollEdgeBy( int32_t dx, int32_t dy )
{
return Internal::Adaptor::GetImplementation( *this ).ScrollEdgeBy( dx, dy );
}
-void WebEngine::SetScrollPosition( int x, int y )
+void WebEngine::SetScrollPosition( int32_t x, int32_t y )
{
Internal::Adaptor::GetImplementation( *this ).SetScrollPosition( x, y );
}
return Internal::Adaptor::GetImplementation( *this ).GetContentSize();
}
-void WebEngine::SetSize( int width, int height )
+void WebEngine::SetSize( uint32_t width, uint32_t height )
{
}
return Internal::Adaptor::GetImplementation( *this ).GetLoadProgressPercentage();
}
-void WebEngine::UpdateDisplayArea( Dali::Rect< int > displayArea )
+void WebEngine::UpdateDisplayArea( Dali::Rect< int32_t > displayArea )
{
}
{
}
-Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadStartedSignal()
+Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& WebEngine::FrameRenderedSignal()
{
- return Internal::Adaptor::GetImplementation( *this ).PageLoadStartedSignal();
+ return Internal::Adaptor::GetImplementation(*this).FrameRenderedSignal();
}
-Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadInProgressSignal()
+void WebEngine::RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
{
- return Internal::Adaptor::GetImplementation( *this ).PageLoadInProgressSignal();
+ Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadStartedCallback(callback);
}
-Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadFinishedSignal()
+void WebEngine::RegisterPageLoadInProgressCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
{
- return Internal::Adaptor::GetImplementation( *this ).PageLoadFinishedSignal();
+ Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadInProgressCallback(callback);
}
-Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& WebEngine::PageLoadErrorSignal()
+void WebEngine::RegisterPageLoadFinishedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
{
- return Internal::Adaptor::GetImplementation( *this ).PageLoadErrorSignal();
+ Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadFinishedCallback(callback);
}
-Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType& WebEngine::ScrollEdgeReachedSignal()
+void WebEngine::RegisterPageLoadErrorCallback(Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback callback)
{
- return Internal::Adaptor::GetImplementation( *this ).ScrollEdgeReachedSignal();
+ Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadErrorCallback(callback);
}
-Dali::WebEnginePlugin::WebEngineUrlChangedSignalType& WebEngine::UrlChangedSignal()
+void WebEngine::RegisterScrollEdgeReachedCallback(Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback callback)
{
- return Internal::Adaptor::GetImplementation( *this ).UrlChangedSignal();
+ Internal::Adaptor::GetImplementation( *this ).RegisterScrollEdgeReachedCallback(callback);
}
-Dali::WebEnginePlugin::WebEngineFormRepostDecisionSignalType& WebEngine::FormRepostDecisionSignal()
+void WebEngine::RegisterUrlChangedCallback(Dali::WebEnginePlugin::WebEngineUrlChangedCallback callback)
{
- return Internal::Adaptor::GetImplementation( *this ).FormRepostDecisionSignal();
+ Internal::Adaptor::GetImplementation( *this ).RegisterUrlChangedCallback(callback);
}
-Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& WebEngine::FrameRenderedSignal()
+void WebEngine::RegisterFormRepostDecidedCallback(Dali::WebEnginePlugin::WebEngineFormRepostDecidedCallback callback)
{
- return Internal::Adaptor::GetImplementation(*this).FrameRenderedSignal();
+ Internal::Adaptor::GetImplementation( *this ).RegisterFormRepostDecidedCallback(callback);
}
-Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType& WebEngine::RequestInterceptorSignal()
+void WebEngine::RegisterConsoleMessageReceivedCallback(Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback callback)
{
- return Internal::Adaptor::GetImplementation(*this).RequestInterceptorSignal();
+ Internal::Adaptor::GetImplementation( *this ).RegisterConsoleMessageReceivedCallback(callback);
}
-} // namespace Dali;
+void WebEngine::RegisterResponsePolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback callback)
+{
+ Internal::Adaptor::GetImplementation( *this ).RegisterResponsePolicyDecidedCallback(callback);
+}
+
+void WebEngine::RegisterNavigationPolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback callback)
+{
+ Internal::Adaptor::GetImplementation(*this).RegisterNavigationPolicyDecidedCallback(callback);
+}
+
+void WebEngine::RegisterCertificateConfirmedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
+{
+ Internal::Adaptor::GetImplementation( *this ).RegisterCertificateConfirmedCallback(callback);
+}
+void WebEngine::RegisterSslCertificateChangedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
+{
+ Internal::Adaptor::GetImplementation( *this ).RegisterSslCertificateChangedCallback(callback);
+}
+
+void WebEngine::RegisterHttpAuthHandlerCallback(Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback callback)
+{
+ Internal::Adaptor::GetImplementation( *this ).RegisterHttpAuthHandlerCallback(callback);
+}
+
+void WebEngine::RegisterContextMenuShownCallback(Dali::WebEnginePlugin::WebEngineContextMenuShownCallback callback)
+{
+ Internal::Adaptor::GetImplementation( *this ).RegisterContextMenuShownCallback(callback);
+}
+
+void WebEngine::RegisterContextMenuHiddenCallback(Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback callback)
+{
+ Internal::Adaptor::GetImplementation( *this ).RegisterContextMenuHiddenCallback(callback);
+}
+
+void WebEngine::GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
+{
+ Internal::Adaptor::GetImplementation(*this).GetPlainTextAsynchronously(callback);
+}
+
+} // namespace Dali;
projects / platform / core / uifw / dali-toolkit.git / blobdiff