X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=automated-tests%2Fsrc%2Fdali-toolkit%2Fdali-toolkit-test-utils%2Ftoolkit-web-engine.cpp;h=0043f2c0f804721ca882b091df471bddfc0257cb;hp=372aec91d995140f9395d48ec0eb053da242fcf4;hb=fb222199e44a5352d8c7f6e1c715da1a995e41af;hpb=c2d8362d9a983d332a32d60fdb17b72aa3cf298d

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 372aec9..0043f2c 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
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,9 +18,15 @@
 #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-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/adaptor-framework/native-image-source.h>
 #include <toolkit-application.h>
 
 namespace Dali
@@ -36,46 +42,441 @@ class WebEngine;
 
 namespace
 {
-static WebEngine* gInstance = NULL;
+
+// 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;
 
 bool OnGoBack();
 bool OnGoForward();
 bool OnLoadUrl();
 bool OnEvaluteJavaScript();
+bool OnJavaScriptAlert();
+bool OnJavaScriptConfirm();
+bool OnJavaScriptPrompt();
+bool OnScrollEdge();
 bool OnClearHistory();
 
-static void ConnectToGlobalSignal( bool (*func)() )
+static void ConnectToGlobalSignal( bool ( *func )() )
 {
   Dali::Timer timer = Dali::Timer::New( 0 );
   timer.TickSignal().Connect( func );
 }
 
-static void DisconnectFromGlobalSignal( bool (*func)() )
+static void DisconnectFromGlobalSignal( bool ( *func )() )
 {
   Dali::Timer timer = Dali::Timer::New( 0 );
   timer.TickSignal().Disconnect( func );
 }
-}
+} // namespace anonymous
+
+class MockWebEngineContext : public Dali::WebEngineContext
+{
+public:
+  MockWebEngineContext()
+    : mockModel( Dali::WebEngineContext::CacheModel::DOCUMENT_VIEWER )
+  {
+  }
+
+  Dali::WebEngineContext::CacheModel GetCacheModel() const override
+  {
+    return mockModel;
+  }
+
+  void SetCacheModel( Dali::WebEngineContext::CacheModel cacheModel ) override
+  {
+    mockModel = cacheModel;
+  }
+
+  void SetProxyUri( const std::string& uri ) override
+  {
+  }
+
+  void SetDefaultProxyAuth( const std::string& username, const std::string& password ) override
+  {
+  }
+
+  void SetCertificateFilePath( const std::string& certificatePath ) override
+  {
+  }
+
+  void DeleteWebDatabase() override
+  {
+  }
+
+  void DeleteWebStorage() override
+  {
+  }
+
+  void DeleteLocalFileSystem() override
+  {
+  }
+
+  void DisableCache( bool cacheDisabled ) override
+  {
+  }
+
+  void ClearCache() override
+  {
+  }
+
+private:
+  Dali::WebEngineContext::CacheModel mockModel;
+};
+
+class MockWebEngineCookieManager : public Dali::WebEngineCookieManager
+{
+public:
+  MockWebEngineCookieManager()
+    : mockCookieAcceptPolicy( Dali::WebEngineCookieManager::CookieAcceptPolicy::NO_THIRD_PARTY )
+  {
+  }
+
+  void SetCookieAcceptPolicy( Dali::WebEngineCookieManager::CookieAcceptPolicy policy ) override
+  {
+    mockCookieAcceptPolicy = policy;
+  }
+
+  Dali::WebEngineCookieManager::CookieAcceptPolicy GetCookieAcceptPolicy() const override
+  {
+    return mockCookieAcceptPolicy;
+  }
+
+  void ClearCookies() override
+  {
+  }
+
+  void SetPersistentStorage( const std::string& path, Dali::WebEngineCookieManager::CookiePersistentStorage storage ) override
+  {
+  }
+
+private:
+  Dali::WebEngineCookieManager::CookieAcceptPolicy mockCookieAcceptPolicy;
+};
+
+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( )
+    : mockItem(),
+      pMockItem( &mockItem )
+  {
+  }
+
+  Dali::WebEngineBackForwardListItem& GetCurrentItem() const override
+  {
+    return *pMockItem;
+  }
+
+  Dali::WebEngineBackForwardListItem& GetItemAtIndex( uint32_t index ) const override
+  {
+    return *pMockItem;
+  }
+
+  uint32_t GetItemCount() const override
+  {
+    return 1;
+  }
+
+private:
+  MockWebEngineBackForwardListItem mockItem;
+  WebEngineBackForwardListItem* pMockItem;
+};
+
+class MockWebEngineSettings : public WebEngineSettings
+{
+public:
+  MockWebEngineSettings()
+    : mockDefaultFontSize( 16 ),
+      mockJavaScriptEnabled( true ),
+      mockAutoFittingEnabled ( true ),
+      mockPluginsEnabled ( true ),
+      mockPrivateBrowsingEnabled( true ),
+      mockLinkMagnifierEnabled( true ),
+      mockKeypadWithoutUserActionUsed( true ),
+      mockAutofillPasswordFormEnabled( true ),
+      mockFormCandidateDataEnabled( true ),
+      mockTextSelectionEnabled( true ),
+      mockTextAutosizingEnable( true ),
+      mockArrowScrollEnable( true ),
+      mockClipboardEnabled( true ),
+      mockImePanelEnabled( true ),
+      mockImageLoadedAutomatically( true ),
+      mockDefaultTextEncodingName()
+  {
+  }
+
+  uint32_t GetDefaultFontSize() const override
+  {
+    return mockDefaultFontSize;
+  }
+
+  void SetDefaultFontSize( uint32_t size ) override
+  {
+    mockDefaultFontSize = size;
+  }
+
+  bool IsJavaScriptEnabled() const override
+  {
+    return mockJavaScriptEnabled;
+  }
+
+  void EnableJavaScript( bool enabled ) override
+  {
+    mockJavaScriptEnabled = enabled;
+  }
+
+  bool IsAutoFittingEnabled() const override
+  {
+    return mockAutoFittingEnabled;
+  }
+
+  void EnableAutoFitting( bool enabled ) override
+  {
+    mockAutoFittingEnabled = enabled;
+  }
+
+  bool ArePluginsEnabled() const override
+  {
+    return mockPluginsEnabled;
+  }
+
+  void EnablePlugins( bool enabled ) override
+  {
+    mockPluginsEnabled = enabled;
+  }
+
+  bool IsPrivateBrowsingEnabled() const override
+  {
+    return mockPrivateBrowsingEnabled;
+  }
+
+  void EnablePrivateBrowsing( bool enabled ) override
+  {
+    mockPrivateBrowsingEnabled = enabled;
+  }
+
+  bool IsLinkMagnifierEnabled() const override
+  {
+    return mockLinkMagnifierEnabled;
+  }
+
+  void EnableLinkMagnifier( bool enabled ) override
+  {
+    mockLinkMagnifierEnabled = enabled;
+  }
+
+  bool IsKeypadWithoutUserActionUsed() const override
+  {
+    return mockKeypadWithoutUserActionUsed;
+  }
+
+  void UseKeypadWithoutUserAction( bool used ) override
+  {
+    mockKeypadWithoutUserActionUsed = used;
+  }
+
+  bool IsAutofillPasswordFormEnabled() const override
+  {
+    return mockAutofillPasswordFormEnabled;
+  }
+
+  void EnableAutofillPasswordForm( bool enabled ) override
+  {
+    mockAutofillPasswordFormEnabled = enabled;
+  }
+
+  bool IsFormCandidateDataEnabled() const override
+  {
+    return mockFormCandidateDataEnabled;
+  }
+
+  void EnableFormCandidateData( bool enabled ) override
+  {
+    mockFormCandidateDataEnabled = enabled;
+  }
+
+  bool IsTextSelectionEnabled() const override
+  {
+    return mockTextSelectionEnabled;
+  }
+
+  void EnableTextSelection( bool enabled ) override
+  {
+    mockTextSelectionEnabled = enabled;
+  }
+
+  bool IsTextAutosizingEnabled() const override
+  {
+    return mockTextAutosizingEnable;
+  }
+
+  void EnableTextAutosizing( bool enabled ) override
+  {
+    mockTextAutosizingEnable = enabled;
+  }
+
+  bool IsArrowScrollEnabled() const override
+  {
+    return mockArrowScrollEnable;
+  }
+
+  void EnableArrowScroll( bool enabled ) override
+  {
+    mockArrowScrollEnable = enabled;
+  }
+
+  bool IsClipboardEnabled() const override
+  {
+    return mockClipboardEnabled;
+  }
+
+  void EnableClipboard( bool enabled ) override
+  {
+    mockClipboardEnabled = enabled;
+  }
+
+  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
+  {
+  }
+
+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 WebEngine: public Dali::BaseObject
 {
 public:
 
+  using JavaScriptEvaluatedResultCallback = std::function<void(const std::string&)>;
+  using JavaScriptAlertCallback = std::function<bool(const std::string&)>;
+  using JavaScriptConfirmCallback = std::function<bool(const std::string&)>;
+  using JavaScriptPromptCallback = std::function<bool(const std::string&, const std::string&)>;
+
   WebEngine()
     : mUrl()
     , mCurrentPlusOnePos( 0 )
-    , mCacheModel( Dali::WebEnginePlugin::CacheModel::DOCUMENT_VIEWER )
-    , mCookieAcceptPolicy( Dali::WebEnginePlugin::CookieAcceptPolicy::NO_THIRD_PARTY )
     , mUserAgent()
-    , mEnableJavaScript( true )
-    , mLoadImagesAutomatically( true )
-    , mDefaultTextEncodingName()
-    , mDefaultFontSize( 16 )
     , mEvaluating( false )
+    , mScrollPosition( 0, 0 )
+    , mScrollSize( 500, 500 )
+    , mContentSize( 500, 500 )
   {
     gInstanceCount++;
-    gInstance = this;
+    if ( gInstanceCount == 1 ) // only first web engine need be saved.
+    {
+      gInstance = this;
+    }
+
+    mockWebEngineSettings = new MockWebEngineSettings();
+    mockWebEngineContext = new MockWebEngineContext();
+    mockWebEngineCookieManager = new MockWebEngineCookieManager();
+    mockWebEngineBackForwardList = new MockWebEngineBackForwardList();
   }
 
   virtual ~WebEngine()
@@ -83,8 +484,33 @@ public:
     gInstanceCount--;
     if( !gInstanceCount )
     {
-      gInstance = NULL;
+      gInstance = 0;
     }
+
+    delete mockWebEngineSettings;
+    delete mockWebEngineContext;
+    delete mockWebEngineCookieManager;
+    delete mockWebEngineBackForwardList;
+  }
+
+  Dali::WebEngineSettings& GetSettings() const
+  {
+    return *mockWebEngineSettings;
+  }
+
+  Dali::WebEngineContext& GetContext() const
+  {
+    return *mockWebEngineContext;
+  }
+
+  Dali::WebEngineCookieManager& GetCookieManager() const
+  {
+    return *mockWebEngineCookieManager;
+  }
+
+  Dali::WebEngineBackForwardList& GetBackForwardList() const
+  {
+    return *mockWebEngineBackForwardList;
   }
 
   void LoadUrl( const std::string& url )
@@ -98,6 +524,37 @@ public:
     return mUrl;
   }
 
