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

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