X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali-toolkit%2Fdali-toolkit-test-utils%2Ftoolkit-web-engine.cpp;h=e6f47a81f66d79f6aaf0f798b961a5350fa9c3fa;hb=787268448801d95e2bccb7488059371b65912d8d;hp=f400f7530587e5b22bf019b8227595b62b2d525d;hpb=979b10d9898707860fc2ee542dc0bb9946097eb9;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git

diff --git a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-web-engine.cpp b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-web-engine.cpp
index f400f75..e6f47a8 100755
--- a/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-web-engine.cpp
+++ b/automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-web-engine.cpp
@@ -20,17 +20,26 @@
 #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-certificate.h>
 #include <dali/devel-api/adaptor-framework/web-engine-console-message.h>
 #include <dali/devel-api/adaptor-framework/web-engine-context.h>
+#include <dali/devel-api/adaptor-framework/web-engine-context-menu.h>
+#include <dali/devel-api/adaptor-framework/web-engine-context-menu-item.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-frame.h>
+#include <dali/devel-api/adaptor-framework/web-engine-hit-test.h>
+#include <dali/devel-api/adaptor-framework/web-engine-http-auth-handler.h>
 #include <dali/devel-api/adaptor-framework/web-engine-load-error.h>
+#include <dali/devel-api/adaptor-framework/web-engine-policy-decision.h>
+#include <dali/devel-api/adaptor-framework/web-engine-request-interceptor.h>
+#include <dali/devel-api/adaptor-framework/web-engine-security-origin.h>
 #include <dali/devel-api/adaptor-framework/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>