+  std::string GetTitle() const
+  {
+    return std::string("title");
+  }
+
+  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 );
+  }
+
   bool CanGoForward() const
   {
     return mHistory.size() > mCurrentPlusOnePos;
@@ -130,29 +587,36 @@ public:
     }
   }
 
-  void ClearHistory()
-  {
-    ConnectToGlobalSignal( &OnClearHistory );
-  }
-
-  Dali::WebEnginePlugin::CacheModel GetCacheModel() const
+  void RegisterJavaScriptAlertCallback( Dali::WebEnginePlugin::JavaScriptAlertCallback callback )
   {
-    return mCacheModel;
+    if ( callback )
+    {
+      ConnectToGlobalSignal( &OnJavaScriptAlert );
+      mJavaScriptAlertCallback = callback;
+    }
   }
 
-  void SetCacheModel( Dali::WebEnginePlugin::CacheModel cacheModel )
+  void RegisterJavaScriptConfirmCallback( Dali::WebEnginePlugin::JavaScriptConfirmCallback callback )
   {
-    mCacheModel = cacheModel;
+    if ( callback )
+    {
+      ConnectToGlobalSignal( &OnJavaScriptConfirm );
+      mJavaScriptConfirmCallback = callback;
+    }
   }
 
-  Dali::WebEnginePlugin::CookieAcceptPolicy GetCookieAcceptPolicy() const
+  void RegisterJavaScriptPromptCallback( Dali::WebEnginePlugin::JavaScriptPromptCallback callback )
   {
-    return mCookieAcceptPolicy;
+    if ( callback )
+    {
+      ConnectToGlobalSignal( &OnJavaScriptPrompt );
+      mJavaScriptPromptCallback = callback;
+    }
   }
 
