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