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