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