-  void SetCookieAcceptPolicy( Dali::WebEnginePlugin::CookieAcceptPolicy policy )
+  void ClearHistory()
   {
-    mCookieAcceptPolicy = policy;
+    ConnectToGlobalSignal( &OnClearHistory );
   }
 
   const std::string& GetUserAgent() const
@@ -165,91 +629,92 @@ public:
     mUserAgent = userAgent;
   }
 
-  bool IsJavaScriptEnabled() const
+  void ScrollBy( int dx, int dy )
   {
-    return mEnableJavaScript;
+    mScrollPosition += Dali::Vector2( dx, dy );
+    if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
+    {
+      ConnectToGlobalSignal( &OnScrollEdge );
+    }
   }
 
-  void EnableJavaScript( bool enabled )
+  void SetScrollPosition( int x, int y )
   {
-    mEnableJavaScript = enabled;
+    mScrollPosition.x = x;
+    mScrollPosition.y = y;
   }
 
-  bool AreImagesAutomaticallyLoaded() const
+  Dali::Vector2 GetScrollPosition() const
   {
-    return mLoadImagesAutomatically;
+    return mScrollPosition;
   }
 
-  void LoadImagesAutomatically( bool automatic )
+  Dali::Vector2 GetScrollSize() const
   {
-    mLoadImagesAutomatically = automatic;
+    return mScrollSize;
   }
 