@@ -45,14 +54,16 @@ namespace Adaptor
 {
 
 class WebEngine;
+class MockWebEngineContext;
 
 namespace
 {
 
 // Generally only one WebEngine instance exists.
 // If > 1, a new web engine has been created by CreateWindowSignal.
-static WebEngine* gInstance = 0;
+static WebEngine* gInstance = nullptr;
 static int gInstanceCount = 0;
+static MockWebEngineContext* gWebEngineContextInstance = nullptr;
 
 bool OnGoBack();
 bool OnGoForward();
@@ -61,11 +72,18 @@ bool OnEvaluteJavaScript();
 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 OnChangesWatch();
 
 static void ConnectToGlobalSignal( bool ( *func )() )
 {
@@ -100,6 +118,22 @@ public:
 
   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
@@ -108,21 +142,63 @@ public:
 
   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)
+  {
+    if (callback)
+    {
+      ConnectToGlobalSignal(&OnSecurityOriginAcquired);
+      mSecurityOriginAcquiredCallback = callback;
+    }
+    return true;
+  }
+
+  bool DeleteWebDatabase(Dali::WebEngineSecurityOrigin& origin)
+  {
+    return true;
+  }
+
+  bool GetWebStorageOrigins(Dali::WebEngineContext::WebEngineSecurityOriginAcquiredCallback callback)
+  {
+    if (callback)
+    {
+      ConnectToGlobalSignal(&OnSecurityOriginAcquired);
+      mSecurityOriginAcquiredCallback = callback;
+    }
+    return true;
+  }
+
+  bool GetWebStorageUsageForOrigin(Dali::WebEngineSecurityOrigin& origin, Dali::WebEngineContext::WebEngineStorageUsageAcquiredCallback callback) 
   {
+    if (callback)
+    {
+      ConnectToGlobalSignal(&OnStorageUsageAcquired);
+      mStorageUsageAcquiredCallback = callback;
+    }
+    return true;
   }
 
-  void DisableCache( bool cacheDisabled ) override
+  void DeleteAllWebStorage() override
+  {
+  }
+
+  bool DeleteWebStorage(Dali::WebEngineSecurityOrigin& origin)
+  {
+    return true;
+  }
+
+  void DeleteLocalFileSystem() override
   {
   }
 
@@ -130,8 +206,128 @@ public:
   {
   }
 
+  bool DeleteApplicationCache(Dali::WebEngineSecurityOrigin& origin)
+  {
+    return true;
+  }
+
+  void GetFormPasswordList(Dali::WebEngineContext::WebEngineFormPasswordAcquiredCallback callback)
+  {
+    if (callback)
+    {
+      ConnectToGlobalSignal(&OnFormPasswordAcquired);
+      mFormPasswordAcquiredCallback = callback;
+    }
+  }
+
+  void RegisterDownloadStartedCallback(Dali::WebEngineContext::WebEngineDownloadStartedCallback callback)
+  {
+    if (callback)
+    {
+      ConnectToGlobalSignal(&OnDownloadStarted);
+      mDownloadStartedCallback = callback;
+    }
+  }
+
+  void RegisterMimeOverriddenCallback(Dali::WebEngineContext::WebEngineMimeOverriddenCallback callback)
+  {
+    if (callback)
+    {
+      ConnectToGlobalSignal(&OnMimeOverridden);
+      mMimeOverriddenCallback = 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;
+
 private:
   Dali::WebEngineContext::CacheModel mockModel;
+  std::string                        mockProxyUri;
+  std::string                        mockBypassRule;
+  std::string                        mockCertificateFilePath;
+  bool                               mockCacheEnabled;
+  float                              mockZoomFactor;
 };
 
 class MockWebEngineCookieManager : public Dali::WebEngineCookieManager
@@ -160,171 +356,529 @@ public:
   {
   }
 
+  void ChangesWatch( Dali::WebEngineCookieManager::WebEngineCookieManagerChangesWatchCallback callback ) override
+  {
+    if ( callback )
+    {
+      ConnectToGlobalSignal( &OnChangesWatch );
+      mChangesWatchCallback = callback;
+    }
+  }
+
+public:
+  Dali::WebEngineCookieManager::WebEngineCookieManagerChangesWatchCallback mChangesWatchCallback;
+
 private:
   Dali::WebEngineCookieManager::CookieAcceptPolicy mockCookieAcceptPolicy;
 };
 
-class MockWebEngineBackForwardListItem : public Dali::WebEngineBackForwardListItem
+class MockWebEngineBackForwardListItem : public Dali::WebEngineBackForwardListItem
+{
+public:
+  MockWebEngineBackForwardListItem()
+    : mockUrl( "http://url" ),
+      mockTitle( "title" ),
+      mockOriginalUrl( "http://originalurl" )
+  {
+  }
+
+  std::string GetUrl() const override
+  {
+    return mockUrl;
+  }
+
+  std::string GetTitle() const override
+  {
+    return mockTitle;
+  }
+
+  std::string GetOriginalUrl() const override
+  {
+    return mockOriginalUrl;
+  }
+
+private:
+  std::string mockUrl;
+  std::string mockTitle;
+  std::string mockOriginalUrl;
+};
+
+class MockWebEngineBackForwardList : public Dali::WebEngineBackForwardList
+{
+public:
+  MockWebEngineBackForwardList()
+  {
+  }
+
+  std::unique_ptr<Dali::WebEngineBackForwardListItem> GetCurrentItem() const override
+  {
+    std::unique_ptr<Dali::WebEngineBackForwardListItem> ret(new MockWebEngineBackForwardListItem());
+    return ret;
+  }
+
+  std::unique_ptr<Dali::WebEngineBackForwardListItem> GetPreviousItem() const override
+  {
+    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;
+  }
+
+  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
+{
+public:
+  MockWebEngineFormRepostDecision()
+  {
+  }
+
+  void Reply(bool allowed) override {}
+};
+
+class MockWebEngineFrame : public Dali::WebEngineFrame
+{
+public:
+  MockWebEngineFrame()
+  {
+  }
+
+  bool IsMainFrame() const override
+  {
+    return true;
+  }
+};
+
+class MockWebEnginePolicyDecision : public Dali::WebEnginePolicyDecision
+{
+public:
+  MockWebEnginePolicyDecision()
+  {
+  }
+
+  std::string GetUrl() const override
+  {
+    return "http://test.html";
+  }
+
+  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 MockWebEngineRequestInterceptor : public WebEngineRequestInterceptor
+{
+public:
+  MockWebEngineRequestInterceptor()
+  {
+  }
+
+  std::string GetUrl() const override
+  {
+    return "http://test.html";
+  }
+
+  bool Ignore() override
+  {
+    return true;
+  }
+
+  bool SetResponseStatus(int statusCode, const std::string &customedStatusText) override
+  {
+    return true;
+  }
+
+  bool AddResponseHeader(const std::string &fieldName, const std::string &fieldValue) override
+  {
+    return true;
+  }
+
+  bool AddResponseBody(const std::string &body, uint32_t length) override
+  {
+    return true;
+  }
+};
+
+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;
+  }
+
+  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:
-  MockWebEngineBackForwardListItem()
-    : mockUrl( "http://url" ),
-      mockTitle( "title" ),
-      mockOriginalUrl( "http://originalurl" )
+  MockWebEngineContextMenu()
   {
   }
 
-  std::string GetUrl() const override
+  uint32_t GetItemCount() const override
   {
-    return mockUrl;
+    return 1;
   }
 
-  std::string GetTitle() const override
+  std::unique_ptr<Dali::WebEngineContextMenuItem> GetItemAt(uint32_t index) const override
   {
-    return mockTitle;
+    std::unique_ptr<Dali::WebEngineContextMenuItem> webitem(new MockWebEngineContextMenuItem());
+    return webitem;
   }
 
-  std::string GetOriginalUrl() const override
+  std::vector<std::unique_ptr<WebEngineContextMenuItem>> GetItemList() const override
   {
-    return mockOriginalUrl;
+    std::vector<std::unique_ptr<WebEngineContextMenuItem>> result;
+    std::unique_ptr<Dali::WebEngineContextMenuItem> webitem(new MockWebEngineContextMenuItem());
+    result.push_back(std::move(webitem));
+    return result;
   }
 
-private:
-  std::string mockUrl;
-  std::string mockTitle;
-  std::string mockOriginalUrl;
-};
-
-class MockWebEngineBackForwardList : public Dali::WebEngineBackForwardList
-{
-public:
-  MockWebEngineBackForwardList()
-    : mockItem(),
-      pMockItem( &mockItem )
+  bool RemoveItem(WebEngineContextMenuItem& item) override
   {
+    return true;
   }
 
-  Dali::WebEngineBackForwardListItem& GetCurrentItem() const override
+  bool AppendItemAsAction(WebEngineContextMenuItem::ItemTag tag, const std::string& title, bool enabled) override
   {
-    return *pMockItem;
+    return true;
   }
 
-  Dali::WebEngineBackForwardListItem& GetItemAtIndex( uint32_t index ) const override
+  bool AppendItem(WebEngineContextMenuItem::ItemTag tag, const std::string& title, const std::string& iconFile, bool enabled) override
   {
-    return *pMockItem;
+    return true;
   }
 
-  uint32_t GetItemCount() const override
+  bool SelectItem(WebEngineContextMenuItem& item) override
   {
-    return 1;
+    return true;
   }
 
-private:
-  MockWebEngineBackForwardListItem mockItem;
-  WebEngineBackForwardListItem* pMockItem;
+  bool Hide() override
+  {
+    return true;
+  }
 };
 
-class MockWebEngineFormRepostDecision : public WebEngineFormRepostDecision
+class MockWebEngineHitTest : public Dali::WebEngineHitTest
 {
 public:
-  MockWebEngineFormRepostDecision()
+  MockWebEngineHitTest()
   {
   }
 
-  void Reply(bool allowed) override {}
-};
-
-class MockWebEngineRequestInterceptor : public WebEngineRequestInterceptor
-{
-public:
-  MockWebEngineRequestInterceptor()
+  ResultContext GetResultContext() const override
   {
+    return ResultContext::DOCUMENT;
   }
 
-  std::string GetUrl() const override
+  std::string GetLinkUri() const override
   {
     return "http://test.html";
   }
 
-  bool Ignore() override
+  std::string GetLinkTitle() const override
   {
-    return true;
+    return "test";
   }
 
-  bool SetResponseStatus(int statusCode, const std::string &customedStatusText) override
+  std::string GetLinkLabel() const override
   {
-    return true;
+    return "label";
   }
 
-  bool AddResponseHeader(const std::string &fieldName, const std::string &fieldValue) override
+  std::string GetImageUri() const override
   {
-    return true;
+    return "http://test.jpg";
   }
 
-  bool AddResponseBody(const std::string &body, uint32_t length) override
+  std::string GetMediaUri() const override
   {
-    return true;
+    return "http://test.mp4";
   }
-};
 
-class MockWebEngineConsoleMessage : public Dali::WebEngineConsoleMessage
-{
-public:
-  MockWebEngineConsoleMessage()
+  std::string GetTagName() const override
   {
+    return "img";
   }
 
-  std::string GetSource() const override
+  std::string GetNodeValue() const override
   {
-    return "source";
+    return "test";
   }
 
-  uint32_t GetLine() const override
+  Dali::Property::Map& GetAttributes() const override
   {
-    return 10;
+    return mockAttributesMap;
   }
 
-  SeverityLevel GetSeverityLevel() const override
+  std::string GetImageFileNameExtension() const override
   {
-    return SeverityLevel::EMPTY;
+    return "jpg";
   }
 
-  std::string GetText() const override
+  Dali::PixelData GetImageBuffer() override
   {
-    return "This is a text.";
+    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 MockWebEngineLoadError : public Dali::WebEngineLoadError
+class MockWebEngineSecurityOrigin : public Dali::WebEngineSecurityOrigin
 {
 public:
-  MockWebEngineLoadError(const std::string& url)
-    : mockUrl(url)
+  MockWebEngineSecurityOrigin()
+    : mockUrl("https://test.html")
+    , mockPotocol("https")
   {
   }
 
-  std::string GetUrl() const override
+  std::string GetHost() const
   {
     return mockUrl;
   }
 
-  ErrorCode GetCode() const override
-  {
-    return ErrorCode::UNKNOWN;
-  }
-
-  std::string GetDescription() const override
-  {
-    return "This is an error.";
-  }
-
-  ErrorType GetType() const override
+  std::string GetProtocol() const
   {
-    return ErrorType::NONE;
+    return mockPotocol;
   }
 
 private:
   std::string mockUrl;
+  std::string mockPotocol;
 };
 
 class MockWebEngineSettings : public WebEngineSettings
@@ -542,6 +1096,40 @@ public:
   {
   }
 
+  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;
@@ -565,8 +1153,6 @@ class WebEngine: public Dali::BaseObject
 {
 public:
 
-  using JavaScriptEvaluatedResultCallback = std::function<void(const std::string&)>;
-
   WebEngine()
     : mUrl()
     , mCurrentPlusOnePos( 0 )
@@ -583,7 +1169,12 @@ public:
     }
 
     mockWebEngineSettings = new MockWebEngineSettings();
-    mockWebEngineContext = new MockWebEngineContext();
+    MockWebEngineContext* engineContext = new MockWebEngineContext();
+    mockWebEngineContext = engineContext;
+    if ( gInstanceCount == 1 )
+    {
+      gWebEngineContextInstance = engineContext;
+    }
     mockWebEngineCookieManager = new MockWebEngineCookieManager();
     mockWebEngineBackForwardList = new MockWebEngineBackForwardList();
   }
@@ -594,6 +1185,7 @@ public:
     if( !gInstanceCount )
     {
       gInstance = 0;
+      gWebEngineContextInstance = 0;
     }
 
     delete mockWebEngineSettings;
@@ -628,7 +1220,7 @@ public:
     ConnectToGlobalSignal( &OnLoadUrl );
   }
 
-  const std::string& GetUrl() const
+  std::string GetUrl() const
   {
     return mUrl;
   }
@@ -640,28 +1232,20 @@ public:
 
   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
@@ -723,12 +1307,28 @@ public:
     }
   }
 
