automated-tests/src/dali-toolkit/dali-toolkit-test-utils/toolkit-web-engine.cpp

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