-  const std::string& GetDefaultTextEncodingName() const
+  Dali::Vector2 GetContentSize() const
   {
-    return mDefaultTextEncodingName;
+    return  mContentSize;
   }
 
-  void SetDefaultTextEncodingName( const std::string& defaultTextEncodingName )
+  Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadStartedSignal()
   {
-    mDefaultTextEncodingName = defaultTextEncodingName;
+    return mPageLoadStartedSignal;
   }
 
-  int GetDefaultFontSize() const
+  Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadInProgressSignal()
   {
-    return mDefaultFontSize;
+    return mPageLoadInProgressSignal;
   }
 
-  void SetDefaultFontSize( int defaultFontSize )
+  Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadFinishedSignal()
   {
-    mDefaultFontSize = defaultFontSize;
+    return mPageLoadFinishedSignal;
   }
 
-  Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadStartedSignal()
+  Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& PageLoadErrorSignal()
   {
-    return mPageLoadStartedSignal;
+    return mPageLoadErrorSignal;
   }
 
-  Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadFinishedSignal()
+  Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType& ScrollEdgeReachedSignal()
   {
-    return mPageLoadFinishedSignal;
+    return mScrollEdgeReachedSignal;
   }
 
-  Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& PageLoadErrorSignal()
+  Dali::WebEnginePlugin::WebEngineUrlChangedSignalType& UrlChangedSignal()
   {
-    return mPageLoadErrorSignal;
+    return mUrlChangedSignal;
   }
 
   std::string                                                mUrl;
   std::vector< std::string >                                 mHistory;
   size_t                                                     mCurrentPlusOnePos;
-  Dali::WebEnginePlugin::CacheModel                          mCacheModel;
-  Dali::WebEnginePlugin::CookieAcceptPolicy                  mCookieAcceptPolicy;
   std::string                                                mUserAgent;
-  bool                                                       mEnableJavaScript;
-  bool                                                       mLoadImagesAutomatically;
-  std::string                                                mDefaultTextEncodingName;
-  int                                                        mDefaultFontSize;
   Dali::WebEnginePlugin::WebEnginePageLoadSignalType         mPageLoadStartedSignal;
+  Dali::WebEnginePlugin::WebEnginePageLoadSignalType         mPageLoadInProgressSignal;
   Dali::WebEnginePlugin::WebEnginePageLoadSignalType         mPageLoadFinishedSignal;
   Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType    mPageLoadErrorSignal;