+  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;
   }
@@ -738,7 +1338,7 @@ public:
     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 )
@@ -747,7 +1347,7 @@ public:
     }
   }
 
-  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 )
@@ -757,7 +1357,7 @@ public:
     return true;
   }
 
-  void SetScrollPosition( int x, int y )
+  void SetScrollPosition( int32_t x, int32_t y )
   {
     mScrollPosition.x = x;
     mScrollPosition.y = y;
@@ -813,7 +1413,7 @@ public:
     return mScaleFactor;
   }
 
-  Dali::PixelData GetScreenshot(Dali::Rect<int> viewArea, float scaleFactor)
+  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 ];
@@ -823,7 +1423,7 @@ public:
                                  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 )
     {
@@ -852,54 +1452,84 @@ public:
     }
   }
 
-  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 RegisterRequestInterceptorCallback(Dali::WebEnginePlugin::WebEngineRequestInterceptorCallback callback)
   {
-    return mFrameRenderedSignal;
+    mRequestInterceptorCallback = callback;
+  }
+
+  void RegisterConsoleMessageReceivedCallback(Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback callback)
+  {
+    mConsoleMessageCallback = callback;
+  }
+
+  void RegisterResponsePolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback callback)
+  {
+    mResponsePolicyDecisionCallback = 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;
   }
 
