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

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