-  std::vector< std::function< void( const std::string& ) > > mResultCallbacks;
+  std::vector<JavaScriptEvaluatedResultCallback>             mResultCallbacks;
   bool                                                       mEvaluating;
-};
 
-inline WebEngine& GetImplementation( Dali::WebEngine& webEngine )
-{
-  DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
-  BaseObject& handle = webEngine.GetBaseObject();
-  return static_cast< Internal::Adaptor::WebEngine& >( handle );
-}
+  Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType mScrollEdgeReachedSignal;
+  Dali::Vector2                                               mScrollPosition;
+  Dali::Vector2                                               mScrollSize;
+  Dali::Vector2                                               mContentSize;
+  WebEngineBackForwardList*                                   mockWebEngineBackForwardList;
+  WebEngineContext*                                           mockWebEngineContext;
+  WebEngineCookieManager*                                     mockWebEngineCookieManager;
+  WebEngineSettings*                                          mockWebEngineSettings;
+  Dali::WebEnginePlugin::WebEngineUrlChangedSignalType        mUrlChangedSignal;
+
+  JavaScriptAlertCallback                                     mJavaScriptAlertCallback;
+  JavaScriptConfirmCallback                                   mJavaScriptConfirmCallback;
+  JavaScriptPromptCallback                                    mJavaScriptPromptCallback;
+};
 
-inline const WebEngine& GetImplementation( const Dali::WebEngine& webEngine )
-{
-  DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
-  const BaseObject& handle = webEngine.GetBaseObject();
-  return static_cast< const Internal::Adaptor::WebEngine& >( handle );
-}
 
 namespace
 {
@@ -289,8 +754,22 @@ 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" );
+  }
+  return false;
+}
+
+bool OnScrollEdge()
+{
+  DisconnectFromGlobalSignal( &OnScrollEdge );
+
+  if( gInstance )
+  {
+    gInstance->mScrollEdgeReachedSignal.Emit( Dali::WebEnginePlugin::ScrollEdge::BOTTOM );
   }
+
   return false;
 }
 
@@ -309,11 +788,42 @@ bool OnEvaluteJavaScript()
   return false;
 }
 
+bool OnJavaScriptAlert()
+{
+  DisconnectFromGlobalSignal( &OnJavaScriptAlert );
+  if ( gInstance )
+  {
+    gInstance->mJavaScriptAlertCallback( "this is an alert popup." );
+  }
+  return false;
+}
+
+bool OnJavaScriptConfirm()
+{
+  DisconnectFromGlobalSignal( &OnJavaScriptConfirm );
+  if ( gInstance )
+  {
+    gInstance->mJavaScriptConfirmCallback( "this is a confirm popup." );
+  }
+  return false;
+}
+
+bool OnJavaScriptPrompt()
+{
+  DisconnectFromGlobalSignal( &OnJavaScriptPrompt );
+  if ( gInstance )
+  {
+    gInstance->mJavaScriptPromptCallback( "this is a prompt pompt.", "" );
+  }
+  return false;
+}
+
 bool OnClearHistory()
 {
   DisconnectFromGlobalSignal( &OnClearHistory );
 
-  if( gInstance && gInstance->mCurrentPlusOnePos ) {
+  if( gInstance && gInstance->mCurrentPlusOnePos )
+  {
     std::string url = gInstance->mHistory[ gInstance->mCurrentPlusOnePos - 1 ];
     std::vector< std::string >().swap( gInstance->mHistory );
     gInstance->mHistory.push_back( url );
@@ -321,13 +831,27 @@ bool OnClearHistory()
   }
   return false;
 }
+
 } // namespace
 
+inline WebEngine& GetImplementation( Dali::WebEngine& webEngine )
+{
+  DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
+  BaseObject& handle = webEngine.GetBaseObject();
+  return static_cast< Internal::Adaptor::WebEngine& >( handle );
+}
+
+inline const WebEngine& GetImplementation( const Dali::WebEngine& webEngine )
+{
+  DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
+  const BaseObject& handle = webEngine.GetBaseObject();
+  return static_cast< const Internal::Adaptor::WebEngine& >( handle );
+}
+
 } // namespace Adaptor
 
 } // namespace Internal
 