-  Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType& RequestInterceptorSignal()
+  void RegisterContextMenuShownCallback(Dali::WebEnginePlugin::WebEngineContextMenuShownCallback callback)
   {
-    return mRequestInterceptorSignal;
+    mContextMenuShownCallback = callback;
   }
 
-  Dali::WebEnginePlugin::WebEngineConsoleMessageSignalType& ConsoleMessageSignal()
+  void RegisterContextMenuHiddenCallback(Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback callback)
   {
-    return mConsoleMessageSignal;
+    mContextMenuHiddenCallback = callback;
   }
 
   std::string              mUrl;
@@ -907,16 +1537,7 @@ public:
   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::WebEngineConsoleMessageSignalType     mConsoleMessageSignal;
+  Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType mFrameRenderedSignal;
 
   bool  mEvaluating;
   float mPageZoomFactor;
@@ -931,13 +1552,31 @@ public:
   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::WebEngineRequestInterceptorCallback     mRequestInterceptorCallback;
+  Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback mConsoleMessageCallback;
+  Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback  mResponsePolicyDecisionCallback;
+  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;
 };
 
 
@@ -978,21 +1617,77 @@ bool OnLoadUrl()
     }
     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));
-
-    std::shared_ptr<Dali::WebEngineLoadError> error(new MockWebEngineLoadError(gInstance->mUrl));
-    gInstance->mPageLoadErrorSignal.Emit(std::move(error));
-    std::shared_ptr<Dali::WebEngineConsoleMessage> message(new MockWebEngineConsoleMessage());
-    gInstance->mConsoleMessageSignal.Emit(std::move(message));
+    if (gInstance->mFrameRenderedCallback)
+    {
+      gInstance->mFrameRenderedCallback();
+    }
+    if (gInstance->mRequestInterceptorCallback)
+    {
+      std::unique_ptr<Dali::WebEngineRequestInterceptor> interceptor(new MockWebEngineRequestInterceptor());
+      gInstance->mRequestInterceptorCallback(std::move(interceptor));
+    }
+    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->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;
 }
