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