-
 // Dali::WebEngine Implementation
 WebEngine::WebEngine()
 {
@@ -369,15 +893,49 @@ void WebEngine::Create( int width, int height, const std::string& locale, const
 {
 }
 
+void WebEngine::Create( int width, int height, int argc, char** argv )
+{
+}
+
 void WebEngine::Destroy()
 {
 }
 
+WebEngineSettings& WebEngine::GetSettings() const
+{
+  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();
+}
+
 void WebEngine::LoadUrl( const std::string& url )
 {
   return Internal::Adaptor::GetImplementation( *this ).LoadUrl( url );
 }
 
+std::string WebEngine::GetTitle() const
+{
+  return Internal::Adaptor::GetImplementation( *this ).GetTitle();
+}
+
+Dali::PixelData WebEngine::GetFavicon() const
+{
+  return Internal::Adaptor::GetImplementation( *this ).GetFavicon();
+}
+
 const std::string& WebEngine::GetUrl()
 {
   return Internal::Adaptor::GetImplementation( *this ).GetUrl();
@@ -390,7 +948,7 @@ NativeImageInterfacePtr WebEngine::GetNativeImageSource()
   return sourcePtr;
 }
 
-void WebEngine::LoadHTMLString( const std::string& htmlString )
+void WebEngine::LoadHtmlString( const std::string& htmlString )
 {
 }
 
@@ -439,37 +997,40 @@ void WebEngine::AddJavaScriptMessageHandler( const std::string& exposedObjectNam
 {
 }
 
-void WebEngine::ClearHistory()
+void WebEngine::RegisterJavaScriptAlertCallback( Dali::WebEnginePlugin::JavaScriptAlertCallback callback )
+{
+  Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptAlertCallback( callback );
+}
+
+void WebEngine::JavaScriptAlertReply()
 {
-  Internal::Adaptor::GetImplementation( *this ).ClearHistory();
 }
 
-void WebEngine::ClearCache()
+void WebEngine::RegisterJavaScriptConfirmCallback( Dali::WebEnginePlugin::JavaScriptConfirmCallback callback )
 {
+  Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptConfirmCallback( callback );
 }
 
-void WebEngine::ClearCookies()
+void WebEngine::JavaScriptConfirmReply( bool confirmed )
 {
 }
 
-Dali::WebEnginePlugin::CacheModel WebEngine::GetCacheModel() const
+void WebEngine::RegisterJavaScriptPromptCallback( Dali::WebEnginePlugin::JavaScriptPromptCallback callback )
 {
-  return Internal::Adaptor::GetImplementation( *this ).GetCacheModel();
+  Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptPromptCallback( callback );
 }
 
-void WebEngine::SetCacheModel( Dali::WebEnginePlugin::CacheModel cacheModel )
+void WebEngine::JavaScriptPromptReply( const std::string& result )
 {
-  Internal::Adaptor::GetImplementation( *this ).SetCacheModel( cacheModel );
 }
 
-Dali::WebEnginePlugin::CookieAcceptPolicy WebEngine::GetCookieAcceptPolicy() const
+void WebEngine::ClearAllTilesResources()
 {
-  return Internal::Adaptor::GetImplementation( *this ).GetCookieAcceptPolicy();
 }
 
-void WebEngine::SetCookieAcceptPolicy( Dali::WebEnginePlugin::CookieAcceptPolicy policy )
+void WebEngine::ClearHistory()
 {
-  Internal::Adaptor::GetImplementation( *this ).SetCookieAcceptPolicy( policy );
+  Internal::Adaptor::GetImplementation( *this ).ClearHistory();
 }
 
 const std::string& WebEngine::GetUserAgent() const
@@ -482,61 +1043,72 @@ void WebEngine::SetUserAgent( const std::string& userAgent )
   Internal::Adaptor::GetImplementation( *this ).SetUserAgent( userAgent );
 }
 
-bool WebEngine::IsJavaScriptEnabled() const
+void WebEngine::ScrollBy( int dx, int dy )
 {
-  return Internal::Adaptor::GetImplementation( *this ).IsJavaScriptEnabled();
+  Internal::Adaptor::GetImplementation( *this ).ScrollBy( dx, dy );
 }
 
-void WebEngine::EnableJavaScript( bool enabled )
+void WebEngine::SetScrollPosition( int x, int y )
 {
-  Internal::Adaptor::GetImplementation( *this ).EnableJavaScript( enabled );
+  Internal::Adaptor::GetImplementation( *this ).SetScrollPosition( x, y );
 }
 
-bool WebEngine::AreImagesAutomaticallyLoaded() const
+Dali::Vector2 WebEngine::GetScrollPosition() const
 {
-  return Internal::Adaptor::GetImplementation( *this ).AreImagesAutomaticallyLoaded();
+  return Internal::Adaptor::GetImplementation( *this ).GetScrollPosition();
 }
 
-void WebEngine::LoadImagesAutomatically( bool automatic )
+Dali::Vector2 WebEngine::GetScrollSize() const
 {
-  Internal::Adaptor::GetImplementation( *this ).LoadImagesAutomatically( automatic );
+  return Internal::Adaptor::GetImplementation( *this ).GetScrollSize();
 }
 
-const std::string& WebEngine::GetDefaultTextEncodingName() const
+Dali::Vector2 WebEngine::GetContentSize() const
 {
-  return Internal::Adaptor::GetImplementation( *this ).GetDefaultTextEncodingName();
+  return Internal::Adaptor::GetImplementation( *this ).GetContentSize();
 }
 
-void WebEngine::SetDefaultTextEncodingName( const std::string& defaultTextEncodingName )
+void WebEngine::SetSize( int width, int height )
 {
-  Internal::Adaptor::GetImplementation( *this ).SetDefaultTextEncodingName( defaultTextEncodingName );
 }
 
-int WebEngine::GetDefaultFontSize() const
+bool WebEngine::SendTouchEvent( const TouchEvent& touch )
 {
-  return Internal::Adaptor::GetImplementation( *this ).GetDefaultFontSize();
+  return true;
 }
 
-void WebEngine::SetDefaultFontSize( int defaultFontSize )
+bool WebEngine::SendKeyEvent( const KeyEvent& event )
 {
-  Internal::Adaptor::GetImplementation( *this ).SetDefaultFontSize( defaultFontSize );
+  return true;
 }
 
-void WebEngine::SetSize( int width, int height )
+bool WebEngine::SendHoverEvent( const HoverEvent& event )
 {
+  return true;
 }
 
-bool WebEngine::SendTouchEvent( const TouchEvent& touch )
+bool WebEngine::SendWheelEvent( const WheelEvent& event )
 {
   return true;
 }
 
-bool WebEngine::SendKeyEvent( const KeyEvent& event )
+void WebEngine::SetFocus( bool focused )
 {
-  return true;
 }
 
-void WebEngine::SetFocus( bool focused )
+void WebEngine::UpdateDisplayArea( Dali::Rect< int > displayArea )
+{
+}
+
+void WebEngine::EnableVideoHole( bool enabled )
+{
+}
+
+void WebEngine::EnableMouseEvents( bool enabled )
+{
+}
+
+void WebEngine::EnableKeyEvents( bool enabled )
 {
 }
 
@@ -545,6 +1117,11 @@ Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadStartedSi
   return Internal::Adaptor::GetImplementation( *this ).PageLoadStartedSignal();
 }
 
+Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadInProgressSignal()
+{
+  return Internal::Adaptor::GetImplementation( *this ).PageLoadInProgressSignal();
+}
+
 Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadFinishedSignal()
 {
   return Internal::Adaptor::GetImplementation( *this ).PageLoadFinishedSignal();
@@ -555,5 +1132,15 @@ Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& WebEngine::PageLoadErro
   return Internal::Adaptor::GetImplementation( *this ).PageLoadErrorSignal();
 }
 
+Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType& WebEngine::ScrollEdgeReachedSignal()
+{
+  return Internal::Adaptor::GetImplementation( *this ).ScrollEdgeReachedSignal();
+}
+
+Dali::WebEnginePlugin::WebEngineUrlChangedSignalType& WebEngine::UrlChangedSignal()
+{
+  return Internal::Adaptor::GetImplementation( *this ).UrlChangedSignal();
+}
+
 } // namespace Dali;