@@ -1001,9 +1696,9 @@ bool OnScrollEdge()
 {
   DisconnectFromGlobalSignal( &OnScrollEdge );
 
-  if( gInstance )
+  if( gInstance && gInstance->mScrollEdgeReachedCallback )
   {
-    gInstance->mScrollEdgeReachedSignal.Emit( Dali::WebEnginePlugin::ScrollEdge::BOTTOM );
+    gInstance->mScrollEdgeReachedCallback( Dali::WebEnginePlugin::ScrollEdge::BOTTOM );
   }
 
   return false;
@@ -1089,6 +1784,17 @@ bool OnGeolocationPermission()
   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 );
@@ -1103,6 +1809,81 @@ bool 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 OnChangesWatch()
+{
+  DisconnectFromGlobalSignal( &OnChangesWatch );
+
+  if ( gInstance )
+  {
+    MockWebEngineCookieManager* temp = (MockWebEngineCookieManager *)(&(gInstance->GetCookieManager()));
+    if ( temp )
+    {
+      temp->mChangesWatchCallback();
+    }
+  }
+
+  return false;
+}
+
 } // namespace
 
 inline WebEngine& GetImplementation( Dali::WebEngine& webEngine )
@@ -1160,11 +1941,11 @@ WebEngine WebEngine::DownCast( BaseHandle handle )
   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 )
 {
 }
 
