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   WebEngineFrameRenderedSignalType& FrameRenderedSignal() override { return frameRenderedSignal; }
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 RegisterCertificateConfirmedCallback(WebEngineCertificateCallback callback) override {}
1244   void RegisterSslCertificateChangedCallback(WebEngineCertificateCallback callback) override {}
1245   void RegisterHttpAuthHandlerCallback(WebEngineHttpAuthHandlerCallback callback) override {}
1246   void RegisterContextMenuShownCallback(WebEngineContextMenuShownCallback callback) override {}
1247   void RegisterContextMenuHiddenCallback(WebEngineContextMenuHiddenCallback callback) override {}
1248   void GetPlainTextAsynchronously(PlainTextReceivedCallback callback) override {}
1249 private:
1250   MockWebEngineSettings settings;
1251   MockWebEngineBackForwardList backForwardList;
1252   WebEngineFrameRenderedSignalType frameRenderedSignal;
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   Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& FrameRenderedSignal()
1618   {
1619     return mFrameRenderedSignal;
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 RegisterCertificateConfirmedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
1673   {
1674     mCertificateConfirmCallback = callback;
1675   }
1676
1677   void RegisterSslCertificateChangedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
1678   {
1679     mSslCertificateChangedCallback = callback;
1680   }
1681
1682   void RegisterHttpAuthHandlerCallback(Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback callback)
1683   {
1684     mHttpAuthHandlerCallback = callback;
1685   }
1686
1687   void RegisterContextMenuShownCallback(Dali::WebEnginePlugin::WebEngineContextMenuShownCallback callback)
1688   {
1689     mContextMenuShownCallback = callback;
1690   }
1691
1692   void RegisterContextMenuHiddenCallback(Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback callback)
1693   {
1694     mContextMenuHiddenCallback = callback;
1695   }
1696
1697   void GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
1698   {
1699     if (callback)
1700     {
1701       ConnectToGlobalSignal(&OnPlainTextReceived);
1702       mPlainTextReceivedCallback = callback;
1703     }
1704   }
1705
1706   std::string              mUrl;
1707   std::vector<std::string> mHistory;
1708   size_t                   mCurrentPlusOnePos;
1709   std::string              mUserAgent;
1710
1711   Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType mFrameRenderedSignal;
1712
1713   bool  mEvaluating;
1714   float mPageZoomFactor;
1715   float mTextZoomFactor;
1716   float mScaleFactor;
1717
1718   Dali::Vector2             mScrollPosition;
1719   Dali::Vector2             mScrollSize;
1720   Dali::Vector2             mContentSize;
1721   WebEngineBackForwardList* mockWebEngineBackForwardList;
1722   WebEngineSettings*        mockWebEngineSettings;
1723
1724   std::vector<Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback> mResultCallbacks;
1725
1726   Dali::WebEnginePlugin::WebEnginePageLoadCallback                mPageLoadStartedCallback;
1727   Dali::WebEnginePlugin::WebEnginePageLoadCallback                mPageLoadInProgressCallback;
1728   Dali::WebEnginePlugin::WebEnginePageLoadCallback                mPageLoadFinishedCallback;
1729   Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback           mPageLoadErrorCallback;
1730   Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback       mScrollEdgeReachedCallback;
1731   Dali::WebEnginePlugin::WebEngineUrlChangedCallback              mUrlChangedCallback;
1732   Dali::WebEnginePlugin::WebEngineFormRepostDecidedCallback       mFormRepostDecidedCallback;
1733   Dali::WebEnginePlugin::WebEngineFrameRenderedCallback           mFrameRenderedCallback;
1734   Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback  mConsoleMessageCallback;
1735   Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback   mResponsePolicyDecisionCallback;
1736   Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback mNavigationPolicyDecisionCallback;
1737   Dali::WebEnginePlugin::WebEngineCertificateCallback             mCertificateConfirmCallback;
1738   Dali::WebEnginePlugin::WebEngineCertificateCallback             mSslCertificateChangedCallback;
1739   Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback         mHttpAuthHandlerCallback;
1740   Dali::WebEnginePlugin::WebEngineContextMenuShownCallback        mContextMenuShownCallback;
1741   Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback       mContextMenuHiddenCallback;
1742   Dali::WebEnginePlugin::JavaScriptAlertCallback                  mJavaScriptAlertCallback;
1743   Dali::WebEnginePlugin::JavaScriptConfirmCallback                mJavaScriptConfirmCallback;
1744   Dali::WebEnginePlugin::JavaScriptPromptCallback                 mJavaScriptPromptCallback;
1745   Dali::WebEnginePlugin::ScreenshotCapturedCallback               mScreenshotCapturedCallback;
1746   Dali::WebEnginePlugin::VideoPlayingCallback                     mVideoPlayingCallback;
1747   Dali::WebEnginePlugin::GeolocationPermissionCallback            mGeolocationPermissionCallback;
1748   Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback          mHitTestCreatedCallback;
1749   Dali::WebEnginePlugin::PlainTextReceivedCallback                mPlainTextReceivedCallback;
1750 };
1751
1752
1753 namespace
1754 {
1755
1756 bool OnGoBack()
1757 {
1758   DisconnectFromGlobalSignal( &OnGoBack );
1759
1760   if( gInstance && gInstance->CanGoBack() )
1761   {
1762     gInstance->mCurrentPlusOnePos--;
1763   }
1764   return false;
1765 }
1766
1767 bool OnGoForward()
1768 {
1769   DisconnectFromGlobalSignal( &OnGoForward );
1770
1771   if( gInstance && gInstance->CanGoForward() )
1772   {
1773     gInstance->mCurrentPlusOnePos++;
1774   }
1775   return false;
1776 }
1777
1778 bool OnLoadUrl()
1779 {
1780   DisconnectFromGlobalSignal( &OnLoadUrl );
1781
1782   if( gInstance )
1783   {
1784     if( gInstance->mHistory.size() > gInstance->mCurrentPlusOnePos )
1785     {
1786       gInstance->mHistory.erase( gInstance->mHistory.begin() + gInstance->mCurrentPlusOnePos, gInstance->mHistory.end() );
1787     }
1788     gInstance->mHistory.push_back( gInstance->mUrl );
1789     gInstance->mCurrentPlusOnePos++;
1790     if (gInstance->mPageLoadStartedCallback)
1791     {
1792       gInstance->mPageLoadStartedCallback( gInstance->mUrl );
1793     }
1794     if (gInstance->mPageLoadInProgressCallback)
1795     {
1796       gInstance->mPageLoadInProgressCallback( gInstance->mUrl );
1797     }
1798     if (gInstance->mPageLoadFinishedCallback)
1799     {
1800       gInstance->mPageLoadFinishedCallback( gInstance->mUrl );
1801     }
1802     if (gInstance->mPageLoadErrorCallback)
1803     {
1804       std::unique_ptr<Dali::WebEngineLoadError> error(new MockWebEngineLoadError(gInstance->mUrl));
1805       gInstance->mPageLoadErrorCallback(std::move(error));
1806     }
1807     if (gInstance->mUrlChangedCallback)
1808     {
1809       gInstance->mUrlChangedCallback( "http://new-test" );
1810     }
1811     if (gInstance->mFormRepostDecidedCallback)
1812     {
1813       std::unique_ptr<Dali::WebEngineFormRepostDecision> repostDecision(new MockWebEngineFormRepostDecision());
1814       gInstance->mFormRepostDecidedCallback(std::move(repostDecision));
1815     }
1816     gInstance->mFrameRenderedSignal.Emit();
1817     if (gInstance->mFrameRenderedCallback)
1818     {
1819       gInstance->mFrameRenderedCallback();
1820     }
1821     if (gInstance->mConsoleMessageCallback)
1822     {
1823       std::unique_ptr<Dali::WebEngineConsoleMessage> message(new MockWebEngineConsoleMessage());
1824       gInstance->mConsoleMessageCallback(std::move(message));
1825     }
1826     if (gInstance->mResponsePolicyDecisionCallback)
1827     {
1828       std::unique_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
1829       gInstance->mResponsePolicyDecisionCallback(std::move(policyDecision));
1830     }
1831     if (gInstance->mNavigationPolicyDecisionCallback)
1832     {
1833       std::unique_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
1834       gInstance->mNavigationPolicyDecisionCallback(std::move(policyDecision));
1835     }
1836     if (gInstance->mCertificateConfirmCallback)
1837     {
1838       std::unique_ptr<Dali::WebEngineCertificate> certificate(new MockWebEngineCertificate());
1839       gInstance->mCertificateConfirmCallback(std::move(certificate));
1840     }
1841     if (gInstance->mSslCertificateChangedCallback)
1842     {
1843       std::unique_ptr<Dali::WebEngineCertificate> sslCertificate(new MockWebEngineCertificate());
1844       gInstance->mSslCertificateChangedCallback(std::move(sslCertificate));
1845     }
1846     if (gInstance->mHttpAuthHandlerCallback)
1847     {
1848       std::unique_ptr<Dali::WebEngineHttpAuthHandler> handler(new MockWebEngineHttpAuthHandler());
1849       gInstance->mHttpAuthHandlerCallback(std::move(handler));
1850     }
1851     if (gInstance->mContextMenuShownCallback)
1852     {
1853       std::unique_ptr<Dali::WebEngineContextMenu> menu(new MockWebEngineContextMenu());
1854       gInstance->mContextMenuShownCallback(std::move(menu));
1855     }
1856     if (gInstance->mContextMenuHiddenCallback)
1857     {
1858       std::unique_ptr<Dali::WebEngineContextMenu> hiddenMenu(new MockWebEngineContextMenu());
1859       gInstance->mContextMenuHiddenCallback(std::move(hiddenMenu));
1860     }
1861   }
1862   return false;
1863 }
1864
1865 bool OnScrollEdge()
1866 {
1867   DisconnectFromGlobalSignal( &OnScrollEdge );
1868
1869   if( gInstance && gInstance->mScrollEdgeReachedCallback )
1870   {
1871     gInstance->mScrollEdgeReachedCallback( Dali::WebEnginePlugin::ScrollEdge::BOTTOM );
1872   }
1873
1874   return false;
1875 }
1876
1877 bool OnEvaluteJavaScript()
1878 {
1879   DisconnectFromGlobalSignal( &OnEvaluteJavaScript );
1880
1881   if( gInstance )
1882   {
1883     for( auto& func : gInstance->mResultCallbacks )
1884     {
1885       func("undefined");
1886     }
1887     gInstance->mResultCallbacks.clear();
1888   }
1889   return false;
1890 }
1891
1892 bool OnJavaScriptAlert()
1893 {
1894   DisconnectFromGlobalSignal( &OnJavaScriptAlert );
1895   if ( gInstance )
1896   {
1897     gInstance->mJavaScriptAlertCallback( "this is an alert popup." );
1898   }
1899   return false;
1900 }
1901
1902 bool OnJavaScriptConfirm()
1903 {
1904   DisconnectFromGlobalSignal( &OnJavaScriptConfirm );
1905   if ( gInstance )
1906   {
1907     gInstance->mJavaScriptConfirmCallback( "this is a confirm popup." );
1908   }
1909   return false;
1910 }
1911
1912 bool OnJavaScriptPrompt()
1913 {
1914   DisconnectFromGlobalSignal( &OnJavaScriptPrompt );
1915   if ( gInstance )
1916   {
1917     gInstance->mJavaScriptPromptCallback( "this is a prompt pompt.", "" );
1918   }
1919   return false;
1920 }
1921
1922 bool OnScreenshotCaptured()
1923 {
1924   DisconnectFromGlobalSignal( &OnScreenshotCaptured );
1925   if ( gInstance )
1926   {
1927     uint8_t* pixel = new uint8_t[ 2 * 2 * 4 ];
1928     memset(pixel, 0xff, 2 * 2 * 4);
1929     Dali::PixelData data = Dali::PixelData::New( pixel, 2 * 2 * 4, 2, 2,
1930                                  Dali::Pixel::Format::RGBA8888,
1931                                  Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
1932     gInstance->mScreenshotCapturedCallback( data );
1933   }
1934   return false;
1935 }
1936
1937 bool OnVideoPlaying()
1938 {
1939   DisconnectFromGlobalSignal( &OnVideoPlaying );
1940   if ( gInstance )
1941   {
1942     gInstance->mVideoPlayingCallback( true );
1943   }
1944   return false;
1945 }
1946
1947 bool OnGeolocationPermission()
1948 {
1949   DisconnectFromGlobalSignal( &OnGeolocationPermission );
1950   if ( gInstance )
1951   {
1952     gInstance->mGeolocationPermissionCallback( "", "" );
1953   }
1954   return false;
1955 }
1956
1957 bool OnHitTestCreated()
1958 {
1959   DisconnectFromGlobalSignal(&OnHitTestCreated);
1960   if (gInstance)
1961   {
1962     std::unique_ptr<Dali::WebEngineHitTest> test(new MockWebEngineHitTest());
1963     gInstance->mHitTestCreatedCallback(std::move(test));
1964   }
1965   return false;
1966 }
1967
1968 bool OnClearHistory()
1969 {
1970   DisconnectFromGlobalSignal( &OnClearHistory );
1971
1972   if( gInstance && gInstance->mCurrentPlusOnePos )
1973   {
1974     std::string url = gInstance->mHistory[ gInstance->mCurrentPlusOnePos - 1 ];
1975     std::vector< std::string >().swap( gInstance->mHistory );
1976     gInstance->mHistory.push_back( url );
1977     gInstance->mCurrentPlusOnePos = 1;
1978   }
1979   return false;
1980 }
1981
1982 bool OnSecurityOriginAcquired()
1983 {
1984   DisconnectFromGlobalSignal(&OnSecurityOriginAcquired);
1985   if (gWebEngineContextInstance)
1986   {
1987     std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>> securityOriginList;
1988     std::unique_ptr<Dali::WebEngineSecurityOrigin> origin(new MockWebEngineSecurityOrigin());
1989     securityOriginList.push_back(std::move(origin));
1990     gWebEngineContextInstance->mSecurityOriginAcquiredCallback(securityOriginList);
1991   }
1992   return false;
1993 }
1994
1995 bool OnStorageUsageAcquired()
1996 {
1997   DisconnectFromGlobalSignal(&OnStorageUsageAcquired);
1998   if (gWebEngineContextInstance)
1999   {
2000     gWebEngineContextInstance->mStorageUsageAcquiredCallback(0);
2001   }
2002   return false;
2003 }
2004
2005 bool OnFormPasswordAcquired()
2006 {
2007   DisconnectFromGlobalSignal(&OnFormPasswordAcquired);
2008   if (gWebEngineContextInstance)
2009   {
2010     std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>> formPasswordList;
2011     std::unique_ptr<Dali::WebEngineContext::PasswordData> data(new Dali::WebEngineContext::PasswordData());
2012     data->url = "http://test.html";
2013     data->useFingerprint = false;
2014     formPasswordList.push_back(std::move(data));
2015     gWebEngineContextInstance->mFormPasswordAcquiredCallback(formPasswordList);
2016   }
2017   return false;
2018 }
2019
2020 bool OnDownloadStarted()
2021 {
2022   DisconnectFromGlobalSignal(&OnDownloadStarted);
2023   if (gWebEngineContextInstance)
2024   {
2025     gWebEngineContextInstance->mDownloadStartedCallback("http://test.html");
2026   }
2027   return false;
2028 }
2029
2030 bool OnMimeOverridden()
2031 {
2032   DisconnectFromGlobalSignal(&OnMimeOverridden);
2033   if (gWebEngineContextInstance)
2034   {
2035     std::string newMime;
2036     gWebEngineContextInstance->mMimeOverriddenCallback("http://test.html", "txt/xml", newMime);
2037   }
2038   return false;
2039 }
2040
2041 bool OnRequestIntercepted()
2042 {
2043   DisconnectFromGlobalSignal(&OnRequestIntercepted);
2044   if (gWebEngineContextInstance)
2045   {
2046     Dali::WebEngineRequestInterceptorPtr interceptor = new MockWebEngineRequestInterceptor();
2047     gWebEngineContextInstance->mRequestInterceptedCallback(interceptor);
2048   }
2049   return false;
2050 }
2051
2052 bool OnChangesWatch()
2053 {
2054   DisconnectFromGlobalSignal(&OnChangesWatch);
2055   if (gMockWebEngineCookieManager)
2056   {
2057     gMockWebEngineCookieManager->mChangesWatchCallback();
2058   }
2059   return false;
2060 }
2061
2062 bool OnPlainTextReceived()
2063 {
2064   DisconnectFromGlobalSignal(&OnPlainTextReceived);
2065   if (gInstance)
2066   {
2067     std::string dummyResultText;
2068     gInstance->mPlainTextReceivedCallback(dummyResultText);
2069   }
2070   return false;
2071 }
2072
2073 } // namespace
2074
2075 inline WebEngine& GetImplementation( Dali::WebEngine& webEngine )
2076 {
2077   DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
2078   BaseObject& handle = webEngine.GetBaseObject();
2079   return static_cast< Internal::Adaptor::WebEngine& >( handle );
2080 }
2081
2082 inline const WebEngine& GetImplementation( const Dali::WebEngine& webEngine )
2083 {
2084   DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
2085   const BaseObject& handle = webEngine.GetBaseObject();
2086   return static_cast< const Internal::Adaptor::WebEngine& >( handle );
2087 }
2088
2089 } // namespace Adaptor
2090
2091 } // namespace Internal
2092
2093 // Dali::WebEngine Implementation
2094 WebEngine::WebEngine()
2095 {
2096 }
2097
2098 WebEngine::WebEngine( Internal::Adaptor::WebEngine* internal )
2099 : BaseHandle( internal )
2100 {
2101 }
2102
2103 WebEngine::~WebEngine()
2104 {
2105 }
2106
2107 WebEngine WebEngine::New()
2108 {
2109   Internal::Adaptor::WebEngine* baseObject = new Internal::Adaptor::WebEngine();
2110
2111   return WebEngine( baseObject );
2112 }
2113
2114 Dali::WebEngineContext* WebEngine::GetContext()
2115 {
2116   return Internal::Adaptor::GetContext();
2117 }
2118
2119 Dali::WebEngineCookieManager* WebEngine::GetCookieManager()
2120 {
2121   return Internal::Adaptor::GetCookieManager();
2122 }
2123
2124 WebEngine::WebEngine( const WebEngine& WebEngine )
2125 : BaseHandle( WebEngine )
2126 {
2127 }
2128
2129 WebEngine& WebEngine::operator=( const WebEngine& webEngine )
2130 {
2131   BaseHandle::operator=( webEngine );
2132   return *this;
2133 }
2134
2135 WebEngine WebEngine::DownCast( BaseHandle handle )
2136 {
2137   return WebEngine( dynamic_cast< Internal::Adaptor::WebEngine* >( handle.GetObjectPtr() ) );
2138 }
2139
2140 void WebEngine::Create( uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneId )
2141 {
2142 }
2143
2144 void WebEngine::Create( uint32_t width, uint32_t height, uint32_t argc, char** argv )
2145 {
2146 }
2147
2148 void WebEngine::Destroy()
2149 {
2150 }
2151
2152 WebEngineSettings& WebEngine::GetSettings() const
2153 {
2154   return Internal::Adaptor::GetImplementation( *this ).GetSettings();
2155 }
2156
2157 WebEngineBackForwardList& WebEngine::GetBackForwardList() const
2158 {
2159   return Internal::Adaptor::GetImplementation( *this ).GetBackForwardList();
2160 }
2161
2162 void WebEngine::LoadUrl( const std::string& url )
2163 {
2164   return Internal::Adaptor::GetImplementation( *this ).LoadUrl( url );
2165 }
2166
2167 std::string WebEngine::GetTitle() const
2168 {
2169   return Internal::Adaptor::GetImplementation( *this ).GetTitle();
2170 }
2171
2172 Dali::PixelData WebEngine::GetFavicon() const
2173 {
2174   return Internal::Adaptor::GetImplementation( *this ).GetFavicon();
2175 }
2176
2177 std::string WebEngine::GetUrl() const
2178 {
2179   return Internal::Adaptor::GetImplementation( *this ).GetUrl();
2180 }
2181
2182 Dali::WebEnginePlugin* WebEngine::GetPlugin() const
2183 {
2184   return Internal::Adaptor::GetWebEnginePlugin();
2185 }
2186
2187 NativeImageSourcePtr WebEngine::GetNativeImageSource()
2188 {
2189   Any source;
2190   Dali::NativeImageSourcePtr sourcePtr = Dali::NativeImageSource::New( source );
2191   return sourcePtr;
2192 }
2193
2194 void WebEngine::LoadHtmlString( const std::string& htmlString )
2195 {
2196 }
2197
2198 bool WebEngine::LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl)
2199 {
2200   return true;
2201 }
2202
2203 bool WebEngine::LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri)
2204 {
2205   return true;
2206 }
2207
2208 void WebEngine::Reload()
2209 {
2210 }
2211
2212 bool WebEngine::ReloadWithoutCache()
2213 {
2214   return true;
2215 }
2216
2217 void WebEngine::StopLoading()
2218 {
2219 }
2220
2221 void WebEngine::Suspend()
2222 {
2223 }
2224
2225 void WebEngine::Resume()
2226 {
2227 }
2228
2229 void WebEngine::SuspendNetworkLoading()
2230 {
2231 }
2232
2233 void WebEngine::ResumeNetworkLoading()
2234 {
2235 }
2236
2237 bool WebEngine::AddCustomHeader(const std::string& name, const std::string& value)
2238 {
2239   return true;
2240 }
2241
2242 bool WebEngine::RemoveCustomHeader(const std::string& name)
2243 {
2244   return true;
2245 }
2246
2247 uint32_t WebEngine::StartInspectorServer(uint32_t port)
2248 {
2249   return port;
2250 }
2251
2252 bool WebEngine::StopInspectorServer()
2253 {
2254   return true;
2255 }
2256
2257 bool WebEngine::CanGoForward()
2258 {
2259   return Internal::Adaptor::GetImplementation( *this ).CanGoForward();
2260 }
2261
2262 void WebEngine::GoForward()
2263 {
2264   Internal::Adaptor::GetImplementation( *this ).GoForward();
2265 }
2266
2267 bool WebEngine::CanGoBack()
2268 {
2269   return Internal::Adaptor::GetImplementation( *this ).CanGoBack();
2270 }
2271
2272 void WebEngine::GoBack()
2273 {
2274   Internal::Adaptor::GetImplementation( *this ).GoBack();
2275 }
2276
2277 void WebEngine::EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler )
2278 {
2279   Internal::Adaptor::GetImplementation( *this ).EvaluateJavaScript( script, resultHandler );
2280 }
2281
2282 void WebEngine::AddJavaScriptMessageHandler( const std::string& exposedObjectName, std::function< void(const std::string&) > handler )
2283 {
2284 }
2285
2286 void WebEngine::RegisterJavaScriptAlertCallback( Dali::WebEnginePlugin::JavaScriptAlertCallback callback )
2287 {
2288   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptAlertCallback( callback );
2289 }
2290
2291 void WebEngine::JavaScriptAlertReply()
2292 {
2293 }
2294
2295 void WebEngine::RegisterJavaScriptConfirmCallback( Dali::WebEnginePlugin::JavaScriptConfirmCallback callback )
2296 {
2297   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptConfirmCallback( callback );
2298 }
2299
2300 void WebEngine::JavaScriptConfirmReply( bool confirmed )
2301 {
2302 }
2303
2304 void WebEngine::RegisterJavaScriptPromptCallback( Dali::WebEnginePlugin::JavaScriptPromptCallback callback )
2305 {
2306   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptPromptCallback( callback );
2307 }
2308
2309 void WebEngine::JavaScriptPromptReply( const std::string& result )
2310 {
2311 }
2312
2313 std::unique_ptr<Dali::WebEngineHitTest> WebEngine::CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
2314 {
2315   return Internal::Adaptor::GetImplementation(*this).CreateHitTest(x, y, mode);
2316 }
2317
2318 bool WebEngine::CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
2319 {
2320   return Internal::Adaptor::GetImplementation(*this).CreateHitTestAsynchronously(x, y, mode, callback);
2321 }
2322
2323 void WebEngine::ClearAllTilesResources()
2324 {
2325 }
2326
2327 void WebEngine::ClearHistory()
2328 {
2329   Internal::Adaptor::GetImplementation( *this ).ClearHistory();
2330 }
2331
2332 void WebEngine::SetScaleFactor(float scaleFactor, Dali::Vector2 point)
2333 {
2334   Internal::Adaptor::GetImplementation( *this ).SetScaleFactor(scaleFactor, point);
2335 }
2336
2337 float WebEngine::GetScaleFactor() const
2338 {
2339   return Internal::Adaptor::GetImplementation( *this ).GetScaleFactor();
2340 }
2341
2342 void WebEngine::ActivateAccessibility(bool activated)
2343 {
2344 }
2345
2346 Accessibility::Address WebEngine::GetAccessibilityAddress()
2347 {
2348   return Internal::Adaptor::GetImplementation(*this).GetAccessibilityAddress();
2349 }
2350
2351 bool WebEngine::HighlightText(const std::string& text, Dali::WebEnginePlugin::FindOption options, uint32_t maxMatchCount)
2352 {
2353   return true;
2354 }
2355
2356 void WebEngine::AddDynamicCertificatePath(const std::string& host, const std::string& certPath)
2357 {
2358 }
2359
2360 Dali::PixelData WebEngine::GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
2361 {
2362   return Internal::Adaptor::GetImplementation( *this ).GetScreenshot(viewArea, scaleFactor);
2363 }
2364
2365 bool WebEngine::GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
2366 {
2367   return Internal::Adaptor::GetImplementation( *this ).GetScreenshotAsynchronously(viewArea, scaleFactor, callback);
2368 }
2369
2370 bool WebEngine::CheckVideoPlayingAsynchronously(Dali::WebEnginePlugin::VideoPlayingCallback callback)
2371 {
2372   return Internal::Adaptor::GetImplementation( *this ).CheckVideoPlayingAsynchronously(callback);
2373 }
2374
2375 void WebEngine::RegisterGeolocationPermissionCallback(Dali::WebEnginePlugin::GeolocationPermissionCallback callback)
2376 {
2377   Internal::Adaptor::GetImplementation( *this ).RegisterGeolocationPermissionCallback(callback);
2378 }
2379
2380 std::string WebEngine::GetUserAgent() const
2381 {
2382   return Internal::Adaptor::GetImplementation( *this ).GetUserAgent();
2383 }
2384
2385 void WebEngine::SetUserAgent( const std::string& userAgent )
2386 {
2387   Internal::Adaptor::GetImplementation( *this ).SetUserAgent( userAgent );
2388 }
2389
2390 void WebEngine::ScrollBy( int32_t dx, int32_t dy )
2391 {
2392   Internal::Adaptor::GetImplementation( *this ).ScrollBy( dx, dy );
2393 }
2394
2395 bool WebEngine::ScrollEdgeBy( int32_t dx, int32_t dy )
2396 {
2397   return Internal::Adaptor::GetImplementation( *this ).ScrollEdgeBy( dx, dy );
2398 }
2399
2400 void WebEngine::SetScrollPosition( int32_t x, int32_t y )
2401 {
2402   Internal::Adaptor::GetImplementation( *this ).SetScrollPosition( x, y );
2403 }
2404
2405 Dali::Vector2 WebEngine::GetScrollPosition() const
2406 {
2407   return Internal::Adaptor::GetImplementation( *this ).GetScrollPosition();
2408 }
2409
2410 Dali::Vector2 WebEngine::GetScrollSize() const
2411 {
2412   return Internal::Adaptor::GetImplementation( *this ).GetScrollSize();
2413 }
2414
2415 Dali::Vector2 WebEngine::GetContentSize() const
2416 {
2417   return Internal::Adaptor::GetImplementation( *this ).GetContentSize();
2418 }
2419
2420 void WebEngine::SetSize( uint32_t width, uint32_t height )
2421 {
2422 }
2423
2424 void WebEngine::SetDocumentBackgroundColor(Dali::Vector4 color)
2425 {
2426 }
2427
2428 void WebEngine::ClearTilesWhenHidden(bool cleared)
2429 {
2430 }
2431
2432 void WebEngine::SetTileCoverAreaMultiplier(float multiplier)
2433 {
2434 }
2435
2436 void WebEngine::EnableCursorByClient(bool enabled)
2437 {
2438 }
2439
2440 std::string WebEngine::GetSelectedText() const
2441 {
2442   return "test";
2443 }
2444
2445 bool WebEngine::SendTouchEvent( const TouchEvent& touch )
2446 {
2447   return true;
2448 }
2449
2450 bool WebEngine::SendKeyEvent( const KeyEvent& event )
2451 {
2452   return true;
2453 }
2454
2455 bool WebEngine::SendHoverEvent( const HoverEvent& event )
2456 {
2457   return true;
2458 }
2459
2460 bool WebEngine::SendWheelEvent( const WheelEvent& event )
2461 {
2462   return true;
2463 }
2464
2465 void WebEngine::SetFocus( bool focused )
2466 {
2467 }
2468
2469 void WebEngine::SetPageZoomFactor(float zoomFactor)
2470 {
2471   Internal::Adaptor::GetImplementation( *this ).SetPageZoomFactor(zoomFactor);
2472 }
2473
2474 float WebEngine::GetPageZoomFactor() const
2475 {
2476   return Internal::Adaptor::GetImplementation( *this ).GetPageZoomFactor();
2477 }
2478
2479 void WebEngine::SetTextZoomFactor(float zoomFactor)
2480 {
2481   Internal::Adaptor::GetImplementation( *this ).SetTextZoomFactor(zoomFactor);
2482 }
2483
2484 float WebEngine::GetTextZoomFactor() const
2485 {
2486   return Internal::Adaptor::GetImplementation( *this ).GetTextZoomFactor();
2487 }
2488
2489 float WebEngine::GetLoadProgressPercentage() const
2490 {
2491   return Internal::Adaptor::GetImplementation( *this ).GetLoadProgressPercentage();
2492 }
2493
2494 void WebEngine::UpdateDisplayArea( Dali::Rect< int32_t > displayArea )
2495 {
2496 }
2497
2498 void WebEngine::EnableVideoHole( bool enabled )
2499 {
2500 }
2501
2502 void WebEngine::EnableMouseEvents( bool enabled )
2503 {
2504 }
2505
2506 void WebEngine::EnableKeyEvents( bool enabled )
2507 {
2508 }
2509
2510 Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& WebEngine::FrameRenderedSignal()
2511 {
2512   return Internal::Adaptor::GetImplementation(*this).FrameRenderedSignal();
2513 }
2514
2515 void WebEngine::RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
2516 {
2517   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadStartedCallback(callback);
2518 }
2519
2520 void WebEngine::RegisterPageLoadInProgressCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
2521 {
2522   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadInProgressCallback(callback);
2523 }
2524
2525 void WebEngine::RegisterPageLoadFinishedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
2526 {
2527   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadFinishedCallback(callback);
2528 }
2529
2530 void WebEngine::RegisterPageLoadErrorCallback(Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback callback)
2531 {
2532   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadErrorCallback(callback);
2533 }
2534
2535 void WebEngine::RegisterScrollEdgeReachedCallback(Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback callback)
2536 {
2537   Internal::Adaptor::GetImplementation( *this ).RegisterScrollEdgeReachedCallback(callback);
2538 }
2539
2540 void WebEngine::RegisterUrlChangedCallback(Dali::WebEnginePlugin::WebEngineUrlChangedCallback callback)
2541 {
2542   Internal::Adaptor::GetImplementation( *this ).RegisterUrlChangedCallback(callback);
2543 }
2544
2545 void WebEngine::RegisterFormRepostDecidedCallback(Dali::WebEnginePlugin::WebEngineFormRepostDecidedCallback callback)
2546 {
2547   Internal::Adaptor::GetImplementation( *this ).RegisterFormRepostDecidedCallback(callback);
2548 }
2549
2550 void WebEngine::RegisterConsoleMessageReceivedCallback(Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback callback)
2551 {
2552   Internal::Adaptor::GetImplementation( *this ).RegisterConsoleMessageReceivedCallback(callback);
2553 }
2554
2555 void WebEngine::RegisterResponsePolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback callback)
2556 {
2557   Internal::Adaptor::GetImplementation( *this ).RegisterResponsePolicyDecidedCallback(callback);
2558 }
2559
2560 void WebEngine::RegisterNavigationPolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback callback)
2561 {
2562   Internal::Adaptor::GetImplementation(*this).RegisterNavigationPolicyDecidedCallback(callback);
2563 }
2564
2565 void WebEngine::RegisterCertificateConfirmedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
2566 {
2567   Internal::Adaptor::GetImplementation( *this ).RegisterCertificateConfirmedCallback(callback);
2568 }
2569
2570 void WebEngine::RegisterSslCertificateChangedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
2571 {
2572   Internal::Adaptor::GetImplementation( *this ).RegisterSslCertificateChangedCallback(callback);
2573 }
2574
2575 void WebEngine::RegisterHttpAuthHandlerCallback(Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback callback)
2576 {
2577   Internal::Adaptor::GetImplementation( *this ).RegisterHttpAuthHandlerCallback(callback);
2578 }
2579
2580 void WebEngine::RegisterContextMenuShownCallback(Dali::WebEnginePlugin::WebEngineContextMenuShownCallback callback)
2581 {
2582   Internal::Adaptor::GetImplementation( *this ).RegisterContextMenuShownCallback(callback);
2583 }
2584
2585 void WebEngine::RegisterContextMenuHiddenCallback(Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback callback)
2586 {
2587   Internal::Adaptor::GetImplementation( *this ).RegisterContextMenuHiddenCallback(callback);
2588 }
2589
2590 void WebEngine::GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
2591 {
2592   Internal::Adaptor::GetImplementation(*this).GetPlainTextAsynchronously(callback);
2593 }
2594
2595 } // namespace Dali;