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 class MockWebEngineCertificate : public Dali::WebEngineCertificate
 491 {
 492 public:
 493   MockWebEngineCertificate()
 494   {
 495   }
 496
 497   void Allow(bool allowed) override
 498   {
 499   }
 500
 501   bool IsFromMainFrame() const override
 502   {
 503     return true;
 504   }
 505
 506   std::string GetPem() const override
 507   {
 508     return "abc";
 509   }
 510
 511   bool IsContextSecure() const override
 512   {
 513     return true;
 514   }
 515 };
 516
 517 class MockWebEngineHttpAuthHandler : public Dali::WebEngineHttpAuthHandler
 518 {
 519 public:
 520   MockWebEngineHttpAuthHandler()
 521   {
 522   }
 523
 524   std::string GetRealm() const override
 525   {
 526     return "test";
 527   }
 528
 529   void Suspend() override
 530   {
 531   }
 532
 533   void UseCredential(const std::string& user, const std::string& password) override
 534   {
 535   }
 536
 537   void CancelCredential() override
 538   {
 539   }
 540 };
 541
 542 class MockWebEngineFormRepostDecision : public WebEngineFormRepostDecision
 543 {
 544 public:
 545   MockWebEngineFormRepostDecision()
 546   {
 547   }
 548
 549   void Reply(bool allowed) override {}
 550 };
 551
 552 class MockWebEngineFrame : public Dali::WebEngineFrame
 553 {
 554 public:
 555   MockWebEngineFrame()
 556   {
 557   }
 558
 559   bool IsMainFrame() const override
 560   {
 561     return true;
 562   }
 563 };
 564
 565 class MockWebEnginePolicyDecision : public Dali::WebEnginePolicyDecision
 566 {
 567 public:
 568   MockWebEnginePolicyDecision()
 569   {
 570   }
 571
 572   std::string GetUrl() const override
 573   {
 574     return "http://test.html";
 575   }
 576
 577   std::string GetCookie() const override
 578   {
 579     return "test:abc";
 580   }
 581
 582   Dali::WebEnginePolicyDecision::DecisionType GetDecisionType() const
 583   {
 584     return Dali::WebEnginePolicyDecision::DecisionType::USE;
 585   }
 586
 587   std::string GetResponseMime() const
 588   {
 589     return "txt/xml";
 590   }
 591
 592   int32_t GetResponseStatusCode() const
 593   {
 594     return 500;
 595   }
 596
 597   Dali::WebEnginePolicyDecision::NavigationType GetNavigationType() const
 598   {
 599     return Dali::WebEnginePolicyDecision::NavigationType::LINK_CLICKED;
 600   }
 601
 602   Dali::WebEngineFrame& GetFrame() const
 603   {
 604     return *(Dali::WebEngineFrame*)(&mockWebFrame);
 605   }
 606
 607   std::string GetScheme() const
 608   {
 609     return "test";
 610   }
 611
 612   bool Use()
 613   {
 614     return true;
 615   }
 616
 617   bool Ignore()
 618   {
 619     return true;
 620   }
 621
 622   bool Suspend()
 623   {
 624     return true;
 625   }
 626
 627 private:
 628   MockWebEngineFrame mockWebFrame;
 629 };
 630
 631 class MockWebEngineConsoleMessage : public Dali::WebEngineConsoleMessage
 632 {
 633 public:
 634   MockWebEngineConsoleMessage()
 635   {
 636   }
 637
 638   std::string GetSource() const override
 639   {
 640     return "source";
 641   }
 642
 643   uint32_t GetLine() const override
 644   {
 645     return 10;
 646   }
 647
 648   SeverityLevel GetSeverityLevel() const override
 649   {
 650     return SeverityLevel::EMPTY;
 651   }
 652
 653   std::string GetText() const override
 654   {
 655     return "This is a text.";
 656   }
 657 };
 658
 659 class MockWebEngineLoadError : public Dali::WebEngineLoadError
 660 {
 661 public:
 662   MockWebEngineLoadError(const std::string& url)
 663     : mockUrl(url)
 664   {
 665   }
 666
 667   std::string GetUrl() const override
 668   {
 669     return mockUrl;
 670   }
 671
 672   ErrorCode GetCode() const override
 673   {
 674     return ErrorCode::UNKNOWN;
 675   }
 676
 677   std::string GetDescription() const override
 678   {
 679     return "This is an error.";
 680   }
 681
 682   ErrorType GetType() const override
 683   {
 684     return ErrorType::NONE;
 685   }
 686
 687 private:
 688   std::string mockUrl;
 689 };
 690
 691 class MockWebEngineContextMenuItem : public Dali::WebEngineContextMenuItem
 692 {
 693 public:
 694   MockWebEngineContextMenuItem()
 695   {
 696   }
 697
 698   ItemTag GetTag() const override
 699   {
 700     return ItemTag::NO_ACTION;
 701   }
 702
 703   ItemType GetType() const override
 704   {
 705     return ItemType::ACTION;
 706   }
 707
 708   bool IsEnabled() const override
 709   {
 710     return true;
 711   }
 712
 713   std::string GetLinkUrl() const override
 714   {
 715     return "http://test.html";
 716   }
 717
 718   std::string GetImageUrl() const override
 719   {
 720     return "http://test.jpg";
 721   }
 722
 723   std::string GetTitle() const override
 724   {
 725     return "title";
 726   }
 727
 728   std::unique_ptr<Dali::WebEngineContextMenu> GetParentMenu() const override
 729   {
 730     std::unique_ptr<Dali::WebEngineContextMenu> result;
 731     return result;
 732   }
 733 };
 734
 735 class MockWebEngineContextMenu : public Dali::WebEngineContextMenu
 736 {
 737 public:
 738   MockWebEngineContextMenu()
 739   {
 740   }
 741
 742   uint32_t GetItemCount() const override
 743   {
 744     return 1;
 745   }
 746
 747   std::unique_ptr<Dali::WebEngineContextMenuItem> GetItemAt(uint32_t index) const override
 748   {
 749     std::unique_ptr<Dali::WebEngineContextMenuItem> webitem(new MockWebEngineContextMenuItem());
 750     return webitem;
 751   }
 752
 753   std::vector<std::unique_ptr<WebEngineContextMenuItem>> GetItemList() const override
 754   {
 755     std::vector<std::unique_ptr<WebEngineContextMenuItem>> result;
 756     std::unique_ptr<Dali::WebEngineContextMenuItem> webitem(new MockWebEngineContextMenuItem());
 757     result.push_back(std::move(webitem));
 758     return result;
 759   }
 760
 761   bool RemoveItem(WebEngineContextMenuItem& item) override
 762   {
 763     return true;
 764   }
 765
 766   bool AppendItemAsAction(WebEngineContextMenuItem::ItemTag tag, const std::string& title, bool enabled) override
 767   {
 768     return true;
 769   }
 770
 771   bool AppendItem(WebEngineContextMenuItem::ItemTag tag, const std::string& title, const std::string& iconFile, bool enabled) override
 772   {
 773     return true;
 774   }
 775
 776   bool SelectItem(WebEngineContextMenuItem& item) override
 777   {
 778     return true;
 779   }
 780
 781   bool Hide() override
 782   {
 783     return true;
 784   }
 785 };
 786
 787 class MockWebEngineHitTest : public Dali::WebEngineHitTest
 788 {
 789 public:
 790   MockWebEngineHitTest()
 791   {
 792   }
 793
 794   ResultContext GetResultContext() const override
 795   {
 796     return ResultContext::DOCUMENT;
 797   }
 798
 799   std::string GetLinkUri() const override
 800   {
 801     return "http://test.html";
 802   }
 803
 804   std::string GetLinkTitle() const override
 805   {
 806     return "test";
 807   }
 808
 809   std::string GetLinkLabel() const override
 810   {
 811     return "label";
 812   }
 813
 814   std::string GetImageUri() const override
 815   {
 816     return "http://test.jpg";
 817   }
 818
 819   std::string GetMediaUri() const override
 820   {
 821     return "http://test.mp4";
 822   }
 823
 824   std::string GetTagName() const override
 825   {
 826     return "img";
 827   }
 828
 829   std::string GetNodeValue() const override
 830   {
 831     return "test";
 832   }
 833
 834   Dali::Property::Map GetAttributes() const override
 835   {
 836     return mockAttributesMap;
 837   }
 838
 839   std::string GetImageFileNameExtension() const override
 840   {
 841     return "jpg";
 842   }
 843
 844   Dali::PixelData GetImageBuffer() override
 845   {
 846     uint8_t* imageData = new uint8_t[16];
 847     memset(imageData, 0xff, 16);
 848     return Dali::PixelData::New(imageData, 16, 2, 2,
 849                                 Dali::Pixel::Format::RGBA8888,
 850                                 Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
 851   }
 852
 853 private:
 854   mutable Dali::Property::Map mockAttributesMap;
 855 };
 856
 857 class MockWebEngineSecurityOrigin : public Dali::WebEngineSecurityOrigin
 858 {
 859 public:
 860   MockWebEngineSecurityOrigin()
 861     : mockUrl("https://test.html")
 862     , mockPotocol("https")
 863   {
 864   }
 865
 866   std::string GetHost() const
 867   {
 868     return mockUrl;
 869   }
 870
 871   std::string GetProtocol() const
 872   {
 873     return mockPotocol;
 874   }
 875
 876 private:
 877   std::string mockUrl;
 878   std::string mockPotocol;
 879 };
 880
 881 class MockWebEngineSettings : public WebEngineSettings
 882 {
 883 public:
 884   MockWebEngineSettings()
 885     : mockDefaultFontSize( 16 ),
 886       mockJavaScriptEnabled( true ),
 887       mockAutoFittingEnabled ( true ),
 888       mockPluginsEnabled ( true ),
 889       mockPrivateBrowsingEnabled( true ),
 890       mockLinkMagnifierEnabled( true ),
 891       mockKeypadWithoutUserActionUsed( true ),
 892       mockAutofillPasswordFormEnabled( true ),
 893       mockFormCandidateDataEnabled( true ),
 894       mockTextSelectionEnabled( true ),
 895       mockTextAutosizingEnable( true ),
 896       mockArrowScrollEnable( true ),
 897       mockClipboardEnabled( true ),
 898       mockImePanelEnabled( true ),
 899       mockImageLoadedAutomatically( true ),
 900       mockDefaultTextEncodingName()
 901   {
 902   }
 903
 904   uint32_t GetDefaultFontSize() const override
 905   {
 906     return mockDefaultFontSize;
 907   }
 908
 909   void SetDefaultFontSize( uint32_t size ) override
 910   {
 911     mockDefaultFontSize = size;
 912   }
 913
 914   bool IsJavaScriptEnabled() const override
 915   {
 916     return mockJavaScriptEnabled;
 917   }
 918
 919   void EnableJavaScript( bool enabled ) override
 920   {
 921     mockJavaScriptEnabled = enabled;
 922   }
 923
 924   bool IsAutoFittingEnabled() const override
 925   {
 926     return mockAutoFittingEnabled;
 927   }
 928
 929   void EnableAutoFitting( bool enabled ) override
 930   {
 931     mockAutoFittingEnabled = enabled;
 932   }
 933
 934   bool ArePluginsEnabled() const override
 935   {
 936     return mockPluginsEnabled;
 937   }
 938
 939   void EnablePlugins( bool enabled ) override
 940   {
 941     mockPluginsEnabled = enabled;
 942   }
 943
 944   bool IsPrivateBrowsingEnabled() const override
 945   {
 946     return mockPrivateBrowsingEnabled;
 947   }
 948
 949   void EnablePrivateBrowsing( bool enabled ) override
 950   {
 951     mockPrivateBrowsingEnabled = enabled;
 952   }
 953
 954   bool IsLinkMagnifierEnabled() const override
 955   {
 956     return mockLinkMagnifierEnabled;
 957   }
 958
 959   void EnableLinkMagnifier( bool enabled ) override
 960   {
 961     mockLinkMagnifierEnabled = enabled;
 962   }
 963
 964   bool IsKeypadWithoutUserActionUsed() const override
 965   {
 966     return mockKeypadWithoutUserActionUsed;
 967   }
 968
 969   void UseKeypadWithoutUserAction( bool used ) override
 970   {
 971     mockKeypadWithoutUserActionUsed = used;
 972   }
 973
 974   bool IsAutofillPasswordFormEnabled() const override
 975   {
 976     return mockAutofillPasswordFormEnabled;
 977   }
 978
 979   void EnableAutofillPasswordForm( bool enabled ) override
 980   {
 981     mockAutofillPasswordFormEnabled = enabled;
 982   }
 983
 984   bool IsFormCandidateDataEnabled() const override
 985   {
 986     return mockFormCandidateDataEnabled;
 987   }
 988
 989   void EnableFormCandidateData( bool enabled ) override
 990   {
 991     mockFormCandidateDataEnabled = enabled;
 992   }
 993
 994   bool IsTextSelectionEnabled() const override
 995   {
 996     return mockTextSelectionEnabled;
 997   }
 998
 999   void EnableTextSelection( bool enabled ) override
1000   {
1001     mockTextSelectionEnabled = enabled;
1002   }
1003
1004   bool IsTextAutosizingEnabled() const override
1005   {
1006     return mockTextAutosizingEnable;
1007   }
1008
1009   void EnableTextAutosizing( bool enabled ) override
1010   {
1011     mockTextAutosizingEnable = enabled;
1012   }
1013
1014   bool IsArrowScrollEnabled() const override
1015   {
1016     return mockArrowScrollEnable;
1017   }
1018
1019   void EnableArrowScroll( bool enabled ) override
1020   {
1021     mockArrowScrollEnable = enabled;
1022   }
1023
1024   bool IsClipboardEnabled() const override
1025   {
1026     return mockClipboardEnabled;
1027   }
1028
1029   void EnableClipboard( bool enabled ) override
1030   {
1031     mockClipboardEnabled = enabled;
1032   }
1033
1034   bool IsImePanelEnabled() const override
1035   {
1036     return mockImePanelEnabled;
1037   }
1038
1039   void EnableImePanel( bool enabled ) override
1040   {
1041     mockImePanelEnabled = enabled;
1042   }
1043
1044   bool AreImagesLoadedAutomatically() const override
1045   {
1046     return mockImageLoadedAutomatically;
1047   }
1048
1049   void AllowImagesLoadAutomatically( bool automatic ) override
1050   {
1051     mockImageLoadedAutomatically = automatic;
1052   }
1053
1054   std::string GetDefaultTextEncodingName() const override
1055   {
1056     return mockDefaultTextEncodingName;
1057   }
1058
1059   void SetDefaultTextEncodingName( const std::string& defaultTextEncodingName ) override
1060   {
1061     mockDefaultTextEncodingName = defaultTextEncodingName;
1062   }
1063
1064   void AllowMixedContents( bool allowed ) override
1065   {
1066   }
1067
1068   void EnableSpatialNavigation( bool enabled ) override
1069   {
1070   }
1071
1072   void EnableWebSecurity( bool enabled ) override
1073   {
1074   }
1075
1076   void EnableCacheBuilder( bool enabled ) override
1077   {
1078   }
1079
1080   void UseScrollbarThumbFocusNotifications( bool used ) override
1081   {
1082   }
1083
1084   void EnableDoNotTrack( bool enabled ) override
1085   {
1086   }
1087
1088   void AllowFileAccessFromExternalUrl( bool allowed ) override
1089   {
1090   }
1091
1092   void AllowScriptsOpenWindows( bool allowed ) override
1093   {
1094   }
1095
1096   bool SetViewportMetaTag(bool enable) override
1097   {
1098     return true;
1099   }
1100
1101   bool SetForceZoom(bool enable) override
1102   {
1103     return true;
1104   }
1105
1106   bool IsZoomForced() const override
1107   {
1108     return true;
1109   }
1110
1111   bool SetTextZoomEnabled(bool enable) override
1112   {
1113     return true;
1114   }
1115
1116   bool IsTextZoomEnabled() const override
1117   {
1118     return true;
1119   }
1120
1121   void SetExtraFeature(const std::string& feature, bool enable) override
1122   {
1123   }
1124
1125   bool IsExtraFeatureEnabled(const std::string& feature) const override
1126   {
1127     return  true;
1128   }
1129
1130 private:
1131   int mockDefaultFontSize;
1132   bool mockJavaScriptEnabled;
1133   bool mockAutoFittingEnabled;
1134   bool mockPluginsEnabled;
1135   bool mockPrivateBrowsingEnabled;
1136   bool mockLinkMagnifierEnabled;
1137   bool mockKeypadWithoutUserActionUsed;
1138   bool mockAutofillPasswordFormEnabled;
1139   bool mockFormCandidateDataEnabled;
1140   bool mockTextSelectionEnabled;
1141   bool mockTextAutosizingEnable;
1142   bool mockArrowScrollEnable;
1143   bool mockClipboardEnabled;
1144   bool mockImePanelEnabled;
1145   bool mockImageLoadedAutomatically;
1146   std::string mockDefaultTextEncodingName;
1147 };
1148
1149 class MockWebEnginePlugin : public Dali::WebEnginePlugin
1150 {
1151 public:
1152   MockWebEnginePlugin(){}
1153   void Create(uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneId) override {}
1154   void Create(uint32_t width, uint32_t height, uint32_t argc, char** argv) override {}
1155   void Destroy() override {}
1156   WebEngineSettings& GetSettings() const override { return *((WebEngineSettings*)&settings); }
1157   WebEngineBackForwardList& GetBackForwardList() const override { return *((WebEngineBackForwardList*)&backForwardList); }
1158   void LoadUrl(const std::string& url) override {}
1159   std::string GetTitle() const override { return std::string(); }
1160   Dali::PixelData GetFavicon() const override { return Dali::PixelData(); }
1161   NativeImageSourcePtr GetNativeImageSource() override { return nullptr; }
1162   std::string GetUrl() const override { return std::string(); }
1163   void LoadHtmlString(const std::string& htmlString) override {}
1164   bool LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl) override { return false; }
1165   bool LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri) override { return false; }
1166   void Reload() override {}
1167   bool ReloadWithoutCache() override { return false; }
1168   void StopLoading() override {}
1169   void Suspend() override {}
1170   void Resume() override {}
1171   void SuspendNetworkLoading() override {}
1172   void ResumeNetworkLoading() override {}
1173   bool AddCustomHeader(const std::string& name, const std::string& value) override { return false; }
1174   bool RemoveCustomHeader(const std::string& name) override { return false; }
1175   uint32_t StartInspectorServer(uint32_t port) override { return 0; }
1176   bool StopInspectorServer() override { return false; }
1177   void ScrollBy(int32_t deltaX, int32_t deltaY) override {}
1178   bool ScrollEdgeBy(int32_t deltaX, int32_t deltaY) override { return false; }
1179   void SetScrollPosition(int32_t x, int32_t y) override {}
1180   Dali::Vector2 GetScrollPosition() const override { return Dali::Vector2(); }
1181   Dali::Vector2 GetScrollSize() const override { return Dali::Vector2(); }
1182   Dali::Vector2 GetContentSize() const override { return Dali::Vector2(); }
1183   bool CanGoForward() override { return false; }
1184   void GoForward() override {}
1185   bool CanGoBack() override { return false; }
1186   void GoBack() override {}
1187   void EvaluateJavaScript(const std::string& script, JavaScriptMessageHandlerCallback resultHandler) override {}
1188   void AddJavaScriptMessageHandler(const std::string& exposedObjectName, JavaScriptMessageHandlerCallback handler) override {}
1189   void RegisterJavaScriptAlertCallback(JavaScriptAlertCallback callback) override {}
1190   void JavaScriptAlertReply() override {}
1191   void RegisterJavaScriptConfirmCallback(JavaScriptConfirmCallback callback) override {}
1192   void JavaScriptConfirmReply(bool confirmed) override {}
1193   void RegisterJavaScriptPromptCallback(JavaScriptPromptCallback callback) override {}
1194   void JavaScriptPromptReply(const std::string& result) override {}
1195   std::unique_ptr<Dali::WebEngineHitTest> CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode) override { return nullptr; }
1196   bool CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, WebEngineHitTestCreatedCallback callback) override { return false; }
1197   void ClearHistory() override {}
1198   void ClearAllTilesResources() override {}
1199   std::string GetUserAgent() const override { return std::string(); }
1200   void SetUserAgent(const std::string& userAgent) override {}
1201   void SetSize(uint32_t width, uint32_t height) override {}
1202   void SetDocumentBackgroundColor(Dali::Vector4 color) override {}
1203   void ClearTilesWhenHidden(bool cleared) override {}
1204   void SetTileCoverAreaMultiplier(float multiplier) override {}
1205   void EnableCursorByClient(bool enabled) override {}
1206   std::string GetSelectedText() const override { return std::string(); }
1207   bool SendTouchEvent(const TouchEvent& touch) override { return false; }
1208   bool SendKeyEvent(const KeyEvent& event) override { return false; }
1209   void EnableMouseEvents(bool enabled) override {}
1210   void EnableKeyEvents(bool enabled) override {}
1211   void SetFocus(bool focused) override {}
1212   void SetPageZoomFactor(float zoomFactor) override {}
1213   float GetPageZoomFactor() const override { return 0.0f; }
1214   void SetTextZoomFactor(float zoomFactor) override {}
1215   float GetTextZoomFactor() const override { return 0.0f; }
1216   float GetLoadProgressPercentage() const override { return 0.0f; }
1217   void SetScaleFactor(float scaleFactor, Dali::Vector2 point) override {}
1218   float GetScaleFactor() const override { return 0.0f; }
1219   void ActivateAccessibility(bool activated) override {}
1220   Accessibility::Address GetAccessibilityAddress() override { return Accessibility::Address(); }
1221   bool SetVisibility(bool visible) override { return false; }
1222   bool HighlightText(const std::string& text, FindOption options, uint32_t maxMatchCount) override { return false; }
1223   void AddDynamicCertificatePath(const std::string& host, const std::string& certPath) override {}
1224   Dali::PixelData GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor) override { return Dali::PixelData(); }
1225   bool GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, ScreenshotCapturedCallback callback) override { return false; }
1226   bool CheckVideoPlayingAsynchronously(VideoPlayingCallback callback) override { return false; }
1227   void RegisterGeolocationPermissionCallback(GeolocationPermissionCallback callback) override {}
1228   void UpdateDisplayArea(Dali::Rect<int32_t> displayArea) override {}
1229   void EnableVideoHole(bool enabled) override {}
1230   bool SendHoverEvent(const HoverEvent& event) override { return false; }
1231   bool SendWheelEvent(const WheelEvent& event) override { return false; }
1232   void RegisterFrameRenderedCallback(WebEngineFrameRenderedCallback callback) override {}
1233   void RegisterPageLoadStartedCallback(WebEnginePageLoadCallback callback) override {}
1234   void RegisterPageLoadInProgressCallback(WebEnginePageLoadCallback callback) override {}
1235   void RegisterPageLoadFinishedCallback(WebEnginePageLoadCallback callback) override {}
1236   void RegisterPageLoadErrorCallback(WebEnginePageLoadErrorCallback callback) override {}
1237   void RegisterScrollEdgeReachedCallback(WebEngineScrollEdgeReachedCallback callback) override {}
1238   void RegisterUrlChangedCallback(WebEngineUrlChangedCallback callback) override {}
1239   void RegisterFormRepostDecidedCallback(WebEngineFormRepostDecidedCallback callback) override {}
1240   void RegisterConsoleMessageReceivedCallback(WebEngineConsoleMessageReceivedCallback callback) override {}
1241   void RegisterResponsePolicyDecidedCallback(WebEngineResponsePolicyDecidedCallback callback) override {}
1242   void RegisterNavigationPolicyDecidedCallback(WebEngineNavigationPolicyDecidedCallback callback) override {}
1243   void RegisterNewWindowCreatedCallback(WebEngineNewWindowCreatedCallback callback) override {}
1244   void RegisterCertificateConfirmedCallback(WebEngineCertificateCallback callback) override {}
1245   void RegisterSslCertificateChangedCallback(WebEngineCertificateCallback callback) override {}
1246   void RegisterHttpAuthHandlerCallback(WebEngineHttpAuthHandlerCallback callback) override {}
1247   void RegisterContextMenuShownCallback(WebEngineContextMenuShownCallback callback) override {}
1248   void RegisterContextMenuHiddenCallback(WebEngineContextMenuHiddenCallback callback) override {}
1249   void GetPlainTextAsynchronously(PlainTextReceivedCallback callback) override {}
1250 private:
1251   MockWebEngineSettings settings;
1252   MockWebEngineBackForwardList backForwardList;
1253 };
1254
1255 Dali::WebEnginePlugin* GetWebEnginePlugin()
1256 {
1257   static MockWebEnginePlugin plugin;
1258   return &plugin;
1259 }
1260
1261 class MockWebEngineRequestInterceptor : public WebEngineRequestInterceptor
1262 {
1263 public:
1264   MockWebEngineRequestInterceptor()
1265   {
1266   }
1267
1268   Dali::WebEnginePlugin* GetWebEngine() const
1269   {
1270     return GetWebEnginePlugin();
1271   }
1272
1273   std::string GetUrl() const override
1274   {
1275     return "http://test.html";
1276   }
1277
1278   Dali::Property::Map GetHeaders() const override
1279   {
1280     return mockHeadersMap;
1281   }
1282
1283   std::string GetMethod() const override
1284   {
1285     return "GET";
1286   }
1287
1288   bool Ignore() override
1289   {
1290     return true;
1291   }
1292
1293   bool SetResponseStatus(int statusCode, const std::string& customedStatusText) override
1294   {
1295     return true;
1296   }
1297
1298   bool AddResponseHeader(const std::string& fieldName, const std::string& fieldValue) override
1299   {
1300     mockHeadersMap.Add(fieldName, fieldValue);
1301     return true;
1302   }
1303
1304   bool AddResponseHeaders(const Dali::Property::Map& headers) override
1305   {
1306     mockHeadersMap.Merge(headers);
1307     return true;
1308   }
1309
1310   bool AddResponseBody(const int8_t* body, uint32_t length) override
1311   {
1312     return true;
1313   }
1314
1315   bool AddResponse(const std::string& headers, const int8_t* body, uint32_t length) override
1316   {
1317     return true;
1318   }
1319
1320   bool WriteResponseChunk(const int8_t* chunk, uint32_t length) override
1321   {
1322     return true;
1323   }
1324
1325 private:
1326   Dali::Property::Map mockHeadersMap;
1327 };
1328
1329 class WebEngine: public Dali::BaseObject
1330 {
1331 public:
1332
1333   WebEngine()
1334     : mUrl()
1335     , mCurrentPlusOnePos( 0 )
1336     , mUserAgent()
1337     , mEvaluating( false )
1338     , mScrollPosition( 0, 0 )
1339     , mScrollSize( 500, 500 )
1340     , mContentSize( 500, 500 )
1341   {
1342     gInstanceCount++;
1343     if ( gInstanceCount == 1 ) // only first web engine need be saved.
1344     {
1345       gInstance = this;
1346     }
1347
1348     mockWebEngineSettings = new MockWebEngineSettings();
1349     mockWebEngineBackForwardList = new MockWebEngineBackForwardList();
1350   }
1351
1352   virtual ~WebEngine()
1353   {
1354     gInstanceCount--;
1355     if( !gInstanceCount )
1356     {
1357       gInstance = nullptr;
1358     }
1359
1360     delete mockWebEngineSettings;
1361     delete mockWebEngineBackForwardList;
1362   }
1363
1364   Dali::WebEngineSettings& GetSettings() const
1365   {
1366     return *mockWebEngineSettings;
1367   }
1368
1369   Dali::WebEngineBackForwardList& GetBackForwardList() const
1370   {
1371     return *mockWebEngineBackForwardList;
1372   }
1373
1374   void LoadUrl( const std::string& url )
1375   {
1376     mUrl = url;
1377     ConnectToGlobalSignal( &OnLoadUrl );
1378   }
1379
1380   std::string GetUrl() const
1381   {
1382     return mUrl;
1383   }
1384
1385   std::string GetTitle() const
1386   {
1387     return std::string("title");
1388   }
1389
1390   Dali::PixelData GetFavicon() const
1391   {
1392     static int testGetFaviconCount = 0;
1393     if (testGetFaviconCount == 0)
1394     {
1395       testGetFaviconCount++;
1396       uint8_t* faviconData = new uint8_t[16];
1397       memset(faviconData, 0xff, 16);
1398       return Dali::PixelData::New(faviconData, 16, 2, 2,
1399                                   Dali::Pixel::Format::RGBA8888,
1400                                   Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
1401     }
1402     else
1403     {
1404       return Dali::PixelData();
1405     }
1406   }
1407
1408   bool CanGoForward() const
1409   {
1410     return mHistory.size() > mCurrentPlusOnePos;
1411   }
1412
1413   void GoForward()
1414   {
1415     ConnectToGlobalSignal( &OnGoForward );
1416   }
1417
1418   bool CanGoBack() const
1419   {
1420     return mCurrentPlusOnePos > 1;
1421   }
1422
1423   void GoBack()
1424   {
1425     ConnectToGlobalSignal( &OnGoBack );
1426   }
1427
1428   void EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler )
1429   {
1430     if( resultHandler )
1431     {
1432       if( !mEvaluating )
1433       {
1434         ConnectToGlobalSignal( &OnEvaluteJavaScript );
1435       }
1436       mResultCallbacks.push_back( resultHandler );
1437     }
1438   }
1439
1440   void RegisterJavaScriptAlertCallback( Dali::WebEnginePlugin::JavaScriptAlertCallback callback )
1441   {
1442     if ( callback )
1443     {
1444       ConnectToGlobalSignal( &OnJavaScriptAlert );
1445       mJavaScriptAlertCallback = callback;
1446     }
1447   }
1448
1449   void RegisterJavaScriptConfirmCallback( Dali::WebEnginePlugin::JavaScriptConfirmCallback callback )
1450   {
1451     if ( callback )
1452     {
1453       ConnectToGlobalSignal( &OnJavaScriptConfirm );
1454       mJavaScriptConfirmCallback = callback;
1455     }
1456   }
1457
1458   void RegisterJavaScriptPromptCallback( Dali::WebEnginePlugin::JavaScriptPromptCallback callback )
1459   {
1460     if ( callback )
1461     {
1462       ConnectToGlobalSignal( &OnJavaScriptPrompt );
1463       mJavaScriptPromptCallback = callback;
1464     }
1465   }
1466
1467   std::unique_ptr<Dali::WebEngineHitTest> CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
1468   {
1469     std::unique_ptr<Dali::WebEngineHitTest> hitTest(new MockWebEngineHitTest());
1470     return hitTest;
1471   }
1472
1473   bool CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
1474   {
1475     if (callback)
1476     {
1477       ConnectToGlobalSignal( &OnHitTestCreated );
1478       mHitTestCreatedCallback = callback;
1479     }
1480     return true;
1481   }
1482
1483   void ClearHistory()
1484   {
1485     ConnectToGlobalSignal( &OnClearHistory );
1486   }
1487
1488   std::string GetUserAgent() const
1489   {
1490     return mUserAgent;
1491   }
1492
1493   void SetUserAgent( const std::string& userAgent )
1494   {
1495     mUserAgent = userAgent;
1496   }
1497
1498   void ScrollBy( int32_t dx, int32_t dy )
1499   {
1500     mScrollPosition += Dali::Vector2( dx, dy );
1501     if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
1502     {
1503       ConnectToGlobalSignal( &OnScrollEdge );
1504     }
1505   }
1506
1507   bool ScrollEdgeBy( int32_t dx, int32_t dy )
1508   {
1509     mScrollPosition += Dali::Vector2( dx, dy );
1510     if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
1511     {
1512       ConnectToGlobalSignal( &OnScrollEdge );
1513     }
1514     return true;
1515   }
1516
1517   void SetScrollPosition( int32_t x, int32_t y )
1518   {
1519     mScrollPosition.x = x;
1520     mScrollPosition.y = y;
1521   }
1522
1523   Dali::Vector2 GetScrollPosition() const
1524   {
1525     return mScrollPosition;
1526   }
1527
1528   Dali::Vector2 GetScrollSize() const
1529   {
1530     return mScrollSize;
1531   }
1532
1533   Dali::Vector2 GetContentSize() const
1534   {
1535     return mContentSize;
1536   }
1537
1538   void SetPageZoomFactor(float zoomFactor)
1539   {
1540     mPageZoomFactor = zoomFactor;
1541   }
1542
1543   float GetPageZoomFactor() const
1544   {
1545     return mPageZoomFactor;
1546   }
1547
1548   void SetTextZoomFactor(float zoomFactor)
1549   {
1550     mTextZoomFactor = zoomFactor;
1551   }
1552
1553   float GetTextZoomFactor() const
1554   {
1555     return mTextZoomFactor;
1556   }
1557
1558   float GetLoadProgressPercentage() const
1559   {
1560     return 0.5f;
1561   }
1562
1563   void SetScaleFactor(float scaleFactor, Dali::Vector2 point)
1564   {
1565     mScaleFactor = scaleFactor;
1566   }
1567
1568   float GetScaleFactor() const
1569   {
1570     return mScaleFactor;
1571   }
1572
1573   Dali::Accessibility::Address GetAccessibilityAddress()
1574   {
1575     return {":9.99", "root"};
1576   }
1577
1578   Dali::PixelData GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
1579   {
1580     uint32_t bufferSize = viewArea.width * viewArea.height * 4 ;
1581     uint8_t* pixel = new uint8_t[ bufferSize ];
1582     memset(pixel, 0xff, bufferSize);
1583     return Dali::PixelData::New( pixel, bufferSize, viewArea.width, viewArea.height,
1584                                  Dali::Pixel::Format::RGBA8888,
1585                                  Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
1586   }
1587
1588   bool GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
1589   {
1590     if ( callback )
1591     {
1592       ConnectToGlobalSignal( &OnScreenshotCaptured );
1593       mScreenshotCapturedCallback = callback;
1594     }
1595     return true;
1596   }
1597
1598   bool CheckVideoPlayingAsynchronously(Dali::WebEnginePlugin::VideoPlayingCallback callback)
1599   {
1600     if ( callback )
1601     {
1602       ConnectToGlobalSignal( &OnVideoPlaying );
1603       mVideoPlayingCallback = callback;
1604     }
1605     return true;
1606   }
1607
1608   void RegisterGeolocationPermissionCallback(Dali::WebEnginePlugin::GeolocationPermissionCallback callback)
1609   {
1610     if ( callback )
1611     {
1612       ConnectToGlobalSignal( &OnGeolocationPermission );
1613       mGeolocationPermissionCallback = callback;
1614     }
1615   }
1616
1617   void RegisterFrameRenderedCallback(Dali::WebEnginePlugin::WebEngineFrameRenderedCallback callback)
1618   {
1619     mFrameRenderedCallback = callback;
1620   }
1621
1622   void RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
1623   {
1624     mPageLoadStartedCallback = callback;
1625   }
1626
1627   void RegisterPageLoadInProgressCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
1628   {
1629     mPageLoadInProgressCallback = callback;
1630   }
1631
1632   void RegisterPageLoadFinishedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
1633   {
1634     mPageLoadFinishedCallback = callback;
1635   }
1636
1637   void RegisterPageLoadErrorCallback(Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback callback)
1638   {
1639     mPageLoadErrorCallback = callback;
1640   }
1641
1642   void RegisterScrollEdgeReachedCallback(Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback callback)
1643   {
1644     mScrollEdgeReachedCallback = callback;
1645   }
1646
1647   void RegisterUrlChangedCallback(Dali::WebEnginePlugin::WebEngineUrlChangedCallback callback)
1648   {
1649     mUrlChangedCallback = callback;
1650   }
1651
1652   void RegisterFormRepostDecidedCallback(Dali::WebEnginePlugin::WebEngineFormRepostDecidedCallback callback)
1653   {
1654     mFormRepostDecidedCallback = callback;
1655   }
1656
1657   void RegisterConsoleMessageReceivedCallback(Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback callback)
1658   {
1659     mConsoleMessageCallback = callback;
1660   }
1661
1662   void RegisterResponsePolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback callback)
1663   {
1664     mResponsePolicyDecisionCallback = callback;
1665   }
1666
1667   void RegisterNavigationPolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback callback)
1668   {
1669     mNavigationPolicyDecisionCallback = callback;
1670   }
1671
1672   void RegisterNewWindowCreatedCallback(Dali::WebEnginePlugin::WebEngineNewWindowCreatedCallback callback)
1673   {
1674     mNewWindowCreatedCallback = callback;
1675   }
1676
1677   void RegisterCertificateConfirmedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
1678   {
1679     mCertificateConfirmCallback = callback;
1680   }
1681
1682   void RegisterSslCertificateChangedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
1683   {
1684     mSslCertificateChangedCallback = callback;
1685   }
1686
1687   void RegisterHttpAuthHandlerCallback(Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback callback)
1688   {
1689     mHttpAuthHandlerCallback = callback;
1690   }
1691
1692   void RegisterContextMenuShownCallback(Dali::WebEnginePlugin::WebEngineContextMenuShownCallback callback)
1693   {
1694     mContextMenuShownCallback = callback;
1695   }
1696
1697   void RegisterContextMenuHiddenCallback(Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback callback)
1698   {
1699     mContextMenuHiddenCallback = callback;
1700   }
1701
1702   void GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
1703   {
1704     if (callback)
1705     {
1706       ConnectToGlobalSignal(&OnPlainTextReceived);
1707       mPlainTextReceivedCallback = callback;
1708     }
1709   }
1710
1711   std::string              mUrl;
1712   std::vector<std::string> mHistory;
1713   size_t                   mCurrentPlusOnePos;
1714   std::string              mUserAgent;
1715
1716   bool  mEvaluating;
1717   float mPageZoomFactor;
1718   float mTextZoomFactor;
1719   float mScaleFactor;
1720
1721   Dali::Vector2             mScrollPosition;
1722   Dali::Vector2             mScrollSize;
1723   Dali::Vector2             mContentSize;
1724   WebEngineBackForwardList* mockWebEngineBackForwardList;
1725   WebEngineSettings*        mockWebEngineSettings;
1726
1727   std::vector<Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback> mResultCallbacks;
1728
1729   Dali::WebEnginePlugin::WebEnginePageLoadCallback                mPageLoadStartedCallback;
1730   Dali::WebEnginePlugin::WebEnginePageLoadCallback                mPageLoadInProgressCallback;
1731   Dali::WebEnginePlugin::WebEnginePageLoadCallback                mPageLoadFinishedCallback;
1732   Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback           mPageLoadErrorCallback;
1733   Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback       mScrollEdgeReachedCallback;
1734   Dali::WebEnginePlugin::WebEngineUrlChangedCallback              mUrlChangedCallback;
1735   Dali::WebEnginePlugin::WebEngineFormRepostDecidedCallback       mFormRepostDecidedCallback;
1736   Dali::WebEnginePlugin::WebEngineFrameRenderedCallback           mFrameRenderedCallback;
1737   Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback  mConsoleMessageCallback;
1738   Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback   mResponsePolicyDecisionCallback;
1739   Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback mNavigationPolicyDecisionCallback;
1740   Dali::WebEnginePlugin::WebEngineNewWindowCreatedCallback        mNewWindowCreatedCallback;
1741   Dali::WebEnginePlugin::WebEngineCertificateCallback             mCertificateConfirmCallback;
1742   Dali::WebEnginePlugin::WebEngineCertificateCallback             mSslCertificateChangedCallback;
1743   Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback         mHttpAuthHandlerCallback;
1744   Dali::WebEnginePlugin::WebEngineContextMenuShownCallback        mContextMenuShownCallback;
1745   Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback       mContextMenuHiddenCallback;
1746   Dali::WebEnginePlugin::JavaScriptAlertCallback                  mJavaScriptAlertCallback;
1747   Dali::WebEnginePlugin::JavaScriptConfirmCallback                mJavaScriptConfirmCallback;
1748   Dali::WebEnginePlugin::JavaScriptPromptCallback                 mJavaScriptPromptCallback;
1749   Dali::WebEnginePlugin::ScreenshotCapturedCallback               mScreenshotCapturedCallback;
1750   Dali::WebEnginePlugin::VideoPlayingCallback                     mVideoPlayingCallback;
1751   Dali::WebEnginePlugin::GeolocationPermissionCallback            mGeolocationPermissionCallback;
1752   Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback          mHitTestCreatedCallback;
1753   Dali::WebEnginePlugin::PlainTextReceivedCallback                mPlainTextReceivedCallback;
1754 };
1755
1756
1757 namespace
1758 {
1759
1760 bool OnGoBack()
1761 {
1762   DisconnectFromGlobalSignal( &OnGoBack );
1763
1764   if( gInstance && gInstance->CanGoBack() )
1765   {
1766     gInstance->mCurrentPlusOnePos--;
1767   }
1768   return false;
1769 }
1770
1771 bool OnGoForward()
1772 {
1773   DisconnectFromGlobalSignal( &OnGoForward );
1774
1775   if( gInstance && gInstance->CanGoForward() )
1776   {
1777     gInstance->mCurrentPlusOnePos++;
1778   }
1779   return false;
1780 }
1781
1782 bool OnLoadUrl()
1783 {
1784   DisconnectFromGlobalSignal( &OnLoadUrl );
1785
1786   if( gInstance )
1787   {
1788     if( gInstance->mHistory.size() > gInstance->mCurrentPlusOnePos )
1789     {
1790       gInstance->mHistory.erase( gInstance->mHistory.begin() + gInstance->mCurrentPlusOnePos, gInstance->mHistory.end() );
1791     }
1792     gInstance->mHistory.push_back( gInstance->mUrl );
1793     gInstance->mCurrentPlusOnePos++;
1794     if (gInstance->mPageLoadStartedCallback)
1795     {
1796       gInstance->mPageLoadStartedCallback( gInstance->mUrl );
1797     }
1798     if (gInstance->mPageLoadInProgressCallback)
1799     {
1800       gInstance->mPageLoadInProgressCallback( gInstance->mUrl );
1801     }
1802     if (gInstance->mPageLoadFinishedCallback)
1803     {
1804       gInstance->mPageLoadFinishedCallback( gInstance->mUrl );
1805     }
1806     if (gInstance->mPageLoadErrorCallback)
1807     {
1808       std::unique_ptr<Dali::WebEngineLoadError> error(new MockWebEngineLoadError(gInstance->mUrl));
1809       gInstance->mPageLoadErrorCallback(std::move(error));
1810     }
1811     if (gInstance->mUrlChangedCallback)
1812     {
1813       gInstance->mUrlChangedCallback( "http://new-test" );
1814     }
1815     if (gInstance->mFormRepostDecidedCallback)
1816     {
1817       std::unique_ptr<Dali::WebEngineFormRepostDecision> repostDecision(new MockWebEngineFormRepostDecision());
1818       gInstance->mFormRepostDecidedCallback(std::move(repostDecision));
1819     }
1820     if (gInstance->mFrameRenderedCallback)
1821     {
1822       gInstance->mFrameRenderedCallback();
1823     }
1824     if (gInstance->mConsoleMessageCallback)
1825     {
1826       std::unique_ptr<Dali::WebEngineConsoleMessage> message(new MockWebEngineConsoleMessage());
1827       gInstance->mConsoleMessageCallback(std::move(message));
1828     }
1829     if (gInstance->mResponsePolicyDecisionCallback)
1830     {
1831       std::unique_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
1832       gInstance->mResponsePolicyDecisionCallback(std::move(policyDecision));
1833     }
1834     if (gInstance->mNavigationPolicyDecisionCallback)
1835     {
1836       std::unique_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
1837       gInstance->mNavigationPolicyDecisionCallback(std::move(policyDecision));
1838     }
1839     if (gInstance->mNewWindowCreatedCallback)
1840     {
1841       Dali::WebEnginePlugin* plugin = 0;
1842       gInstance->mNewWindowCreatedCallback(plugin);
1843     }
1844     if (gInstance->mCertificateConfirmCallback)
1845     {
1846       std::unique_ptr<Dali::WebEngineCertificate> certificate(new MockWebEngineCertificate());
1847       gInstance->mCertificateConfirmCallback(std::move(certificate));
1848     }
1849     if (gInstance->mSslCertificateChangedCallback)
1850     {
1851       std::unique_ptr<Dali::WebEngineCertificate> sslCertificate(new MockWebEngineCertificate());
1852       gInstance->mSslCertificateChangedCallback(std::move(sslCertificate));
1853     }
1854     if (gInstance->mHttpAuthHandlerCallback)
1855     {
1856       std::unique_ptr<Dali::WebEngineHttpAuthHandler> handler(new MockWebEngineHttpAuthHandler());
1857       gInstance->mHttpAuthHandlerCallback(std::move(handler));
1858     }
1859     if (gInstance->mContextMenuShownCallback)
1860     {
1861       std::unique_ptr<Dali::WebEngineContextMenu> menu(new MockWebEngineContextMenu());
1862       gInstance->mContextMenuShownCallback(std::move(menu));
1863     }
1864     if (gInstance->mContextMenuHiddenCallback)
1865     {
1866       std::unique_ptr<Dali::WebEngineContextMenu> hiddenMenu(new MockWebEngineContextMenu());
1867       gInstance->mContextMenuHiddenCallback(std::move(hiddenMenu));
1868     }
1869   }
1870   return false;
1871 }
1872
1873 bool OnScrollEdge()
1874 {
1875   DisconnectFromGlobalSignal( &OnScrollEdge );
1876
1877   if( gInstance && gInstance->mScrollEdgeReachedCallback )
1878   {
1879     gInstance->mScrollEdgeReachedCallback( Dali::WebEnginePlugin::ScrollEdge::BOTTOM );
1880   }
1881
1882   return false;
1883 }
1884
1885 bool OnEvaluteJavaScript()
1886 {
1887   DisconnectFromGlobalSignal( &OnEvaluteJavaScript );
1888
1889   if( gInstance )
1890   {
1891     for( auto& func : gInstance->mResultCallbacks )
1892     {
1893       func("undefined");
1894     }
1895     gInstance->mResultCallbacks.clear();
1896   }
1897   return false;
1898 }
1899
1900 bool OnJavaScriptAlert()
1901 {
1902   DisconnectFromGlobalSignal( &OnJavaScriptAlert );
1903   if ( gInstance )
1904   {
1905     gInstance->mJavaScriptAlertCallback( "this is an alert popup." );
1906   }
1907   return false;
1908 }
1909
1910 bool OnJavaScriptConfirm()
1911 {
1912   DisconnectFromGlobalSignal( &OnJavaScriptConfirm );
1913   if ( gInstance )
1914   {
1915     gInstance->mJavaScriptConfirmCallback( "this is a confirm popup." );
1916   }
1917   return false;
1918 }
1919
1920 bool OnJavaScriptPrompt()
1921 {
1922   DisconnectFromGlobalSignal( &OnJavaScriptPrompt );
1923   if ( gInstance )
1924   {
1925     gInstance->mJavaScriptPromptCallback( "this is a prompt pompt.", "" );
1926   }
1927   return false;
1928 }
1929
1930 bool OnScreenshotCaptured()
1931 {
1932   DisconnectFromGlobalSignal( &OnScreenshotCaptured );
1933   if ( gInstance )
1934   {
1935     uint8_t* pixel = new uint8_t[ 2 * 2 * 4 ];
1936     memset(pixel, 0xff, 2 * 2 * 4);
1937     Dali::PixelData data = Dali::PixelData::New( pixel, 2 * 2 * 4, 2, 2,
1938                                  Dali::Pixel::Format::RGBA8888,
1939                                  Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
1940     gInstance->mScreenshotCapturedCallback( data );
1941   }
1942   return false;
1943 }
1944
1945 bool OnVideoPlaying()
1946 {
1947   DisconnectFromGlobalSignal( &OnVideoPlaying );
1948   if ( gInstance )
1949   {
1950     gInstance->mVideoPlayingCallback( true );
1951   }
1952   return false;
1953 }
1954
1955 bool OnGeolocationPermission()
1956 {
1957   DisconnectFromGlobalSignal( &OnGeolocationPermission );
1958   if ( gInstance )
1959   {
1960     gInstance->mGeolocationPermissionCallback( "", "" );
1961   }
1962   return false;
1963 }
1964
1965 bool OnHitTestCreated()
1966 {
1967   DisconnectFromGlobalSignal(&OnHitTestCreated);
1968   if (gInstance)
1969   {
1970     std::unique_ptr<Dali::WebEngineHitTest> test(new MockWebEngineHitTest());
1971     gInstance->mHitTestCreatedCallback(std::move(test));
1972   }
1973   return false;
1974 }
1975
1976 bool OnClearHistory()
1977 {
1978   DisconnectFromGlobalSignal( &OnClearHistory );
1979
1980   if( gInstance && gInstance->mCurrentPlusOnePos )
1981   {
1982     std::string url = gInstance->mHistory[ gInstance->mCurrentPlusOnePos - 1 ];
1983     std::vector< std::string >().swap( gInstance->mHistory );
1984     gInstance->mHistory.push_back( url );
1985     gInstance->mCurrentPlusOnePos = 1;
1986   }
1987   return false;
1988 }
1989
1990 bool OnSecurityOriginAcquired()
1991 {
1992   DisconnectFromGlobalSignal(&OnSecurityOriginAcquired);
1993   if (gWebEngineContextInstance)
1994   {
1995     std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>> securityOriginList;
1996     std::unique_ptr<Dali::WebEngineSecurityOrigin> origin(new MockWebEngineSecurityOrigin());
1997     securityOriginList.push_back(std::move(origin));
1998     gWebEngineContextInstance->mSecurityOriginAcquiredCallback(securityOriginList);
1999   }
2000   return false;
2001 }
2002
2003 bool OnStorageUsageAcquired()
2004 {
2005   DisconnectFromGlobalSignal(&OnStorageUsageAcquired);
2006   if (gWebEngineContextInstance)
2007   {
2008     gWebEngineContextInstance->mStorageUsageAcquiredCallback(0);
2009   }
2010   return false;
2011 }
2012
2013 bool OnFormPasswordAcquired()
2014 {
2015   DisconnectFromGlobalSignal(&OnFormPasswordAcquired);
2016   if (gWebEngineContextInstance)
2017   {
2018     std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>> formPasswordList;
2019     std::unique_ptr<Dali::WebEngineContext::PasswordData> data(new Dali::WebEngineContext::PasswordData());
2020     data->url = "http://test.html";
2021     data->useFingerprint = false;
2022     formPasswordList.push_back(std::move(data));
2023     gWebEngineContextInstance->mFormPasswordAcquiredCallback(formPasswordList);
2024   }
2025   return false;
2026 }
2027
2028 bool OnDownloadStarted()
2029 {
2030   DisconnectFromGlobalSignal(&OnDownloadStarted);
2031   if (gWebEngineContextInstance)
2032   {
2033     gWebEngineContextInstance->mDownloadStartedCallback("http://test.html");
2034   }
2035   return false;
2036 }
2037
2038 bool OnMimeOverridden()
2039 {
2040   DisconnectFromGlobalSignal(&OnMimeOverridden);
2041   if (gWebEngineContextInstance)
2042   {
2043     std::string newMime;
2044     gWebEngineContextInstance->mMimeOverriddenCallback("http://test.html", "txt/xml", newMime);
2045   }
2046   return false;
2047 }
2048
2049 bool OnRequestIntercepted()
2050 {
2051   DisconnectFromGlobalSignal(&OnRequestIntercepted);
2052   if (gWebEngineContextInstance)
2053   {
2054     Dali::WebEngineRequestInterceptorPtr interceptor = new MockWebEngineRequestInterceptor();
2055     gWebEngineContextInstance->mRequestInterceptedCallback(interceptor);
2056   }
2057   return false;
2058 }
2059
2060 bool OnChangesWatch()
2061 {
2062   DisconnectFromGlobalSignal(&OnChangesWatch);
2063   if (gMockWebEngineCookieManager)
2064   {
2065     gMockWebEngineCookieManager->mChangesWatchCallback();
2066   }
2067   return false;
2068 }
2069
2070 bool OnPlainTextReceived()
2071 {
2072   DisconnectFromGlobalSignal(&OnPlainTextReceived);
2073   if (gInstance)
2074   {
2075     std::string dummyResultText;
2076     gInstance->mPlainTextReceivedCallback(dummyResultText);
2077   }
2078   return false;
2079 }
2080
2081 } // namespace
2082
2083 inline WebEngine& GetImplementation( Dali::WebEngine& webEngine )
2084 {
2085   DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
2086   BaseObject& handle = webEngine.GetBaseObject();
2087   return static_cast< Internal::Adaptor::WebEngine& >( handle );
2088 }
2089
2090 inline const WebEngine& GetImplementation( const Dali::WebEngine& webEngine )
2091 {
2092   DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
2093   const BaseObject& handle = webEngine.GetBaseObject();
2094   return static_cast< const Internal::Adaptor::WebEngine& >( handle );
2095 }
2096
2097 } // namespace Adaptor
2098
2099 } // namespace Internal
2100
2101 // Dali::WebEngine Implementation
2102 WebEngine::WebEngine()
2103 {
2104 }
2105
2106 WebEngine::WebEngine( Internal::Adaptor::WebEngine* internal )
2107 : BaseHandle( internal )
2108 {
2109 }
2110
2111 WebEngine::~WebEngine()
2112 {
2113 }
2114
2115 WebEngine WebEngine::New()
2116 {
2117   Internal::Adaptor::WebEngine* baseObject = new Internal::Adaptor::WebEngine();
2118
2119   return WebEngine( baseObject );
2120 }
2121
2122 Dali::WebEngineContext* WebEngine::GetContext()
2123 {
2124   return Internal::Adaptor::GetContext();
2125 }
2126
2127 Dali::WebEngineCookieManager* WebEngine::GetCookieManager()
2128 {
2129   return Internal::Adaptor::GetCookieManager();
2130 }
2131
2132 WebEngine::WebEngine( const WebEngine& WebEngine )
2133 : BaseHandle( WebEngine )
2134 {
2135 }
2136
2137 WebEngine& WebEngine::operator=( const WebEngine& webEngine )
2138 {
2139   BaseHandle::operator=( webEngine );
2140   return *this;
2141 }
2142
2143 WebEngine WebEngine::DownCast( BaseHandle handle )
2144 {
2145   return WebEngine( dynamic_cast< Internal::Adaptor::WebEngine* >( handle.GetObjectPtr() ) );
2146 }
2147
2148 void WebEngine::Create( uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneId )
2149 {
2150 }
2151
2152 void WebEngine::Create( uint32_t width, uint32_t height, uint32_t argc, char** argv )
2153 {
2154 }
2155
2156 void WebEngine::Destroy()
2157 {
2158 }
2159
2160 WebEngineSettings& WebEngine::GetSettings() const
2161 {
2162   return Internal::Adaptor::GetImplementation( *this ).GetSettings();
2163 }
2164
2165 WebEngineBackForwardList& WebEngine::GetBackForwardList() const
2166 {
2167   return Internal::Adaptor::GetImplementation( *this ).GetBackForwardList();
2168 }
2169
2170 void WebEngine::LoadUrl( const std::string& url )
2171 {
2172   return Internal::Adaptor::GetImplementation( *this ).LoadUrl( url );
2173 }
2174
2175 std::string WebEngine::GetTitle() const
2176 {
2177   return Internal::Adaptor::GetImplementation( *this ).GetTitle();
2178 }
2179
2180 Dali::PixelData WebEngine::GetFavicon() const
2181 {
2182   return Internal::Adaptor::GetImplementation( *this ).GetFavicon();
2183 }
2184
2185 std::string WebEngine::GetUrl() const
2186 {
2187   return Internal::Adaptor::GetImplementation( *this ).GetUrl();
2188 }
2189
2190 Dali::WebEnginePlugin* WebEngine::GetPlugin() const
2191 {
2192   return Internal::Adaptor::GetWebEnginePlugin();
2193 }
2194
2195 NativeImageSourcePtr WebEngine::GetNativeImageSource()
2196 {
2197   Any source;
2198   Dali::NativeImageSourcePtr sourcePtr = Dali::NativeImageSource::New( source );
2199   return sourcePtr;
2200 }
2201
2202 void WebEngine::LoadHtmlString( const std::string& htmlString )
2203 {
2204 }
2205
2206 bool WebEngine::LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl)
2207 {
2208   return true;
2209 }
2210
2211 bool WebEngine::LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri)
2212 {
2213   return true;
2214 }
2215
2216 void WebEngine::Reload()
2217 {
2218 }
2219
2220 bool WebEngine::ReloadWithoutCache()
2221 {
2222   return true;
2223 }
2224
2225 void WebEngine::StopLoading()
2226 {
2227 }
2228
2229 void WebEngine::Suspend()
2230 {
2231 }
2232
2233 void WebEngine::Resume()
2234 {
2235 }
2236
2237 void WebEngine::SuspendNetworkLoading()
2238 {
2239 }
2240
2241 void WebEngine::ResumeNetworkLoading()
2242 {
2243 }
2244
2245 bool WebEngine::AddCustomHeader(const std::string& name, const std::string& value)
2246 {
2247   return true;
2248 }
2249
2250 bool WebEngine::RemoveCustomHeader(const std::string& name)
2251 {
2252   return true;
2253 }
2254
2255 uint32_t WebEngine::StartInspectorServer(uint32_t port)
2256 {
2257   return port;
2258 }
2259
2260 bool WebEngine::StopInspectorServer()
2261 {
2262   return true;
2263 }
2264
2265 bool WebEngine::CanGoForward()
2266 {
2267   return Internal::Adaptor::GetImplementation( *this ).CanGoForward();
2268 }
2269
2270 void WebEngine::GoForward()
2271 {
2272   Internal::Adaptor::GetImplementation( *this ).GoForward();
2273 }
2274
2275 bool WebEngine::CanGoBack()
2276 {
2277   return Internal::Adaptor::GetImplementation( *this ).CanGoBack();
2278 }
2279
2280 void WebEngine::GoBack()
2281 {
2282   Internal::Adaptor::GetImplementation( *this ).GoBack();
2283 }
2284
2285 void WebEngine::EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler )
2286 {
2287   Internal::Adaptor::GetImplementation( *this ).EvaluateJavaScript( script, resultHandler );
2288 }
2289
2290 void WebEngine::AddJavaScriptMessageHandler( const std::string& exposedObjectName, std::function< void(const std::string&) > handler )
2291 {
2292 }
2293
2294 void WebEngine::RegisterJavaScriptAlertCallback( Dali::WebEnginePlugin::JavaScriptAlertCallback callback )
2295 {
2296   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptAlertCallback( callback );
2297 }
2298
2299 void WebEngine::JavaScriptAlertReply()
2300 {
2301 }
2302
2303 void WebEngine::RegisterJavaScriptConfirmCallback( Dali::WebEnginePlugin::JavaScriptConfirmCallback callback )
2304 {
2305   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptConfirmCallback( callback );
2306 }
2307
2308 void WebEngine::JavaScriptConfirmReply( bool confirmed )
2309 {
2310 }
2311
2312 void WebEngine::RegisterJavaScriptPromptCallback( Dali::WebEnginePlugin::JavaScriptPromptCallback callback )
2313 {
2314   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptPromptCallback( callback );
2315 }
2316
2317 void WebEngine::JavaScriptPromptReply( const std::string& result )
2318 {
2319 }
2320
2321 std::unique_ptr<Dali::WebEngineHitTest> WebEngine::CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
2322 {
2323   return Internal::Adaptor::GetImplementation(*this).CreateHitTest(x, y, mode);
2324 }
2325
2326 bool WebEngine::CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
2327 {
2328   return Internal::Adaptor::GetImplementation(*this).CreateHitTestAsynchronously(x, y, mode, callback);
2329 }
2330
2331 void WebEngine::ClearAllTilesResources()
2332 {
2333 }
2334
2335 void WebEngine::ClearHistory()
2336 {
2337   Internal::Adaptor::GetImplementation( *this ).ClearHistory();
2338 }
2339
2340 void WebEngine::SetScaleFactor(float scaleFactor, Dali::Vector2 point)
2341 {
2342   Internal::Adaptor::GetImplementation( *this ).SetScaleFactor(scaleFactor, point);
2343 }
2344
2345 float WebEngine::GetScaleFactor() const
2346 {
2347   return Internal::Adaptor::GetImplementation( *this ).GetScaleFactor();
2348 }
2349
2350 void WebEngine::ActivateAccessibility(bool activated)
2351 {
2352 }
2353
2354 Accessibility::Address WebEngine::GetAccessibilityAddress()
2355 {
2356   return Internal::Adaptor::GetImplementation(*this).GetAccessibilityAddress();
2357 }
2358
2359 bool WebEngine::HighlightText(const std::string& text, Dali::WebEnginePlugin::FindOption options, uint32_t maxMatchCount)
2360 {
2361   return true;
2362 }
2363
2364 void WebEngine::AddDynamicCertificatePath(const std::string& host, const std::string& certPath)
2365 {
2366 }
2367
2368 Dali::PixelData WebEngine::GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
2369 {
2370   return Internal::Adaptor::GetImplementation( *this ).GetScreenshot(viewArea, scaleFactor);
2371 }
2372
2373 bool WebEngine::GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
2374 {
2375   return Internal::Adaptor::GetImplementation( *this ).GetScreenshotAsynchronously(viewArea, scaleFactor, callback);
2376 }
2377
2378 bool WebEngine::CheckVideoPlayingAsynchronously(Dali::WebEnginePlugin::VideoPlayingCallback callback)
2379 {
2380   return Internal::Adaptor::GetImplementation( *this ).CheckVideoPlayingAsynchronously(callback);
2381 }
2382
2383 void WebEngine::RegisterGeolocationPermissionCallback(Dali::WebEnginePlugin::GeolocationPermissionCallback callback)
2384 {
2385   Internal::Adaptor::GetImplementation( *this ).RegisterGeolocationPermissionCallback(callback);
2386 }
2387
2388 std::string WebEngine::GetUserAgent() const
2389 {
2390   return Internal::Adaptor::GetImplementation( *this ).GetUserAgent();
2391 }
2392
2393 void WebEngine::SetUserAgent( const std::string& userAgent )
2394 {
2395   Internal::Adaptor::GetImplementation( *this ).SetUserAgent( userAgent );
2396 }
2397
2398 void WebEngine::ScrollBy( int32_t dx, int32_t dy )
2399 {
2400   Internal::Adaptor::GetImplementation( *this ).ScrollBy( dx, dy );
2401 }
2402
2403 bool WebEngine::ScrollEdgeBy( int32_t dx, int32_t dy )
2404 {
2405   return Internal::Adaptor::GetImplementation( *this ).ScrollEdgeBy( dx, dy );
2406 }
2407
2408 void WebEngine::SetScrollPosition( int32_t x, int32_t y )
2409 {
2410   Internal::Adaptor::GetImplementation( *this ).SetScrollPosition( x, y );
2411 }
2412
2413 Dali::Vector2 WebEngine::GetScrollPosition() const
2414 {
2415   return Internal::Adaptor::GetImplementation( *this ).GetScrollPosition();
2416 }
2417
2418 Dali::Vector2 WebEngine::GetScrollSize() const
2419 {
2420   return Internal::Adaptor::GetImplementation( *this ).GetScrollSize();
2421 }
2422
2423 Dali::Vector2 WebEngine::GetContentSize() const
2424 {
2425   return Internal::Adaptor::GetImplementation( *this ).GetContentSize();
2426 }
2427
2428 void WebEngine::SetSize( uint32_t width, uint32_t height )
2429 {
2430 }
2431
2432 void WebEngine::SetDocumentBackgroundColor(Dali::Vector4 color)
2433 {
2434 }
2435
2436 void WebEngine::ClearTilesWhenHidden(bool cleared)
2437 {
2438 }
2439
2440 void WebEngine::SetTileCoverAreaMultiplier(float multiplier)
2441 {
2442 }
2443
2444 void WebEngine::EnableCursorByClient(bool enabled)
2445 {
2446 }
2447
2448 std::string WebEngine::GetSelectedText() const
2449 {
2450   return "test";
2451 }
2452
2453 bool WebEngine::SendTouchEvent( const TouchEvent& touch )
2454 {
2455   return true;
2456 }
2457
2458 bool WebEngine::SendKeyEvent( const KeyEvent& event )
2459 {
2460   return true;
2461 }
2462
2463 bool WebEngine::SendHoverEvent( const HoverEvent& event )
2464 {
2465   return true;
2466 }
2467
2468 bool WebEngine::SendWheelEvent( const WheelEvent& event )
2469 {
2470   return true;
2471 }
2472
2473 void WebEngine::SetFocus( bool focused )
2474 {
2475 }
2476
2477 void WebEngine::SetPageZoomFactor(float zoomFactor)
2478 {
2479   Internal::Adaptor::GetImplementation( *this ).SetPageZoomFactor(zoomFactor);
2480 }
2481
2482 float WebEngine::GetPageZoomFactor() const
2483 {
2484   return Internal::Adaptor::GetImplementation( *this ).GetPageZoomFactor();
2485 }
2486
2487 void WebEngine::SetTextZoomFactor(float zoomFactor)
2488 {
2489   Internal::Adaptor::GetImplementation( *this ).SetTextZoomFactor(zoomFactor);
2490 }
2491
2492 float WebEngine::GetTextZoomFactor() const
2493 {
2494   return Internal::Adaptor::GetImplementation( *this ).GetTextZoomFactor();
2495 }
2496
2497 float WebEngine::GetLoadProgressPercentage() const
2498 {
2499   return Internal::Adaptor::GetImplementation( *this ).GetLoadProgressPercentage();
2500 }
2501
2502 void WebEngine::UpdateDisplayArea( Dali::Rect< int32_t > displayArea )
2503 {
2504 }
2505
2506 void WebEngine::EnableVideoHole( bool enabled )
2507 {
2508 }
2509
2510 void WebEngine::EnableMouseEvents( bool enabled )
2511 {
2512 }
2513
2514 void WebEngine::EnableKeyEvents( bool enabled )
2515 {
2516 }
2517
2518 void WebEngine::RegisterFrameRenderedCallback(Dali::WebEnginePlugin::WebEngineFrameRenderedCallback callback)
2519 {
2520   Internal::Adaptor::GetImplementation(*this).RegisterFrameRenderedCallback(callback);
2521 }
2522
2523 void WebEngine::RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
2524 {
2525   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadStartedCallback(callback);
2526 }
2527
2528 void WebEngine::RegisterPageLoadInProgressCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
2529 {
2530   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadInProgressCallback(callback);
2531 }
2532
2533 void WebEngine::RegisterPageLoadFinishedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
2534 {
2535   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadFinishedCallback(callback);
2536 }
2537
2538 void WebEngine::RegisterPageLoadErrorCallback(Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback callback)
2539 {
2540   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadErrorCallback(callback);
2541 }
2542
2543 void WebEngine::RegisterScrollEdgeReachedCallback(Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback callback)
2544 {
2545   Internal::Adaptor::GetImplementation( *this ).RegisterScrollEdgeReachedCallback(callback);
2546 }
2547
2548 void WebEngine::RegisterUrlChangedCallback(Dali::WebEnginePlugin::WebEngineUrlChangedCallback callback)
2549 {
2550   Internal::Adaptor::GetImplementation( *this ).RegisterUrlChangedCallback(callback);
2551 }
2552
2553 void WebEngine::RegisterFormRepostDecidedCallback(Dali::WebEnginePlugin::WebEngineFormRepostDecidedCallback callback)
2554 {
2555   Internal::Adaptor::GetImplementation( *this ).RegisterFormRepostDecidedCallback(callback);
2556 }
2557
2558 void WebEngine::RegisterConsoleMessageReceivedCallback(Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback callback)
2559 {
2560   Internal::Adaptor::GetImplementation( *this ).RegisterConsoleMessageReceivedCallback(callback);
2561 }
2562
2563 void WebEngine::RegisterResponsePolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback callback)
2564 {
2565   Internal::Adaptor::GetImplementation( *this ).RegisterResponsePolicyDecidedCallback(callback);
2566 }
2567
2568 void WebEngine::RegisterNavigationPolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback callback)
2569 {
2570   Internal::Adaptor::GetImplementation(*this).RegisterNavigationPolicyDecidedCallback(callback);
2571 }
2572
2573 void WebEngine::RegisterNewWindowCreatedCallback(Dali::WebEnginePlugin::WebEngineNewWindowCreatedCallback callback)
2574 {
2575   Internal::Adaptor::GetImplementation(*this).RegisterNewWindowCreatedCallback(callback);
2576 }
2577
2578 void WebEngine::RegisterCertificateConfirmedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
2579 {
2580   Internal::Adaptor::GetImplementation( *this ).RegisterCertificateConfirmedCallback(callback);
2581 }
2582
2583 void WebEngine::RegisterSslCertificateChangedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
2584 {
2585   Internal::Adaptor::GetImplementation( *this ).RegisterSslCertificateChangedCallback(callback);
2586 }
2587
2588 void WebEngine::RegisterHttpAuthHandlerCallback(Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback callback)
2589 {
2590   Internal::Adaptor::GetImplementation( *this ).RegisterHttpAuthHandlerCallback(callback);
2591 }
2592
2593 void WebEngine::RegisterContextMenuShownCallback(Dali::WebEnginePlugin::WebEngineContextMenuShownCallback callback)
2594 {
2595   Internal::Adaptor::GetImplementation( *this ).RegisterContextMenuShownCallback(callback);
2596 }
2597
2598 void WebEngine::RegisterContextMenuHiddenCallback(Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback callback)
2599 {
2600   Internal::Adaptor::GetImplementation( *this ).RegisterContextMenuHiddenCallback(callback);
2601 }
2602
2603 void WebEngine::GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
2604 {
2605   Internal::Adaptor::GetImplementation(*this).GetPlainTextAsynchronously(callback);
2606 }
2607
2608 } // namespace Dali;