automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-web-engine.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include "toolkit-timer.h"
  19
  20 #include <dali/devel-api/adaptor-framework/web-engine.h>
  21 #include <dali/devel-api/adaptor-framework/web-engine-back-forward-list.h>
  22 #include <dali/devel-api/adaptor-framework/web-engine-back-forward-list-item.h>
  23 #include <dali/devel-api/adaptor-framework/web-engine-console-message.h>
  24 #include <dali/devel-api/adaptor-framework/web-engine-context.h>
  25 #include <dali/devel-api/adaptor-framework/web-engine-cookie-manager.h>
  26 #include <dali/devel-api/adaptor-framework/web-engine-form-repost-decision.h>
  27 #include <dali/devel-api/adaptor-framework/web-engine-request-interceptor.h>
  28 #include <dali/devel-api/adaptor-framework/web-engine-load-error.h>
  29 #include <dali/devel-api/adaptor-framework/web-engine-settings.h>
  30 #include <dali/public-api/adaptor-framework/native-image-source.h>
  31 #include <dali/public-api/images/pixel-data.h>
  32 #include <dali/public-api/object/any.h>
  33 #include <dali/public-api/object/base-object.h>
  34 #include <memory>
  35 #include <string.h>
  36 #include <toolkit-application.h>
  37
  38 namespace Dali
  39 {
  40
  41 namespace Internal
  42 {
  43
  44 namespace Adaptor
  45 {
  46
  47 class WebEngine;
  48
  49 namespace
  50 {
  51
  52 // Generally only one WebEngine instance exists.
  53 // If > 1, a new web engine has been created by CreateWindowSignal.
  54 static WebEngine* gInstance = 0;
  55 static int gInstanceCount = 0;
  56
  57 bool OnGoBack();
  58 bool OnGoForward();
  59 bool OnLoadUrl();
  60 bool OnEvaluteJavaScript();
  61 bool OnJavaScriptAlert();
  62 bool OnJavaScriptConfirm();
  63 bool OnJavaScriptPrompt();
  64 bool OnScrollEdge();
  65 bool OnScreenshotCaptured();
  66 bool OnVideoPlaying();
  67 bool OnGeolocationPermission();
  68 bool OnClearHistory();
  69
  70 static void ConnectToGlobalSignal( bool ( *func )() )
  71 {
  72   Dali::Timer timer = Dali::Timer::New( 0 );
  73   timer.TickSignal().Connect( func );
  74 }
  75
  76 static void DisconnectFromGlobalSignal( bool ( *func )() )
  77 {
  78   Dali::Timer timer = Dali::Timer::New( 0 );
  79   timer.TickSignal().Disconnect( func );
  80 }
  81 } // namespace anonymous
  82
  83 class MockWebEngineContext : public Dali::WebEngineContext
  84 {
  85 public:
  86   MockWebEngineContext()
  87     : mockModel( Dali::WebEngineContext::CacheModel::DOCUMENT_VIEWER )
  88   {
  89   }
  90
  91   Dali::WebEngineContext::CacheModel GetCacheModel() const override
  92   {
  93     return mockModel;
  94   }
  95
  96   void SetCacheModel( Dali::WebEngineContext::CacheModel cacheModel ) override
  97   {
  98     mockModel = cacheModel;
  99   }
 100
 101   void SetProxyUri( const std::string& uri ) override
 102   {
 103   }
 104
 105   void SetDefaultProxyAuth( const std::string& username, const std::string& password ) override
 106   {
 107   }
 108
 109   void SetCertificateFilePath( const std::string& certificatePath ) override
 110   {
 111   }
 112
 113   void DeleteWebDatabase() override
 114   {
 115   }
 116
 117   void DeleteWebStorage() override
 118   {
 119   }
 120
 121   void DeleteLocalFileSystem() override
 122   {
 123   }
 124
 125   void DisableCache( bool cacheDisabled ) override
 126   {
 127   }
 128
 129   void ClearCache() override
 130   {
 131   }
 132
 133 private:
 134   Dali::WebEngineContext::CacheModel mockModel;
 135 };
 136
 137 class MockWebEngineCookieManager : public Dali::WebEngineCookieManager
 138 {
 139 public:
 140   MockWebEngineCookieManager()
 141     : mockCookieAcceptPolicy( Dali::WebEngineCookieManager::CookieAcceptPolicy::NO_THIRD_PARTY )
 142   {
 143   }
 144
 145   void SetCookieAcceptPolicy( Dali::WebEngineCookieManager::CookieAcceptPolicy policy ) override
 146   {
 147     mockCookieAcceptPolicy = policy;
 148   }
 149
 150   Dali::WebEngineCookieManager::CookieAcceptPolicy GetCookieAcceptPolicy() const override
 151   {
 152     return mockCookieAcceptPolicy;
 153   }
 154
 155   void ClearCookies() override
 156   {
 157   }
 158
 159   void SetPersistentStorage( const std::string& path, Dali::WebEngineCookieManager::CookiePersistentStorage storage ) override
 160   {
 161   }
 162
 163 private:
 164   Dali::WebEngineCookieManager::CookieAcceptPolicy mockCookieAcceptPolicy;
 165 };
 166
 167 class MockWebEngineBackForwardListItem : public Dali::WebEngineBackForwardListItem
 168 {
 169 public:
 170   MockWebEngineBackForwardListItem()
 171     : mockUrl( "http://url" ),
 172       mockTitle( "title" ),
 173       mockOriginalUrl( "http://originalurl" )
 174   {
 175   }
 176
 177   std::string GetUrl() const override
 178   {
 179     return mockUrl;
 180   }
 181
 182   std::string GetTitle() const override
 183   {
 184     return mockTitle;
 185   }
 186
 187   std::string GetOriginalUrl() const override
 188   {
 189     return mockOriginalUrl;
 190   }
 191
 192 private:
 193   std::string mockUrl;
 194   std::string mockTitle;
 195   std::string mockOriginalUrl;
 196 };
 197
 198 class MockWebEngineBackForwardList : public Dali::WebEngineBackForwardList
 199 {
 200 public:
 201   MockWebEngineBackForwardList()
 202     : mockItem(),
 203       pMockItem( &mockItem )
 204   {
 205   }
 206
 207   Dali::WebEngineBackForwardListItem& GetCurrentItem() const override
 208   {
 209     return *pMockItem;
 210   }
 211
 212   Dali::WebEngineBackForwardListItem& GetItemAtIndex( uint32_t index ) const override
 213   {
 214     return *pMockItem;
 215   }
 216
 217   uint32_t GetItemCount() const override
 218   {
 219     return 1;
 220   }
 221
 222 private:
 223   MockWebEngineBackForwardListItem mockItem;
 224   WebEngineBackForwardListItem* pMockItem;
 225 };
 226
 227 class MockWebEngineFormRepostDecision : public WebEngineFormRepostDecision
 228 {
 229 public:
 230   MockWebEngineFormRepostDecision()
 231   {
 232   }
 233
 234   void Reply(bool allowed) override {}
 235 };
 236
 237 class MockWebEngineRequestInterceptor : public WebEngineRequestInterceptor
 238 {
 239 public:
 240   MockWebEngineRequestInterceptor()
 241   {
 242   }
 243
 244   std::string GetUrl() const override
 245   {
 246     return "http://test.html";
 247   }
 248
 249   bool Ignore() override
 250   {
 251     return true;
 252   }
 253
 254   bool SetResponseStatus(int statusCode, const std::string &customedStatusText) override
 255   {
 256     return true;
 257   }
 258
 259   bool AddResponseHeader(const std::string &fieldName, const std::string &fieldValue) override
 260   {
 261     return true;
 262   }
 263
 264   bool AddResponseBody(const std::string &body, uint32_t length) override
 265   {
 266     return true;
 267   }
 268 };
 269
 270 class MockWebEngineConsoleMessage : public Dali::WebEngineConsoleMessage
 271 {
 272 public:
 273   MockWebEngineConsoleMessage()
 274   {
 275   }
 276
 277   std::string GetSource() const override
 278   {
 279     return "source";
 280   }
 281
 282   uint32_t GetLine() const override
 283   {
 284     return 10;
 285   }
 286
 287   SeverityLevel GetSeverityLevel() const override
 288   {
 289     return SeverityLevel::EMPTY;
 290   }
 291
 292   std::string GetText() const override
 293   {
 294     return "This is a text.";
 295   }
 296 };
 297
 298 class MockWebEngineLoadError : public Dali::WebEngineLoadError
 299 {
 300 public:
 301   MockWebEngineLoadError(const std::string& url)
 302     : mockUrl(url)
 303   {
 304   }
 305
 306   std::string GetUrl() const override
 307   {
 308     return mockUrl;
 309   }
 310
 311   ErrorCode GetCode() const override
 312   {
 313     return ErrorCode::UNKNOWN;
 314   }
 315
 316   std::string GetDescription() const override
 317   {
 318     return "This is an error.";
 319   }
 320
 321   ErrorType GetType() const override
 322   {
 323     return ErrorType::NONE;
 324   }
 325
 326 private:
 327   std::string mockUrl;
 328 };
 329
 330 class MockWebEngineSettings : public WebEngineSettings
 331 {
 332 public:
 333   MockWebEngineSettings()
 334     : mockDefaultFontSize( 16 ),
 335       mockJavaScriptEnabled( true ),
 336       mockAutoFittingEnabled ( true ),
 337       mockPluginsEnabled ( true ),
 338       mockPrivateBrowsingEnabled( true ),
 339       mockLinkMagnifierEnabled( true ),
 340       mockKeypadWithoutUserActionUsed( true ),
 341       mockAutofillPasswordFormEnabled( true ),
 342       mockFormCandidateDataEnabled( true ),
 343       mockTextSelectionEnabled( true ),
 344       mockTextAutosizingEnable( true ),
 345       mockArrowScrollEnable( true ),
 346       mockClipboardEnabled( true ),
 347       mockImePanelEnabled( true ),
 348       mockImageLoadedAutomatically( true ),
 349       mockDefaultTextEncodingName()
 350   {
 351   }
 352
 353   uint32_t GetDefaultFontSize() const override
 354   {
 355     return mockDefaultFontSize;
 356   }
 357
 358   void SetDefaultFontSize( uint32_t size ) override
 359   {
 360     mockDefaultFontSize = size;
 361   }
 362
 363   bool IsJavaScriptEnabled() const override
 364   {
 365     return mockJavaScriptEnabled;
 366   }
 367
 368   void EnableJavaScript( bool enabled ) override
 369   {
 370     mockJavaScriptEnabled = enabled;
 371   }
 372
 373   bool IsAutoFittingEnabled() const override
 374   {
 375     return mockAutoFittingEnabled;
 376   }
 377
 378   void EnableAutoFitting( bool enabled ) override
 379   {
 380     mockAutoFittingEnabled = enabled;
 381   }
 382
 383   bool ArePluginsEnabled() const override
 384   {
 385     return mockPluginsEnabled;
 386   }
 387
 388   void EnablePlugins( bool enabled ) override
 389   {
 390     mockPluginsEnabled = enabled;
 391   }
 392
 393   bool IsPrivateBrowsingEnabled() const override
 394   {
 395     return mockPrivateBrowsingEnabled;
 396   }
 397
 398   void EnablePrivateBrowsing( bool enabled ) override
 399   {
 400     mockPrivateBrowsingEnabled = enabled;
 401   }
 402
 403   bool IsLinkMagnifierEnabled() const override
 404   {
 405     return mockLinkMagnifierEnabled;
 406   }
 407
 408   void EnableLinkMagnifier( bool enabled ) override
 409   {
 410     mockLinkMagnifierEnabled = enabled;
 411   }
 412
 413   bool IsKeypadWithoutUserActionUsed() const override
 414   {
 415     return mockKeypadWithoutUserActionUsed;
 416   }
 417
 418   void UseKeypadWithoutUserAction( bool used ) override
 419   {
 420     mockKeypadWithoutUserActionUsed = used;
 421   }
 422
 423   bool IsAutofillPasswordFormEnabled() const override
 424   {
 425     return mockAutofillPasswordFormEnabled;
 426   }
 427
 428   void EnableAutofillPasswordForm( bool enabled ) override
 429   {
 430     mockAutofillPasswordFormEnabled = enabled;
 431   }
 432
 433   bool IsFormCandidateDataEnabled() const override
 434   {
 435     return mockFormCandidateDataEnabled;
 436   }
 437
 438   void EnableFormCandidateData( bool enabled ) override
 439   {
 440     mockFormCandidateDataEnabled = enabled;
 441   }
 442
 443   bool IsTextSelectionEnabled() const override
 444   {
 445     return mockTextSelectionEnabled;
 446   }
 447
 448   void EnableTextSelection( bool enabled ) override
 449   {
 450     mockTextSelectionEnabled = enabled;
 451   }
 452
 453   bool IsTextAutosizingEnabled() const override
 454   {
 455     return mockTextAutosizingEnable;
 456   }
 457
 458   void EnableTextAutosizing( bool enabled ) override
 459   {
 460     mockTextAutosizingEnable = enabled;
 461   }
 462
 463   bool IsArrowScrollEnabled() const override
 464   {
 465     return mockArrowScrollEnable;
 466   }
 467
 468   void EnableArrowScroll( bool enabled ) override
 469   {
 470     mockArrowScrollEnable = enabled;
 471   }
 472
 473   bool IsClipboardEnabled() const override
 474   {
 475     return mockClipboardEnabled;
 476   }
 477
 478   void EnableClipboard( bool enabled ) override
 479   {
 480     mockClipboardEnabled = enabled;
 481   }
 482
 483   bool IsImePanelEnabled() const override
 484   {
 485     return mockImePanelEnabled;
 486   }
 487
 488   void EnableImePanel( bool enabled ) override
 489   {
 490     mockImePanelEnabled = enabled;
 491   }
 492
 493   bool AreImagesLoadedAutomatically() const override
 494   {
 495     return mockImageLoadedAutomatically;
 496   }
 497
 498   void AllowImagesLoadAutomatically( bool automatic ) override
 499   {
 500     mockImageLoadedAutomatically = automatic;
 501   }
 502
 503   std::string GetDefaultTextEncodingName() const override
 504   {
 505     return mockDefaultTextEncodingName;
 506   }
 507
 508   void SetDefaultTextEncodingName( const std::string& defaultTextEncodingName ) override
 509   {
 510     mockDefaultTextEncodingName = defaultTextEncodingName;
 511   }
 512
 513   void AllowMixedContents( bool allowed ) override
 514   {
 515   }
 516
 517   void EnableSpatialNavigation( bool enabled ) override
 518   {
 519   }
 520
 521   void EnableWebSecurity( bool enabled ) override
 522   {
 523   }
 524
 525   void EnableCacheBuilder( bool enabled ) override
 526   {
 527   }
 528
 529   void UseScrollbarThumbFocusNotifications( bool used ) override
 530   {
 531   }
 532
 533   void EnableDoNotTrack( bool enabled ) override
 534   {
 535   }
 536
 537   void AllowFileAccessFromExternalUrl( bool allowed ) override
 538   {
 539   }
 540
 541   void AllowScriptsOpenWindows( bool allowed ) override
 542   {
 543   }
 544
 545 private:
 546   int mockDefaultFontSize;
 547   bool mockJavaScriptEnabled;
 548   bool mockAutoFittingEnabled;
 549   bool mockPluginsEnabled;
 550   bool mockPrivateBrowsingEnabled;
 551   bool mockLinkMagnifierEnabled;
 552   bool mockKeypadWithoutUserActionUsed;
 553   bool mockAutofillPasswordFormEnabled;
 554   bool mockFormCandidateDataEnabled;
 555   bool mockTextSelectionEnabled;
 556   bool mockTextAutosizingEnable;
 557   bool mockArrowScrollEnable;
 558   bool mockClipboardEnabled;
 559   bool mockImePanelEnabled;
 560   bool mockImageLoadedAutomatically;
 561   std::string mockDefaultTextEncodingName;
 562 };
 563
 564 class WebEngine: public Dali::BaseObject
 565 {
 566 public:
 567
 568   using JavaScriptEvaluatedResultCallback = std::function<void(const std::string&)>;
 569
 570   WebEngine()
 571     : mUrl()
 572     , mCurrentPlusOnePos( 0 )
 573     , mUserAgent()
 574     , mEvaluating( false )
 575     , mScrollPosition( 0, 0 )
 576     , mScrollSize( 500, 500 )
 577     , mContentSize( 500, 500 )
 578   {
 579     gInstanceCount++;
 580     if ( gInstanceCount == 1 ) // only first web engine need be saved.
 581     {
 582       gInstance = this;
 583     }
 584
 585     mockWebEngineSettings = new MockWebEngineSettings();
 586     mockWebEngineContext = new MockWebEngineContext();
 587     mockWebEngineCookieManager = new MockWebEngineCookieManager();
 588     mockWebEngineBackForwardList = new MockWebEngineBackForwardList();
 589   }
 590
 591   virtual ~WebEngine()
 592   {
 593     gInstanceCount--;
 594     if( !gInstanceCount )
 595     {
 596       gInstance = 0;
 597     }
 598
 599     delete mockWebEngineSettings;
 600     delete mockWebEngineContext;
 601     delete mockWebEngineCookieManager;
 602     delete mockWebEngineBackForwardList;
 603   }
 604
 605   Dali::WebEngineSettings& GetSettings() const
 606   {
 607     return *mockWebEngineSettings;
 608   }
 609
 610   Dali::WebEngineContext& GetContext() const
 611   {
 612     return *mockWebEngineContext;
 613   }
 614
 615   Dali::WebEngineCookieManager& GetCookieManager() const
 616   {
 617     return *mockWebEngineCookieManager;
 618   }
 619
 620   Dali::WebEngineBackForwardList& GetBackForwardList() const
 621   {
 622     return *mockWebEngineBackForwardList;
 623   }
 624
 625   void LoadUrl( const std::string& url )
 626   {
 627     mUrl = url;
 628     ConnectToGlobalSignal( &OnLoadUrl );
 629   }
 630
 631   const std::string& GetUrl() const
 632   {
 633     return mUrl;
 634   }
 635
 636   std::string GetTitle() const
 637   {
 638     return std::string("title");
 639   }
 640
 641   Dali::PixelData GetFavicon() const
 642   {
 643     uint8_t* faviconData = new uint8_t[ 16 ];
 644
 645     faviconData[ 0 ] = 0xff;
 646     faviconData[ 1 ] = 0x00;
 647     faviconData[ 2 ] = 0x00;
 648     faviconData[ 3 ] = 0xff;
 649     faviconData[ 4 ] = 0xff;
 650     faviconData[ 5 ] = 0x00;
 651     faviconData[ 6 ] = 0x00;
 652     faviconData[ 7 ] = 0xff;
 653     faviconData[ 8 ] = 0xff;
 654     faviconData[ 9 ] = 0x00;
 655     faviconData[ 10 ] = 0x00;
 656     faviconData[ 11 ] = 0xff;
 657     faviconData[ 12 ] = 0xff;
 658     faviconData[ 13 ] = 0x00;
 659     faviconData[ 14 ] = 0x00;
 660     faviconData[ 15 ] = 0xff;
 661
 662     return Dali::PixelData::New( faviconData, 16, 2, 2,
 663                                  Dali::Pixel::Format::RGBA8888,
 664                                  Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
 665   }
 666
 667   bool CanGoForward() const
 668   {
 669     return mHistory.size() > mCurrentPlusOnePos;
 670   }
 671
 672   void GoForward()
 673   {
 674     ConnectToGlobalSignal( &OnGoForward );
 675   }
 676
 677   bool CanGoBack() const
 678   {
 679     return mCurrentPlusOnePos > 1;
 680   }
 681
 682   void GoBack()
 683   {
 684     ConnectToGlobalSignal( &OnGoBack );
 685   }
 686
 687   void EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler )
 688   {
 689     if( resultHandler )
 690     {
 691       if( !mEvaluating )
 692       {
 693         ConnectToGlobalSignal( &OnEvaluteJavaScript );
 694       }
 695       mResultCallbacks.push_back( resultHandler );
 696     }
 697   }
 698
 699   void RegisterJavaScriptAlertCallback( Dali::WebEnginePlugin::JavaScriptAlertCallback callback )
 700   {
 701     if ( callback )
 702     {
 703       ConnectToGlobalSignal( &OnJavaScriptAlert );
 704       mJavaScriptAlertCallback = callback;
 705     }
 706   }
 707
 708   void RegisterJavaScriptConfirmCallback( Dali::WebEnginePlugin::JavaScriptConfirmCallback callback )
 709   {
 710     if ( callback )
 711     {
 712       ConnectToGlobalSignal( &OnJavaScriptConfirm );
 713       mJavaScriptConfirmCallback = callback;
 714     }
 715   }
 716
 717   void RegisterJavaScriptPromptCallback( Dali::WebEnginePlugin::JavaScriptPromptCallback callback )
 718   {
 719     if ( callback )
 720     {
 721       ConnectToGlobalSignal( &OnJavaScriptPrompt );
 722       mJavaScriptPromptCallback = callback;
 723     }
 724   }
 725
 726   void ClearHistory()
 727   {
 728     ConnectToGlobalSignal( &OnClearHistory );
 729   }
 730
 731   const std::string& GetUserAgent() const
 732   {
 733     return mUserAgent;
 734   }
 735
 736   void SetUserAgent( const std::string& userAgent )
 737   {
 738     mUserAgent = userAgent;
 739   }
 740
 741   void ScrollBy( int dx, int dy )
 742   {
 743     mScrollPosition += Dali::Vector2( dx, dy );
 744     if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
 745     {
 746       ConnectToGlobalSignal( &OnScrollEdge );
 747     }
 748   }
 749
 750   bool ScrollEdgeBy( int dx, int dy )
 751   {
 752     mScrollPosition += Dali::Vector2( dx, dy );
 753     if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
 754     {
 755       ConnectToGlobalSignal( &OnScrollEdge );
 756     }
 757     return true;
 758   }
 759
 760   void SetScrollPosition( int x, int y )
 761   {
 762     mScrollPosition.x = x;
 763     mScrollPosition.y = y;
 764   }
 765
 766   Dali::Vector2 GetScrollPosition() const
 767   {
 768     return mScrollPosition;
 769   }
 770
 771   Dali::Vector2 GetScrollSize() const
 772   {
 773     return mScrollSize;
 774   }
 775
 776   Dali::Vector2 GetContentSize() const
 777   {
 778     return mContentSize;
 779   }
 780
 781   void SetPageZoomFactor(float zoomFactor)
 782   {
 783     mPageZoomFactor = zoomFactor;
 784   }
 785
 786   float GetPageZoomFactor() const
 787   {
 788     return mPageZoomFactor;
 789   }
 790
 791   void SetTextZoomFactor(float zoomFactor)
 792   {
 793     mTextZoomFactor = zoomFactor;
 794   }
 795
 796   float GetTextZoomFactor() const
 797   {
 798     return mTextZoomFactor;
 799   }
 800
 801   float GetLoadProgressPercentage() const
 802   {
 803     return 0.5f;
 804   }
 805
 806   void SetScaleFactor(float scaleFactor, Dali::Vector2 point)
 807   {
 808     mScaleFactor = scaleFactor;
 809   }
 810
 811   float GetScaleFactor() const
 812   {
 813     return mScaleFactor;
 814   }
 815
 816   Dali::PixelData GetScreenshot(Dali::Rect<int> viewArea, float scaleFactor)
 817   {
 818     uint32_t bufferSize = viewArea.width * viewArea.height * 4 ;
 819     uint8_t* pixel = new uint8_t[ bufferSize ];
 820     memset(pixel, 0xff, bufferSize);
 821     return Dali::PixelData::New( pixel, bufferSize, viewArea.width, viewArea.height,
 822                                  Dali::Pixel::Format::RGBA8888,
 823                                  Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
 824   }
 825
 826   bool GetScreenshotAsynchronously(Dali::Rect<int> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
 827   {
 828     if ( callback )
 829     {
 830       ConnectToGlobalSignal( &OnScreenshotCaptured );
 831       mScreenshotCapturedCallback = callback;
 832     }
 833     return true;
 834   }
 835
 836   bool CheckVideoPlayingAsynchronously(Dali::WebEnginePlugin::VideoPlayingCallback callback)
 837   {
 838     if ( callback )
 839     {
 840       ConnectToGlobalSignal( &OnVideoPlaying );
 841       mVideoPlayingCallback = callback;
 842     }
 843     return true;
 844   }
 845
 846   void RegisterGeolocationPermissionCallback(Dali::WebEnginePlugin::GeolocationPermissionCallback callback)
 847   {
 848     if ( callback )
 849     {
 850       ConnectToGlobalSignal( &OnGeolocationPermission );
 851       mGeolocationPermissionCallback = callback;
 852     }
 853   }
 854
 855   Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadStartedSignal()
 856   {
 857     return mPageLoadStartedSignal;
 858   }
 859
 860   Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadInProgressSignal()
 861   {
 862     return mPageLoadInProgressSignal;
 863   }
 864
 865   Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadFinishedSignal()
 866   {
 867     return mPageLoadFinishedSignal;
 868   }
 869
 870   Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& PageLoadErrorSignal()
 871   {
 872     return mPageLoadErrorSignal;
 873   }
 874
 875   Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType& ScrollEdgeReachedSignal()
 876   {
 877     return mScrollEdgeReachedSignal;
 878   }
 879
 880   Dali::WebEnginePlugin::WebEngineUrlChangedSignalType& UrlChangedSignal()
 881   {
 882     return mUrlChangedSignal;
 883   }
 884
 885   Dali::WebEnginePlugin::WebEngineFormRepostDecisionSignalType& FormRepostDecisionSignal()
 886   {
 887     return mFormRepostDecisionSignal;
 888   }
 889
 890   Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& FrameRenderedSignal()
 891   {
 892     return mFrameRenderedSignal;
 893   }
 894
 895   Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType& RequestInterceptorSignal()
 896   {
 897     return mRequestInterceptorSignal;
 898   }
 899
 900   Dali::WebEnginePlugin::WebEngineConsoleMessageSignalType& ConsoleMessageSignal()
 901   {
 902     return mConsoleMessageSignal;
 903   }
 904
 905   std::string              mUrl;
 906   std::vector<std::string> mHistory;
 907   size_t                   mCurrentPlusOnePos;
 908   std::string              mUserAgent;
 909
 910   Dali::WebEnginePlugin::WebEnginePageLoadSignalType           mPageLoadStartedSignal;
 911   Dali::WebEnginePlugin::WebEnginePageLoadSignalType           mPageLoadInProgressSignal;
 912   Dali::WebEnginePlugin::WebEnginePageLoadSignalType           mPageLoadFinishedSignal;
 913   Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType      mPageLoadErrorSignal;
 914   Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType  mScrollEdgeReachedSignal;
 915   Dali::WebEnginePlugin::WebEngineUrlChangedSignalType         mUrlChangedSignal;
 916   Dali::WebEnginePlugin::WebEngineFormRepostDecisionSignalType mFormRepostDecisionSignal;
 917   Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType      mFrameRenderedSignal;
 918   Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType mRequestInterceptorSignal;
 919   Dali::WebEnginePlugin::WebEngineConsoleMessageSignalType     mConsoleMessageSignal;
 920
 921   bool  mEvaluating;
 922   float mPageZoomFactor;
 923   float mTextZoomFactor;
 924   float mScaleFactor;
 925
 926   Dali::Vector2             mScrollPosition;
 927   Dali::Vector2             mScrollSize;
 928   Dali::Vector2             mContentSize;
 929   WebEngineBackForwardList* mockWebEngineBackForwardList;
 930   WebEngineContext*         mockWebEngineContext;
 931   WebEngineCookieManager*   mockWebEngineCookieManager;
 932   WebEngineSettings*        mockWebEngineSettings;
 933
 934   std::vector<JavaScriptEvaluatedResultCallback>       mResultCallbacks;
 935   Dali::WebEnginePlugin::JavaScriptAlertCallback       mJavaScriptAlertCallback;
 936   Dali::WebEnginePlugin::JavaScriptConfirmCallback     mJavaScriptConfirmCallback;
 937   Dali::WebEnginePlugin::JavaScriptPromptCallback      mJavaScriptPromptCallback;
 938   Dali::WebEnginePlugin::ScreenshotCapturedCallback    mScreenshotCapturedCallback;
 939   Dali::WebEnginePlugin::VideoPlayingCallback          mVideoPlayingCallback;
 940   Dali::WebEnginePlugin::GeolocationPermissionCallback mGeolocationPermissionCallback;
 941 };
 942
 943
 944 namespace
 945 {
 946
 947 bool OnGoBack()
 948 {
 949   DisconnectFromGlobalSignal( &OnGoBack );
 950
 951   if( gInstance && gInstance->CanGoBack() )
 952   {
 953     gInstance->mCurrentPlusOnePos--;
 954   }
 955   return false;
 956 }
 957
 958 bool OnGoForward()
 959 {
 960   DisconnectFromGlobalSignal( &OnGoForward );
 961
 962   if( gInstance && gInstance->CanGoForward() )
 963   {
 964     gInstance->mCurrentPlusOnePos++;
 965   }
 966   return false;
 967 }
 968
 969 bool OnLoadUrl()
 970 {
 971   DisconnectFromGlobalSignal( &OnLoadUrl );
 972
 973   if( gInstance )
 974   {
 975     if( gInstance->mHistory.size() > gInstance->mCurrentPlusOnePos )
 976     {
 977       gInstance->mHistory.erase( gInstance->mHistory.begin() + gInstance->mCurrentPlusOnePos, gInstance->mHistory.end() );
 978     }
 979     gInstance->mHistory.push_back( gInstance->mUrl );
 980     gInstance->mCurrentPlusOnePos++;
 981     gInstance->mPageLoadStartedSignal.Emit( gInstance->mUrl );
 982     gInstance->mPageLoadInProgressSignal.Emit( gInstance->mUrl );
 983     gInstance->mPageLoadFinishedSignal.Emit( gInstance->mUrl );
 984     gInstance->mUrlChangedSignal.Emit( "http://new-test" );
 985
 986     std::shared_ptr<Dali::WebEngineFormRepostDecision> decision(new MockWebEngineFormRepostDecision());
 987     gInstance->mFormRepostDecisionSignal.Emit(std::move(decision));
 988     gInstance->mFrameRenderedSignal.Emit();
 989     std::shared_ptr<Dali::WebEngineRequestInterceptor> interceptor(new MockWebEngineRequestInterceptor());
 990     gInstance->mRequestInterceptorSignal.Emit(std::move(interceptor));
 991
 992     std::shared_ptr<Dali::WebEngineLoadError> error(new MockWebEngineLoadError(gInstance->mUrl));
 993     gInstance->mPageLoadErrorSignal.Emit(std::move(error));
 994     std::shared_ptr<Dali::WebEngineConsoleMessage> message(new MockWebEngineConsoleMessage());
 995     gInstance->mConsoleMessageSignal.Emit(std::move(message));
 996   }
 997   return false;
 998 }
 999
1000 bool OnScrollEdge()
1001 {
1002   DisconnectFromGlobalSignal( &OnScrollEdge );
1003
1004   if( gInstance )
1005   {
1006     gInstance->mScrollEdgeReachedSignal.Emit( Dali::WebEnginePlugin::ScrollEdge::BOTTOM );
1007   }
1008
1009   return false;
1010 }
1011
1012 bool OnEvaluteJavaScript()
1013 {
1014   DisconnectFromGlobalSignal( &OnEvaluteJavaScript );
1015
1016   if( gInstance )
1017   {
1018     for( auto& func : gInstance->mResultCallbacks )
1019     {
1020       func("undefined");
1021     }
1022     gInstance->mResultCallbacks.clear();
1023   }
1024   return false;
1025 }
1026
1027 bool OnJavaScriptAlert()
1028 {
1029   DisconnectFromGlobalSignal( &OnJavaScriptAlert );
1030   if ( gInstance )
1031   {
1032     gInstance->mJavaScriptAlertCallback( "this is an alert popup." );
1033   }
1034   return false;
1035 }
1036
1037 bool OnJavaScriptConfirm()
1038 {
1039   DisconnectFromGlobalSignal( &OnJavaScriptConfirm );
1040   if ( gInstance )
1041   {
1042     gInstance->mJavaScriptConfirmCallback( "this is a confirm popup." );
1043   }
1044   return false;
1045 }
1046
1047 bool OnJavaScriptPrompt()
1048 {
1049   DisconnectFromGlobalSignal( &OnJavaScriptPrompt );
1050   if ( gInstance )
1051   {
1052     gInstance->mJavaScriptPromptCallback( "this is a prompt pompt.", "" );
1053   }
1054   return false;
1055 }
1056
1057 bool OnScreenshotCaptured()
1058 {
1059   DisconnectFromGlobalSignal( &OnScreenshotCaptured );
1060   if ( gInstance )
1061   {
1062     uint8_t* pixel = new uint8_t[ 2 * 2 * 4 ];
1063     memset(pixel, 0xff, 2 * 2 * 4);
1064     Dali::PixelData data = Dali::PixelData::New( pixel, 2 * 2 * 4, 2, 2,
1065                                  Dali::Pixel::Format::RGBA8888,
1066                                  Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
1067     gInstance->mScreenshotCapturedCallback( data );
1068   }
1069   return false;
1070 }
1071
1072 bool OnVideoPlaying()
1073 {
1074   DisconnectFromGlobalSignal( &OnVideoPlaying );
1075   if ( gInstance )
1076   {
1077     gInstance->mVideoPlayingCallback( true );
1078   }
1079   return false;
1080 }
1081
1082 bool OnGeolocationPermission()
1083 {
1084   DisconnectFromGlobalSignal( &OnGeolocationPermission );
1085   if ( gInstance )
1086   {
1087     gInstance->mGeolocationPermissionCallback( "", "" );
1088   }
1089   return false;
1090 }
1091
1092 bool OnClearHistory()
1093 {
1094   DisconnectFromGlobalSignal( &OnClearHistory );
1095
1096   if( gInstance && gInstance->mCurrentPlusOnePos )
1097   {
1098     std::string url = gInstance->mHistory[ gInstance->mCurrentPlusOnePos - 1 ];
1099     std::vector< std::string >().swap( gInstance->mHistory );
1100     gInstance->mHistory.push_back( url );
1101     gInstance->mCurrentPlusOnePos = 1;
1102   }
1103   return false;
1104 }
1105
1106 } // namespace
1107
1108 inline WebEngine& GetImplementation( Dali::WebEngine& webEngine )
1109 {
1110   DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
1111   BaseObject& handle = webEngine.GetBaseObject();
1112   return static_cast< Internal::Adaptor::WebEngine& >( handle );
1113 }
1114
1115 inline const WebEngine& GetImplementation( const Dali::WebEngine& webEngine )
1116 {
1117   DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
1118   const BaseObject& handle = webEngine.GetBaseObject();
1119   return static_cast< const Internal::Adaptor::WebEngine& >( handle );
1120 }
1121
1122 } // namespace Adaptor
1123
1124 } // namespace Internal
1125
1126 // Dali::WebEngine Implementation
1127 WebEngine::WebEngine()
1128 {
1129 }
1130
1131 WebEngine::WebEngine( Internal::Adaptor::WebEngine* internal )
1132 : BaseHandle( internal )
1133 {
1134 }
1135
1136 WebEngine::~WebEngine()
1137 {
1138 }
1139
1140 WebEngine WebEngine::New()
1141 {
1142   Internal::Adaptor::WebEngine* baseObject = new Internal::Adaptor::WebEngine();
1143
1144   return WebEngine( baseObject );
1145 }
1146
1147 WebEngine::WebEngine( const WebEngine& WebEngine )
1148 : BaseHandle( WebEngine )
1149 {
1150 }
1151
1152 WebEngine& WebEngine::operator=( const WebEngine& webEngine )
1153 {
1154   BaseHandle::operator=( webEngine );
1155   return *this;
1156 }
1157
1158 WebEngine WebEngine::DownCast( BaseHandle handle )
1159 {
1160   return WebEngine( dynamic_cast< Internal::Adaptor::WebEngine* >( handle.GetObjectPtr() ) );
1161 }
1162
1163 void WebEngine::Create( int width, int height, const std::string& locale, const std::string& timezoneId )
1164 {
1165 }
1166
1167 void WebEngine::Create( int width, int height, int argc, char** argv )
1168 {
1169 }
1170
1171 void WebEngine::Destroy()
1172 {
1173 }
1174
1175 WebEngineSettings& WebEngine::GetSettings() const
1176 {
1177   return Internal::Adaptor::GetImplementation( *this ).GetSettings();
1178 }
1179
1180 WebEngineContext& WebEngine::GetContext() const
1181 {
1182   return Internal::Adaptor::GetImplementation( *this ).GetContext();
1183 }
1184
1185 WebEngineCookieManager& WebEngine::GetCookieManager() const
1186 {
1187   return Internal::Adaptor::GetImplementation( *this ).GetCookieManager();
1188 }
1189
1190 WebEngineBackForwardList& WebEngine::GetBackForwardList() const
1191 {
1192   return Internal::Adaptor::GetImplementation( *this ).GetBackForwardList();
1193 }
1194
1195 void WebEngine::LoadUrl( const std::string& url )
1196 {
1197   return Internal::Adaptor::GetImplementation( *this ).LoadUrl( url );
1198 }
1199
1200 std::string WebEngine::GetTitle() const
1201 {
1202   return Internal::Adaptor::GetImplementation( *this ).GetTitle();
1203 }
1204
1205 Dali::PixelData WebEngine::GetFavicon() const
1206 {
1207   return Internal::Adaptor::GetImplementation( *this ).GetFavicon();
1208 }
1209
1210 const std::string& WebEngine::GetUrl()
1211 {
1212   return Internal::Adaptor::GetImplementation( *this ).GetUrl();
1213 }
1214
1215 NativeImageInterfacePtr WebEngine::GetNativeImageSource()
1216 {
1217   Any source;
1218   Dali::NativeImageSourcePtr sourcePtr = Dali::NativeImageSource::New( source );
1219   return sourcePtr;
1220 }
1221
1222 void WebEngine::LoadHtmlString( const std::string& htmlString )
1223 {
1224 }
1225
1226 bool WebEngine::LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl)
1227 {
1228   return true;
1229 }
1230
1231 bool WebEngine::LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri)
1232 {
1233   return true;
1234 }
1235
1236 void WebEngine::Reload()
1237 {
1238 }
1239
1240 bool WebEngine::ReloadWithoutCache()
1241 {
1242   return true;
1243 }
1244
1245 void WebEngine::StopLoading()
1246 {
1247 }
1248
1249 void WebEngine::Suspend()
1250 {
1251 }
1252
1253 void WebEngine::Resume()
1254 {
1255 }
1256
1257 void WebEngine::SuspendNetworkLoading()
1258 {
1259 }
1260
1261 void WebEngine::ResumeNetworkLoading()
1262 {
1263 }
1264
1265 bool WebEngine::AddCustomHeader(const std::string& name, const std::string& value)
1266 {
1267   return true;
1268 }
1269
1270 bool WebEngine::RemoveCustomHeader(const std::string& name)
1271 {
1272   return true;
1273 }
1274
1275 uint32_t WebEngine::StartInspectorServer(uint32_t port)
1276 {
1277   return port;
1278 }
1279
1280 bool WebEngine::StopInspectorServer()
1281 {
1282   return true;
1283 }
1284
1285 bool WebEngine::CanGoForward()
1286 {
1287   return Internal::Adaptor::GetImplementation( *this ).CanGoForward();
1288 }
1289
1290 void WebEngine::GoForward()
1291 {
1292   Internal::Adaptor::GetImplementation( *this ).GoForward();
1293 }
1294
1295 bool WebEngine::CanGoBack()
1296 {
1297   return Internal::Adaptor::GetImplementation( *this ).CanGoBack();
1298 }
1299
1300 void WebEngine::GoBack()
1301 {
1302   Internal::Adaptor::GetImplementation( *this ).GoBack();
1303 }
1304
1305 void WebEngine::EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler )
1306 {
1307   Internal::Adaptor::GetImplementation( *this ).EvaluateJavaScript( script, resultHandler );
1308 }
1309
1310 void WebEngine::AddJavaScriptMessageHandler( const std::string& exposedObjectName, std::function< void(const std::string&) > handler )
1311 {
1312 }
1313
1314 void WebEngine::RegisterJavaScriptAlertCallback( Dali::WebEnginePlugin::JavaScriptAlertCallback callback )
1315 {
1316   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptAlertCallback( callback );
1317 }
1318
1319 void WebEngine::JavaScriptAlertReply()
1320 {
1321 }
1322
1323 void WebEngine::RegisterJavaScriptConfirmCallback( Dali::WebEnginePlugin::JavaScriptConfirmCallback callback )
1324 {
1325   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptConfirmCallback( callback );
1326 }
1327
1328 void WebEngine::JavaScriptConfirmReply( bool confirmed )
1329 {
1330 }
1331
1332 void WebEngine::RegisterJavaScriptPromptCallback( Dali::WebEnginePlugin::JavaScriptPromptCallback callback )
1333 {
1334   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptPromptCallback( callback );
1335 }
1336
1337 void WebEngine::JavaScriptPromptReply( const std::string& result )
1338 {
1339 }
1340
1341 void WebEngine::ClearAllTilesResources()
1342 {
1343 }
1344
1345 void WebEngine::ClearHistory()
1346 {
1347   Internal::Adaptor::GetImplementation( *this ).ClearHistory();
1348 }
1349
1350 void WebEngine::SetScaleFactor(float scaleFactor, Dali::Vector2 point)
1351 {
1352   Internal::Adaptor::GetImplementation( *this ).SetScaleFactor(scaleFactor, point);
1353 }
1354
1355 float WebEngine::GetScaleFactor() const
1356 {
1357   return Internal::Adaptor::GetImplementation( *this ).GetScaleFactor();
1358 }
1359
1360 void WebEngine::ActivateAccessibility(bool activated)
1361 {
1362 }
1363
1364 bool WebEngine::HighlightText(const std::string& text, Dali::WebEnginePlugin::FindOption options, uint32_t maxMatchCount)
1365 {
1366   return true;
1367 }
1368
1369 void WebEngine::AddDynamicCertificatePath(const std::string& host, const std::string& certPath)
1370 {
1371 }
1372
1373 Dali::PixelData WebEngine::GetScreenshot(Dali::Rect<int> viewArea, float scaleFactor)
1374 {
1375   return Internal::Adaptor::GetImplementation( *this ).GetScreenshot(viewArea, scaleFactor);
1376 }
1377
1378 bool WebEngine::GetScreenshotAsynchronously(Dali::Rect<int> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
1379 {
1380   return Internal::Adaptor::GetImplementation( *this ).GetScreenshotAsynchronously(viewArea, scaleFactor, callback);
1381 }
1382
1383 bool WebEngine::CheckVideoPlayingAsynchronously(Dali::WebEnginePlugin::VideoPlayingCallback callback)
1384 {
1385   return Internal::Adaptor::GetImplementation( *this ).CheckVideoPlayingAsynchronously(callback);
1386 }
1387
1388 void WebEngine::RegisterGeolocationPermissionCallback(Dali::WebEnginePlugin::GeolocationPermissionCallback callback)
1389 {
1390   Internal::Adaptor::GetImplementation( *this ).RegisterGeolocationPermissionCallback(callback);
1391 }
1392
1393 const std::string& WebEngine::GetUserAgent() const
1394 {
1395   return Internal::Adaptor::GetImplementation( *this ).GetUserAgent();
1396 }
1397
1398 void WebEngine::SetUserAgent( const std::string& userAgent )
1399 {
1400   Internal::Adaptor::GetImplementation( *this ).SetUserAgent( userAgent );
1401 }
1402
1403 void WebEngine::ScrollBy( int dx, int dy )
1404 {
1405   Internal::Adaptor::GetImplementation( *this ).ScrollBy( dx, dy );
1406 }
1407
1408 bool WebEngine::ScrollEdgeBy( int dx, int dy )
1409 {
1410   return Internal::Adaptor::GetImplementation( *this ).ScrollEdgeBy( dx, dy );
1411 }
1412
1413 void WebEngine::SetScrollPosition( int x, int y )
1414 {
1415   Internal::Adaptor::GetImplementation( *this ).SetScrollPosition( x, y );
1416 }
1417
1418 Dali::Vector2 WebEngine::GetScrollPosition() const
1419 {
1420   return Internal::Adaptor::GetImplementation( *this ).GetScrollPosition();
1421 }
1422
1423 Dali::Vector2 WebEngine::GetScrollSize() const
1424 {
1425   return Internal::Adaptor::GetImplementation( *this ).GetScrollSize();
1426 }
1427
1428 Dali::Vector2 WebEngine::GetContentSize() const
1429 {
1430   return Internal::Adaptor::GetImplementation( *this ).GetContentSize();
1431 }
1432
1433 void WebEngine::SetSize( int width, int height )
1434 {
1435 }
1436
1437 void WebEngine::SetDocumentBackgroundColor(Dali::Vector4 color)
1438 {
1439 }
1440
1441 void WebEngine::ClearTilesWhenHidden(bool cleared)
1442 {
1443 }
1444
1445 void WebEngine::SetTileCoverAreaMultiplier(float multiplier)
1446 {
1447 }
1448
1449 void WebEngine::EnableCursorByClient(bool enabled)
1450 {
1451 }
1452
1453 std::string WebEngine::GetSelectedText() const
1454 {
1455   return "test";
1456 }
1457
1458 bool WebEngine::SendTouchEvent( const TouchEvent& touch )
1459 {
1460   return true;
1461 }
1462
1463 bool WebEngine::SendKeyEvent( const KeyEvent& event )
1464 {
1465   return true;
1466 }
1467
1468 bool WebEngine::SendHoverEvent( const HoverEvent& event )
1469 {
1470   return true;
1471 }
1472
1473 bool WebEngine::SendWheelEvent( const WheelEvent& event )
1474 {
1475   return true;
1476 }
1477
1478 void WebEngine::SetFocus( bool focused )
1479 {
1480 }
1481
1482 void WebEngine::SetPageZoomFactor(float zoomFactor)
1483 {
1484   Internal::Adaptor::GetImplementation( *this ).SetPageZoomFactor(zoomFactor);
1485 }
1486
1487 float WebEngine::GetPageZoomFactor() const
1488 {
1489   return Internal::Adaptor::GetImplementation( *this ).GetPageZoomFactor();
1490 }
1491
1492 void WebEngine::SetTextZoomFactor(float zoomFactor)
1493 {
1494   Internal::Adaptor::GetImplementation( *this ).SetTextZoomFactor(zoomFactor);
1495 }
1496
1497 float WebEngine::GetTextZoomFactor() const
1498 {
1499   return Internal::Adaptor::GetImplementation( *this ).GetTextZoomFactor();
1500 }
1501
1502 float WebEngine::GetLoadProgressPercentage() const
1503 {
1504   return Internal::Adaptor::GetImplementation( *this ).GetLoadProgressPercentage();
1505 }
1506
1507 void WebEngine::UpdateDisplayArea( Dali::Rect< int > displayArea )
1508 {
1509 }
1510
1511 void WebEngine::EnableVideoHole( bool enabled )
1512 {
1513 }
1514
1515 void WebEngine::EnableMouseEvents( bool enabled )
1516 {
1517 }
1518
1519 void WebEngine::EnableKeyEvents( bool enabled )
1520 {
1521 }
1522
1523 Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadStartedSignal()
1524 {
1525   return Internal::Adaptor::GetImplementation( *this ).PageLoadStartedSignal();
1526 }
1527
1528 Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadInProgressSignal()
1529 {
1530   return Internal::Adaptor::GetImplementation( *this ).PageLoadInProgressSignal();
1531 }
1532
1533 Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadFinishedSignal()
1534 {
1535   return Internal::Adaptor::GetImplementation( *this ).PageLoadFinishedSignal();
1536 }
1537
1538 Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& WebEngine::PageLoadErrorSignal()
1539 {
1540   return Internal::Adaptor::GetImplementation( *this ).PageLoadErrorSignal();
1541 }
1542
1543 Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType& WebEngine::ScrollEdgeReachedSignal()
1544 {
1545   return Internal::Adaptor::GetImplementation( *this ).ScrollEdgeReachedSignal();
1546 }
1547
1548 Dali::WebEnginePlugin::WebEngineUrlChangedSignalType& WebEngine::UrlChangedSignal()
1549 {
1550   return Internal::Adaptor::GetImplementation( *this ).UrlChangedSignal();
1551 }
1552
1553 Dali::WebEnginePlugin::WebEngineFormRepostDecisionSignalType& WebEngine::FormRepostDecisionSignal()
1554 {
1555   return Internal::Adaptor::GetImplementation( *this ).FormRepostDecisionSignal();
1556 }
1557
1558 Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& WebEngine::FrameRenderedSignal()
1559 {
1560   return Internal::Adaptor::GetImplementation(*this).FrameRenderedSignal();
1561 }
1562
1563 Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType& WebEngine::RequestInterceptorSignal()
1564 {
1565   return Internal::Adaptor::GetImplementation(*this).RequestInterceptorSignal();
1566 }
1567
1568 Dali::WebEnginePlugin::WebEngineConsoleMessageSignalType& WebEngine::ConsoleMessageSignal()
1569 {
1570   return Internal::Adaptor::GetImplementation(*this).ConsoleMessageSignal();
1571 }
1572
1573 } // namespace Dali;
1574