@@ -1207,7 +1988,7 @@ Dali::PixelData WebEngine::GetFavicon() const
   return Internal::Adaptor::GetImplementation( *this ).GetFavicon();
 }
 
-const std::string& WebEngine::GetUrl()
+std::string WebEngine::GetUrl() const
 {
   return Internal::Adaptor::GetImplementation( *this ).GetUrl();
 }
@@ -1338,6 +2119,16 @@ void WebEngine::JavaScriptPromptReply( const std::string& result )
 {
 }
 
+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()
 {
 }
@@ -1370,12 +2161,12 @@ void WebEngine::AddDynamicCertificatePath(const std::string& host, const std::st
 {
 }
 
-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);
 }
@@ -1390,7 +2181,7 @@ void WebEngine::RegisterGeolocationPermissionCallback(Dali::WebEnginePlugin::Geo
   Internal::Adaptor::GetImplementation( *this ).RegisterGeolocationPermissionCallback(callback);
 }
 
-const std::string& WebEngine::GetUserAgent() const
+std::string WebEngine::GetUserAgent() const
 {
   return Internal::Adaptor::GetImplementation( *this ).GetUserAgent();
 }
@@ -1400,17 +2191,17 @@ void WebEngine::SetUserAgent( const std::string& userAgent )
   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 );
 }
@@ -1430,7 +2221,7 @@ Dali::Vector2 WebEngine::GetContentSize() const
   return Internal::Adaptor::GetImplementation( *this ).GetContentSize();
 }
 
-void WebEngine::SetSize( int width, int height )
+void WebEngine::SetSize( uint32_t width, uint32_t height )
 {
 }
 
@@ -1504,7 +2295,7 @@ float WebEngine::GetLoadProgressPercentage() const
   return Internal::Adaptor::GetImplementation( *this ).GetLoadProgressPercentage();
 }
 
-void WebEngine::UpdateDisplayArea( Dali::Rect< int > displayArea )
+void WebEngine::UpdateDisplayArea( Dali::Rect< int32_t > displayArea )
 {
 }
 
@@ -1520,54 +2311,84 @@ void WebEngine::EnableKeyEvents( bool enabled )
 {
 }
 
-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);
+}
+
+void WebEngine::RegisterRequestInterceptorCallback(Dali::WebEnginePlugin::WebEngineRequestInterceptorCallback callback)
+{
+  Internal::Adaptor::GetImplementation( *this ).RegisterRequestInterceptorCallback(callback);
+}
+
+void WebEngine::RegisterConsoleMessageReceivedCallback(Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback callback)
+{
+  Internal::Adaptor::GetImplementation( *this ).RegisterConsoleMessageReceivedCallback(callback);
+}
+
+void WebEngine::RegisterResponsePolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback callback)
+{
+  Internal::Adaptor::GetImplementation( *this ).RegisterResponsePolicyDecidedCallback(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);
 }
 
-Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType& WebEngine::RequestInterceptorSignal()
+void WebEngine::RegisterContextMenuShownCallback(Dali::WebEnginePlugin::WebEngineContextMenuShownCallback callback)
 {
-  return Internal::Adaptor::GetImplementation(*this).RequestInterceptorSignal();
+  Internal::Adaptor::GetImplementation( *this ).RegisterContextMenuShownCallback(callback);
 }
 
-Dali::WebEnginePlugin::WebEngineConsoleMessageSignalType& WebEngine::ConsoleMessageSignal()
+void WebEngine::RegisterContextMenuHiddenCallback(Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback callback)
 {
-  return Internal::Adaptor::GetImplementation(*this).ConsoleMessageSignal();
+  Internal::Adaptor::GetImplementation( *this ).RegisterContextMenuHiddenCallback(callback);
 }
 
 } // namespace Dali;