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