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   bool SetViewportMetaTag(bool enable) override
 993   {
 994     return true;
 995   }
 996
 997   bool SetForceZoom(bool enable) override
 998   {
 999     return true;
1000   }
1001
1002   bool IsZoomForced() const override
1003   {
1004     return true;
1005   }
1006
1007   bool SetTextZoomEnabled(bool enable) override
1008   {
1009     return true;
1010   }
1011
1012   bool IsTextZoomEnabled() const override
1013   {
1014     return true;
1015   }
1016
1017   void SetExtraFeature(const std::string& feature, bool enable) override
1018   {
1019   }
1020
1021   bool IsExtraFeatureEnabled(const std::string& feature) const override
1022   {
1023     return  true;
1024   }
1025
1026 private:
1027   int mockDefaultFontSize;
1028   bool mockJavaScriptEnabled;
1029   bool mockAutoFittingEnabled;
1030   bool mockPluginsEnabled;
1031   bool mockPrivateBrowsingEnabled;
1032   bool mockLinkMagnifierEnabled;
1033   bool mockKeypadWithoutUserActionUsed;
1034   bool mockAutofillPasswordFormEnabled;
1035   bool mockFormCandidateDataEnabled;
1036   bool mockTextSelectionEnabled;
1037   bool mockTextAutosizingEnable;
1038   bool mockArrowScrollEnable;
1039   bool mockClipboardEnabled;
1040   bool mockImePanelEnabled;
1041   bool mockImageLoadedAutomatically;
1042   std::string mockDefaultTextEncodingName;
1043 };
1044
1045 class WebEngine: public Dali::BaseObject
1046 {
1047 public:
1048
1049   using JavaScriptEvaluatedResultCallback = std::function<void(const std::string&)>;
1050
1051   WebEngine()
1052     : mUrl()
1053     , mCurrentPlusOnePos( 0 )
1054     , mUserAgent()
1055     , mEvaluating( false )
1056     , mScrollPosition( 0, 0 )
1057     , mScrollSize( 500, 500 )
1058     , mContentSize( 500, 500 )
1059   {
1060     gInstanceCount++;
1061     if ( gInstanceCount == 1 ) // only first web engine need be saved.
1062     {
1063       gInstance = this;
1064     }
1065
1066     mockWebEngineSettings = new MockWebEngineSettings();
1067     MockWebEngineContext* engineContext = new MockWebEngineContext();
1068     mockWebEngineContext = engineContext;
1069     if ( gInstanceCount == 1 )
1070     {
1071       gWebEngineContextInstance = engineContext;
1072     }
1073     mockWebEngineCookieManager = new MockWebEngineCookieManager();
1074     mockWebEngineBackForwardList = new MockWebEngineBackForwardList();
1075   }
1076
1077   virtual ~WebEngine()
1078   {
1079     gInstanceCount--;
1080     if( !gInstanceCount )
1081     {
1082       gInstance = 0;
1083       gWebEngineContextInstance = 0;
1084     }
1085
1086     delete mockWebEngineSettings;
1087     delete mockWebEngineContext;
1088     delete mockWebEngineCookieManager;
1089     delete mockWebEngineBackForwardList;
1090   }
1091
1092   Dali::WebEngineSettings& GetSettings() const
1093   {
1094     return *mockWebEngineSettings;
1095   }
1096
1097   Dali::WebEngineContext& GetContext() const
1098   {
1099     return *mockWebEngineContext;
1100   }
1101
1102   Dali::WebEngineCookieManager& GetCookieManager() const
1103   {
1104     return *mockWebEngineCookieManager;
1105   }
1106
1107   Dali::WebEngineBackForwardList& GetBackForwardList() const
1108   {
1109     return *mockWebEngineBackForwardList;
1110   }
1111
1112   void LoadUrl( const std::string& url )
1113   {
1114     mUrl = url;
1115     ConnectToGlobalSignal( &OnLoadUrl );
1116   }
1117
1118   const std::string& GetUrl() const
1119   {
1120     return mUrl;
1121   }
1122
1123   std::string GetTitle() const
1124   {
1125     return std::string("title");
1126   }
1127
1128   Dali::PixelData GetFavicon() const
1129   {
1130     uint8_t* faviconData = new uint8_t[ 16 ];
1131
1132     faviconData[ 0 ] = 0xff;
1133     faviconData[ 1 ] = 0x00;
1134     faviconData[ 2 ] = 0x00;
1135     faviconData[ 3 ] = 0xff;
1136     faviconData[ 4 ] = 0xff;
1137     faviconData[ 5 ] = 0x00;
1138     faviconData[ 6 ] = 0x00;
1139     faviconData[ 7 ] = 0xff;
1140     faviconData[ 8 ] = 0xff;
1141     faviconData[ 9 ] = 0x00;
1142     faviconData[ 10 ] = 0x00;
1143     faviconData[ 11 ] = 0xff;
1144     faviconData[ 12 ] = 0xff;
1145     faviconData[ 13 ] = 0x00;
1146     faviconData[ 14 ] = 0x00;
1147     faviconData[ 15 ] = 0xff;
1148
1149     return Dali::PixelData::New( faviconData, 16, 2, 2,
1150                                  Dali::Pixel::Format::RGBA8888,
1151                                  Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
1152   }
1153
1154   bool CanGoForward() const
1155   {
1156     return mHistory.size() > mCurrentPlusOnePos;
1157   }
1158
1159   void GoForward()
1160   {
1161     ConnectToGlobalSignal( &OnGoForward );
1162   }
1163
1164   bool CanGoBack() const
1165   {
1166     return mCurrentPlusOnePos > 1;
1167   }
1168
1169   void GoBack()
1170   {
1171     ConnectToGlobalSignal( &OnGoBack );
1172   }
1173
1174   void EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler )
1175   {
1176     if( resultHandler )
1177     {
1178       if( !mEvaluating )
1179       {
1180         ConnectToGlobalSignal( &OnEvaluteJavaScript );
1181       }
1182       mResultCallbacks.push_back( resultHandler );
1183     }
1184   }
1185
1186   void RegisterJavaScriptAlertCallback( Dali::WebEnginePlugin::JavaScriptAlertCallback callback )
1187   {
1188     if ( callback )
1189     {
1190       ConnectToGlobalSignal( &OnJavaScriptAlert );
1191       mJavaScriptAlertCallback = callback;
1192     }
1193   }
1194
1195   void RegisterJavaScriptConfirmCallback( Dali::WebEnginePlugin::JavaScriptConfirmCallback callback )
1196   {
1197     if ( callback )
1198     {
1199       ConnectToGlobalSignal( &OnJavaScriptConfirm );
1200       mJavaScriptConfirmCallback = callback;
1201     }
1202   }
1203
1204   void RegisterJavaScriptPromptCallback( Dali::WebEnginePlugin::JavaScriptPromptCallback callback )
1205   {
1206     if ( callback )
1207     {
1208       ConnectToGlobalSignal( &OnJavaScriptPrompt );
1209       mJavaScriptPromptCallback = callback;
1210     }
1211   }
1212
1213   std::unique_ptr<Dali::WebEngineHitTest> CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
1214   {
1215     std::unique_ptr<Dali::WebEngineHitTest> hitTest(new MockWebEngineHitTest());
1216     return hitTest;
1217   }
1218
1219   bool CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
1220   {
1221     if (callback)
1222     {
1223       ConnectToGlobalSignal( &OnHitTestCreated );
1224       mHitTestCreatedCallback = callback;
1225     }
1226     return true;
1227   }
1228
1229   void ClearHistory()
1230   {
1231     ConnectToGlobalSignal( &OnClearHistory );
1232   }
1233
1234   const std::string& GetUserAgent() const
1235   {
1236     return mUserAgent;
1237   }
1238
1239   void SetUserAgent( const std::string& userAgent )
1240   {
1241     mUserAgent = userAgent;
1242   }
1243
1244   void ScrollBy( int32_t dx, int32_t dy )
1245   {
1246     mScrollPosition += Dali::Vector2( dx, dy );
1247     if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
1248     {
1249       ConnectToGlobalSignal( &OnScrollEdge );
1250     }
1251   }
1252
1253   bool ScrollEdgeBy( int32_t dx, int32_t dy )
1254   {
1255     mScrollPosition += Dali::Vector2( dx, dy );
1256     if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
1257     {
1258       ConnectToGlobalSignal( &OnScrollEdge );
1259     }
1260     return true;
1261   }
1262
1263   void SetScrollPosition( int32_t x, int32_t y )
1264   {
1265     mScrollPosition.x = x;
1266     mScrollPosition.y = y;
1267   }
1268
1269   Dali::Vector2 GetScrollPosition() const
1270   {
1271     return mScrollPosition;
1272   }
1273
1274   Dali::Vector2 GetScrollSize() const
1275   {
1276     return mScrollSize;
1277   }
1278
1279   Dali::Vector2 GetContentSize() const
1280   {
1281     return mContentSize;
1282   }
1283
1284   void SetPageZoomFactor(float zoomFactor)
1285   {
1286     mPageZoomFactor = zoomFactor;
1287   }
1288
1289   float GetPageZoomFactor() const
1290   {
1291     return mPageZoomFactor;
1292   }
1293
1294   void SetTextZoomFactor(float zoomFactor)
1295   {
1296     mTextZoomFactor = zoomFactor;
1297   }
1298
1299   float GetTextZoomFactor() const
1300   {
1301     return mTextZoomFactor;
1302   }
1303
1304   float GetLoadProgressPercentage() const
1305   {
1306     return 0.5f;
1307   }
1308
1309   void SetScaleFactor(float scaleFactor, Dali::Vector2 point)
1310   {
1311     mScaleFactor = scaleFactor;
1312   }
1313
1314   float GetScaleFactor() const
1315   {
1316     return mScaleFactor;
1317   }
1318
1319   Dali::PixelData GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
1320   {
1321     uint32_t bufferSize = viewArea.width * viewArea.height * 4 ;
1322     uint8_t* pixel = new uint8_t[ bufferSize ];
1323     memset(pixel, 0xff, bufferSize);
1324     return Dali::PixelData::New( pixel, bufferSize, viewArea.width, viewArea.height,
1325                                  Dali::Pixel::Format::RGBA8888,
1326                                  Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
1327   }
1328
1329   bool GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
1330   {
1331     if ( callback )
1332     {
1333       ConnectToGlobalSignal( &OnScreenshotCaptured );
1334       mScreenshotCapturedCallback = callback;
1335     }
1336     return true;
1337   }
1338
1339   bool CheckVideoPlayingAsynchronously(Dali::WebEnginePlugin::VideoPlayingCallback callback)
1340   {
1341     if ( callback )
1342     {
1343       ConnectToGlobalSignal( &OnVideoPlaying );
1344       mVideoPlayingCallback = callback;
1345     }
1346     return true;
1347   }
1348
1349   void RegisterGeolocationPermissionCallback(Dali::WebEnginePlugin::GeolocationPermissionCallback callback)
1350   {
1351     if ( callback )
1352     {
1353       ConnectToGlobalSignal( &OnGeolocationPermission );
1354       mGeolocationPermissionCallback = callback;
1355     }
1356   }
1357
1358   Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadStartedSignal()
1359   {
1360     return mPageLoadStartedSignal;
1361   }
1362
1363   Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadInProgressSignal()
1364   {
1365     return mPageLoadInProgressSignal;
1366   }
1367
1368   Dali::WebEnginePlugin::WebEnginePageLoadSignalType& PageLoadFinishedSignal()
1369   {
1370     return mPageLoadFinishedSignal;
1371   }
1372
1373   Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& PageLoadErrorSignal()
1374   {
1375     return mPageLoadErrorSignal;
1376   }
1377
1378   Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType& ScrollEdgeReachedSignal()
1379   {
1380     return mScrollEdgeReachedSignal;
1381   }
1382
1383   Dali::WebEnginePlugin::WebEngineUrlChangedSignalType& UrlChangedSignal()
1384   {
1385     return mUrlChangedSignal;
1386   }
1387
1388   Dali::WebEnginePlugin::WebEngineFormRepostDecisionSignalType& FormRepostDecisionSignal()
1389   {
1390     return mFormRepostDecisionSignal;
1391   }
1392
1393   Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& FrameRenderedSignal()
1394   {
1395     return mFrameRenderedSignal;
1396   }
1397
1398   Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType& RequestInterceptorSignal()
1399   {
1400     return mRequestInterceptorSignal;
1401   }
1402
1403   Dali::WebEnginePlugin::WebEngineConsoleMessageSignalType& ConsoleMessageSignal()
1404   {
1405     return mConsoleMessageSignal;
1406   }
1407
1408   Dali::WebEnginePlugin::WebEnginePolicyDecisionSignalType& PolicyDecisionSignal()
1409   {
1410     return mPolicyDecisionSignal;
1411   }
1412
1413   Dali::WebEnginePlugin::WebEngineCertificateSignalType& CertificateConfirmSignal()
1414   {
1415     return mCertificateConfirmSignal;
1416   }
1417
1418   Dali::WebEnginePlugin::WebEngineCertificateSignalType& SslCertificateChangedSignal()
1419   {
1420     return mSslCertificateChangedSignal;
1421   }
1422
1423   Dali::WebEnginePlugin::WebEngineHttpAuthHandlerSignalType& HttpAuthHandlerSignal()
1424   {
1425     return mHttpAuthHandlerSignal;
1426   }
1427
1428   Dali::WebEnginePlugin::WebEngineContextMenuCustomizedSignalType& ContextMenuCustomizedSignal()
1429   {
1430     return mContextMenuCustomizedSignal;
1431   }
1432
1433   Dali::WebEnginePlugin::WebEngineContextMenuItemSelectedSignalType& ContextMenuItemSelectedSignal()
1434   {
1435     return mContextMenuItemSelectedSignal;
1436   }
1437
1438   std::string              mUrl;
1439   std::vector<std::string> mHistory;
1440   size_t                   mCurrentPlusOnePos;
1441   std::string              mUserAgent;
1442
1443   Dali::WebEnginePlugin::WebEnginePageLoadSignalType                mPageLoadStartedSignal;
1444   Dali::WebEnginePlugin::WebEnginePageLoadSignalType                mPageLoadInProgressSignal;
1445   Dali::WebEnginePlugin::WebEnginePageLoadSignalType                mPageLoadFinishedSignal;
1446   Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType           mPageLoadErrorSignal;
1447   Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType       mScrollEdgeReachedSignal;
1448   Dali::WebEnginePlugin::WebEngineUrlChangedSignalType              mUrlChangedSignal;
1449   Dali::WebEnginePlugin::WebEngineFormRepostDecisionSignalType      mFormRepostDecisionSignal;
1450   Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType           mFrameRenderedSignal;
1451   Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType      mRequestInterceptorSignal;
1452   Dali::WebEnginePlugin::WebEngineConsoleMessageSignalType          mConsoleMessageSignal;
1453   Dali::WebEnginePlugin::WebEnginePolicyDecisionSignalType          mPolicyDecisionSignal;
1454   Dali::WebEnginePlugin::WebEngineCertificateSignalType             mCertificateConfirmSignal;
1455   Dali::WebEnginePlugin::WebEngineCertificateSignalType             mSslCertificateChangedSignal;
1456   Dali::WebEnginePlugin::WebEngineHttpAuthHandlerSignalType         mHttpAuthHandlerSignal;
1457   Dali::WebEnginePlugin::WebEngineContextMenuCustomizedSignalType   mContextMenuCustomizedSignal;
1458   Dali::WebEnginePlugin::WebEngineContextMenuItemSelectedSignalType mContextMenuItemSelectedSignal;
1459
1460   bool  mEvaluating;
1461   float mPageZoomFactor;
1462   float mTextZoomFactor;
1463   float mScaleFactor;
1464
1465   Dali::Vector2             mScrollPosition;
1466   Dali::Vector2             mScrollSize;
1467   Dali::Vector2             mContentSize;
1468   WebEngineBackForwardList* mockWebEngineBackForwardList;
1469   WebEngineContext*         mockWebEngineContext;
1470   WebEngineCookieManager*   mockWebEngineCookieManager;
1471   WebEngineSettings*        mockWebEngineSettings;
1472
1473   std::vector<JavaScriptEvaluatedResultCallback>         mResultCallbacks;
1474   Dali::WebEnginePlugin::JavaScriptAlertCallback         mJavaScriptAlertCallback;
1475   Dali::WebEnginePlugin::JavaScriptConfirmCallback       mJavaScriptConfirmCallback;
1476   Dali::WebEnginePlugin::JavaScriptPromptCallback        mJavaScriptPromptCallback;
1477   Dali::WebEnginePlugin::ScreenshotCapturedCallback      mScreenshotCapturedCallback;
1478   Dali::WebEnginePlugin::VideoPlayingCallback            mVideoPlayingCallback;
1479   Dali::WebEnginePlugin::GeolocationPermissionCallback   mGeolocationPermissionCallback;
1480   Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback mHitTestCreatedCallback;
1481 };
1482
1483
1484 namespace
1485 {
1486
1487 bool OnGoBack()
1488 {
1489   DisconnectFromGlobalSignal( &OnGoBack );
1490
1491   if( gInstance && gInstance->CanGoBack() )
1492   {
1493     gInstance->mCurrentPlusOnePos--;
1494   }
1495   return false;
1496 }
1497
1498 bool OnGoForward()
1499 {
1500   DisconnectFromGlobalSignal( &OnGoForward );
1501
1502   if( gInstance && gInstance->CanGoForward() )
1503   {
1504     gInstance->mCurrentPlusOnePos++;
1505   }
1506   return false;
1507 }
1508
1509 bool OnLoadUrl()
1510 {
1511   DisconnectFromGlobalSignal( &OnLoadUrl );
1512
1513   if( gInstance )
1514   {
1515     if( gInstance->mHistory.size() > gInstance->mCurrentPlusOnePos )
1516     {
1517       gInstance->mHistory.erase( gInstance->mHistory.begin() + gInstance->mCurrentPlusOnePos, gInstance->mHistory.end() );
1518     }
1519     gInstance->mHistory.push_back( gInstance->mUrl );
1520     gInstance->mCurrentPlusOnePos++;
1521     gInstance->mPageLoadStartedSignal.Emit( gInstance->mUrl );
1522     gInstance->mPageLoadInProgressSignal.Emit( gInstance->mUrl );
1523     gInstance->mPageLoadFinishedSignal.Emit( gInstance->mUrl );
1524     gInstance->mUrlChangedSignal.Emit( "http://new-test" );
1525
1526     std::shared_ptr<Dali::WebEngineFormRepostDecision> repostDecision(new MockWebEngineFormRepostDecision());
1527     gInstance->mFormRepostDecisionSignal.Emit(std::move(repostDecision));
1528     gInstance->mFrameRenderedSignal.Emit();
1529     std::shared_ptr<Dali::WebEngineRequestInterceptor> interceptor(new MockWebEngineRequestInterceptor());
1530     gInstance->mRequestInterceptorSignal.Emit(std::move(interceptor));
1531
1532     std::shared_ptr<Dali::WebEngineLoadError> error(new MockWebEngineLoadError(gInstance->mUrl));
1533     gInstance->mPageLoadErrorSignal.Emit(std::move(error));
1534     std::shared_ptr<Dali::WebEngineConsoleMessage> message(new MockWebEngineConsoleMessage());
1535     gInstance->mConsoleMessageSignal.Emit(std::move(message));
1536     std::shared_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
1537     gInstance->mPolicyDecisionSignal.Emit(std::move(policyDecision));
1538
1539     std::shared_ptr<Dali::WebEngineCertificate> certificate(new MockWebEngineCertificate());
1540     gInstance->mCertificateConfirmSignal.Emit(std::move(certificate));
1541     std::shared_ptr<Dali::WebEngineCertificate> sslCertificate(new MockWebEngineCertificate());
1542     gInstance->mSslCertificateChangedSignal.Emit(std::move(sslCertificate));
1543     std::shared_ptr<Dali::WebEngineHttpAuthHandler> handler(new MockWebEngineHttpAuthHandler());
1544     gInstance->mHttpAuthHandlerSignal.Emit(std::move(handler));
1545
1546     std::shared_ptr<Dali::WebEngineContextMenu> menu(new MockWebEngineContextMenu());
1547     gInstance->mContextMenuCustomizedSignal.Emit(std::move(menu));
1548     std::shared_ptr<Dali::WebEngineContextMenuItem> item(new MockWebEngineContextMenuItem());
1549     gInstance->mContextMenuItemSelectedSignal.Emit(std::move(item));
1550   }
1551   return false;
1552 }
1553
1554 bool OnScrollEdge()
1555 {
1556   DisconnectFromGlobalSignal( &OnScrollEdge );
1557
1558   if( gInstance )
1559   {
1560     gInstance->mScrollEdgeReachedSignal.Emit( Dali::WebEnginePlugin::ScrollEdge::BOTTOM );
1561   }
1562
1563   return false;
1564 }
1565
1566 bool OnEvaluteJavaScript()
1567 {
1568   DisconnectFromGlobalSignal( &OnEvaluteJavaScript );
1569
1570   if( gInstance )
1571   {
1572     for( auto& func : gInstance->mResultCallbacks )
1573     {
1574       func("undefined");
1575     }
1576     gInstance->mResultCallbacks.clear();
1577   }
1578   return false;
1579 }
1580
1581 bool OnJavaScriptAlert()
1582 {
1583   DisconnectFromGlobalSignal( &OnJavaScriptAlert );
1584   if ( gInstance )
1585   {
1586     gInstance->mJavaScriptAlertCallback( "this is an alert popup." );
1587   }
1588   return false;
1589 }
1590
1591 bool OnJavaScriptConfirm()
1592 {
1593   DisconnectFromGlobalSignal( &OnJavaScriptConfirm );
1594   if ( gInstance )
1595   {
1596     gInstance->mJavaScriptConfirmCallback( "this is a confirm popup." );
1597   }
1598   return false;
1599 }
1600
1601 bool OnJavaScriptPrompt()
1602 {
1603   DisconnectFromGlobalSignal( &OnJavaScriptPrompt );
1604   if ( gInstance )
1605   {
1606     gInstance->mJavaScriptPromptCallback( "this is a prompt pompt.", "" );
1607   }
1608   return false;
1609 }
1610
1611 bool OnScreenshotCaptured()
1612 {
1613   DisconnectFromGlobalSignal( &OnScreenshotCaptured );
1614   if ( gInstance )
1615   {
1616     uint8_t* pixel = new uint8_t[ 2 * 2 * 4 ];
1617     memset(pixel, 0xff, 2 * 2 * 4);
1618     Dali::PixelData data = Dali::PixelData::New( pixel, 2 * 2 * 4, 2, 2,
1619                                  Dali::Pixel::Format::RGBA8888,
1620                                  Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
1621     gInstance->mScreenshotCapturedCallback( data );
1622   }
1623   return false;
1624 }
1625
1626 bool OnVideoPlaying()
1627 {
1628   DisconnectFromGlobalSignal( &OnVideoPlaying );
1629   if ( gInstance )
1630   {
1631     gInstance->mVideoPlayingCallback( true );
1632   }
1633   return false;
1634 }
1635
1636 bool OnGeolocationPermission()
1637 {
1638   DisconnectFromGlobalSignal( &OnGeolocationPermission );
1639   if ( gInstance )
1640   {
1641     gInstance->mGeolocationPermissionCallback( "", "" );
1642   }
1643   return false;
1644 }
1645
1646 bool OnHitTestCreated()
1647 {
1648   DisconnectFromGlobalSignal(&OnHitTestCreated);
1649   if (gInstance)
1650   {
1651     std::unique_ptr<Dali::WebEngineHitTest> test(new MockWebEngineHitTest());
1652     gInstance->mHitTestCreatedCallback(std::move(test));
1653   }
1654   return false;
1655 }
1656
1657 bool OnClearHistory()
1658 {
1659   DisconnectFromGlobalSignal( &OnClearHistory );
1660
1661   if( gInstance && gInstance->mCurrentPlusOnePos )
1662   {
1663     std::string url = gInstance->mHistory[ gInstance->mCurrentPlusOnePos - 1 ];
1664     std::vector< std::string >().swap( gInstance->mHistory );
1665     gInstance->mHistory.push_back( url );
1666     gInstance->mCurrentPlusOnePos = 1;
1667   }
1668   return false;
1669 }
1670
1671 bool OnSecurityOriginAcquired()
1672 {
1673   DisconnectFromGlobalSignal(&OnSecurityOriginAcquired);
1674   if (gWebEngineContextInstance)
1675   {
1676     std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>> securityOriginList;
1677     std::unique_ptr<Dali::WebEngineSecurityOrigin> origin(new MockWebEngineSecurityOrigin());
1678     securityOriginList.push_back(std::move(origin));
1679     gWebEngineContextInstance->mSecurityOriginAcquiredCallback(securityOriginList);
1680   }
1681   return false;
1682 }
1683
1684 bool OnStorageUsageAcquired()
1685 {
1686   DisconnectFromGlobalSignal(&OnStorageUsageAcquired);
1687   if (gWebEngineContextInstance)
1688   {
1689     gWebEngineContextInstance->mStorageUsageAcquiredCallback(0);
1690   }
1691   return false;
1692 }
1693
1694 bool OnFormPasswordAcquired()
1695 {
1696   DisconnectFromGlobalSignal(&OnFormPasswordAcquired);
1697   if (gWebEngineContextInstance)
1698   {
1699     std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>> formPasswordList;
1700     std::unique_ptr<Dali::WebEngineContext::PasswordData> data(new Dali::WebEngineContext::PasswordData());
1701     data->url = "http://test.html";
1702     data->useFingerprint = false;
1703     formPasswordList.push_back(std::move(data));
1704     gWebEngineContextInstance->mFormPasswordAcquiredCallback(formPasswordList);
1705   }
1706   return false;
1707 }
1708
1709 bool OnDownloadStarted()
1710 {
1711   DisconnectFromGlobalSignal(&OnDownloadStarted);
1712   if (gWebEngineContextInstance)
1713   {
1714     gWebEngineContextInstance->mDownloadStartedCallback("http://test.html");
1715   }
1716   return false;
1717 }
1718
1719 bool OnMimeOverridden()
1720 {
1721   DisconnectFromGlobalSignal(&OnMimeOverridden);
1722   if (gWebEngineContextInstance)
1723   {
1724     std::string newMime;
1725     gWebEngineContextInstance->mMimeOverriddenCallback("http://test.html", "txt/xml", newMime);
1726   }
1727   return false;
1728 }
1729
1730 } // namespace
1731
1732 inline WebEngine& GetImplementation( Dali::WebEngine& webEngine )
1733 {
1734   DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
1735   BaseObject& handle = webEngine.GetBaseObject();
1736   return static_cast< Internal::Adaptor::WebEngine& >( handle );
1737 }
1738
1739 inline const WebEngine& GetImplementation( const Dali::WebEngine& webEngine )
1740 {
1741   DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
1742   const BaseObject& handle = webEngine.GetBaseObject();
1743   return static_cast< const Internal::Adaptor::WebEngine& >( handle );
1744 }
1745
1746 } // namespace Adaptor
1747
1748 } // namespace Internal
1749
1750 // Dali::WebEngine Implementation
1751 WebEngine::WebEngine()
1752 {
1753 }
1754
1755 WebEngine::WebEngine( Internal::Adaptor::WebEngine* internal )
1756 : BaseHandle( internal )
1757 {
1758 }
1759
1760 WebEngine::~WebEngine()
1761 {
1762 }
1763
1764 WebEngine WebEngine::New()
1765 {
1766   Internal::Adaptor::WebEngine* baseObject = new Internal::Adaptor::WebEngine();
1767
1768   return WebEngine( baseObject );
1769 }
1770
1771 WebEngine::WebEngine( const WebEngine& WebEngine )
1772 : BaseHandle( WebEngine )
1773 {
1774 }
1775
1776 WebEngine& WebEngine::operator=( const WebEngine& webEngine )
1777 {
1778   BaseHandle::operator=( webEngine );
1779   return *this;
1780 }
1781
1782 WebEngine WebEngine::DownCast( BaseHandle handle )
1783 {
1784   return WebEngine( dynamic_cast< Internal::Adaptor::WebEngine* >( handle.GetObjectPtr() ) );
1785 }
1786
1787 void WebEngine::Create( uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneId )
1788 {
1789 }
1790
1791 void WebEngine::Create( uint32_t width, uint32_t height, uint32_t argc, char** argv )
1792 {
1793 }
1794
1795 void WebEngine::Destroy()
1796 {
1797 }
1798
1799 WebEngineSettings& WebEngine::GetSettings() const
1800 {
1801   return Internal::Adaptor::GetImplementation( *this ).GetSettings();
1802 }
1803
1804 WebEngineContext& WebEngine::GetContext() const
1805 {
1806   return Internal::Adaptor::GetImplementation( *this ).GetContext();
1807 }
1808
1809 WebEngineCookieManager& WebEngine::GetCookieManager() const
1810 {
1811   return Internal::Adaptor::GetImplementation( *this ).GetCookieManager();
1812 }
1813
1814 WebEngineBackForwardList& WebEngine::GetBackForwardList() const
1815 {
1816   return Internal::Adaptor::GetImplementation( *this ).GetBackForwardList();
1817 }
1818
1819 void WebEngine::LoadUrl( const std::string& url )
1820 {
1821   return Internal::Adaptor::GetImplementation( *this ).LoadUrl( url );
1822 }
1823
1824 std::string WebEngine::GetTitle() const
1825 {
1826   return Internal::Adaptor::GetImplementation( *this ).GetTitle();
1827 }
1828
1829 Dali::PixelData WebEngine::GetFavicon() const
1830 {
1831   return Internal::Adaptor::GetImplementation( *this ).GetFavicon();
1832 }
1833
1834 const std::string& WebEngine::GetUrl()
1835 {
1836   return Internal::Adaptor::GetImplementation( *this ).GetUrl();
1837 }
1838
1839 NativeImageInterfacePtr WebEngine::GetNativeImageSource()
1840 {
1841   Any source;
1842   Dali::NativeImageSourcePtr sourcePtr = Dali::NativeImageSource::New( source );
1843   return sourcePtr;
1844 }
1845
1846 void WebEngine::LoadHtmlString( const std::string& htmlString )
1847 {
1848 }
1849
1850 bool WebEngine::LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl)
1851 {
1852   return true;
1853 }
1854
1855 bool WebEngine::LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri)
1856 {
1857   return true;
1858 }
1859
1860 void WebEngine::Reload()
1861 {
1862 }
1863
1864 bool WebEngine::ReloadWithoutCache()
1865 {
1866   return true;
1867 }
1868
1869 void WebEngine::StopLoading()
1870 {
1871 }
1872
1873 void WebEngine::Suspend()
1874 {
1875 }
1876
1877 void WebEngine::Resume()
1878 {
1879 }
1880
1881 void WebEngine::SuspendNetworkLoading()
1882 {
1883 }
1884
1885 void WebEngine::ResumeNetworkLoading()
1886 {
1887 }
1888
1889 bool WebEngine::AddCustomHeader(const std::string& name, const std::string& value)
1890 {
1891   return true;
1892 }
1893
1894 bool WebEngine::RemoveCustomHeader(const std::string& name)
1895 {
1896   return true;
1897 }
1898
1899 uint32_t WebEngine::StartInspectorServer(uint32_t port)
1900 {
1901   return port;
1902 }
1903
1904 bool WebEngine::StopInspectorServer()
1905 {
1906   return true;
1907 }
1908
1909 bool WebEngine::CanGoForward()
1910 {
1911   return Internal::Adaptor::GetImplementation( *this ).CanGoForward();
1912 }
1913
1914 void WebEngine::GoForward()
1915 {
1916   Internal::Adaptor::GetImplementation( *this ).GoForward();
1917 }
1918
1919 bool WebEngine::CanGoBack()
1920 {
1921   return Internal::Adaptor::GetImplementation( *this ).CanGoBack();
1922 }
1923
1924 void WebEngine::GoBack()
1925 {
1926   Internal::Adaptor::GetImplementation( *this ).GoBack();
1927 }
1928
1929 void WebEngine::EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler )
1930 {
1931   Internal::Adaptor::GetImplementation( *this ).EvaluateJavaScript( script, resultHandler );
1932 }
1933
1934 void WebEngine::AddJavaScriptMessageHandler( const std::string& exposedObjectName, std::function< void(const std::string&) > handler )
1935 {
1936 }
1937
1938 void WebEngine::RegisterJavaScriptAlertCallback( Dali::WebEnginePlugin::JavaScriptAlertCallback callback )
1939 {
1940   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptAlertCallback( callback );
1941 }
1942
1943 void WebEngine::JavaScriptAlertReply()
1944 {
1945 }
1946
1947 void WebEngine::RegisterJavaScriptConfirmCallback( Dali::WebEnginePlugin::JavaScriptConfirmCallback callback )
1948 {
1949   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptConfirmCallback( callback );
1950 }
1951
1952 void WebEngine::JavaScriptConfirmReply( bool confirmed )
1953 {
1954 }
1955
1956 void WebEngine::RegisterJavaScriptPromptCallback( Dali::WebEnginePlugin::JavaScriptPromptCallback callback )
1957 {
1958   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptPromptCallback( callback );
1959 }
1960
1961 void WebEngine::JavaScriptPromptReply( const std::string& result )
1962 {
1963 }
1964
1965 std::unique_ptr<Dali::WebEngineHitTest> WebEngine::CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
1966 {
1967   return Internal::Adaptor::GetImplementation(*this).CreateHitTest(x, y, mode);
1968 }
1969
1970 bool WebEngine::CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
1971 {
1972   return Internal::Adaptor::GetImplementation(*this).CreateHitTestAsynchronously(x, y, mode, callback);
1973 }
1974
1975 void WebEngine::ClearAllTilesResources()
1976 {
1977 }
1978
1979 void WebEngine::ClearHistory()
1980 {
1981   Internal::Adaptor::GetImplementation( *this ).ClearHistory();
1982 }
1983
1984 void WebEngine::SetScaleFactor(float scaleFactor, Dali::Vector2 point)
1985 {
1986   Internal::Adaptor::GetImplementation( *this ).SetScaleFactor(scaleFactor, point);
1987 }
1988
1989 float WebEngine::GetScaleFactor() const
1990 {
1991   return Internal::Adaptor::GetImplementation( *this ).GetScaleFactor();
1992 }
1993
1994 void WebEngine::ActivateAccessibility(bool activated)
1995 {
1996 }
1997
1998 bool WebEngine::HighlightText(const std::string& text, Dali::WebEnginePlugin::FindOption options, uint32_t maxMatchCount)
1999 {
2000   return true;
2001 }
2002
2003 void WebEngine::AddDynamicCertificatePath(const std::string& host, const std::string& certPath)
2004 {
2005 }
2006
2007 Dali::PixelData WebEngine::GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
2008 {
2009   return Internal::Adaptor::GetImplementation( *this ).GetScreenshot(viewArea, scaleFactor);
2010 }
2011
2012 bool WebEngine::GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
2013 {
2014   return Internal::Adaptor::GetImplementation( *this ).GetScreenshotAsynchronously(viewArea, scaleFactor, callback);
2015 }
2016
2017 bool WebEngine::CheckVideoPlayingAsynchronously(Dali::WebEnginePlugin::VideoPlayingCallback callback)
2018 {
2019   return Internal::Adaptor::GetImplementation( *this ).CheckVideoPlayingAsynchronously(callback);
2020 }
2021
2022 void WebEngine::RegisterGeolocationPermissionCallback(Dali::WebEnginePlugin::GeolocationPermissionCallback callback)
2023 {
2024   Internal::Adaptor::GetImplementation( *this ).RegisterGeolocationPermissionCallback(callback);
2025 }
2026
2027 const std::string& WebEngine::GetUserAgent() const
2028 {
2029   return Internal::Adaptor::GetImplementation( *this ).GetUserAgent();
2030 }
2031
2032 void WebEngine::SetUserAgent( const std::string& userAgent )
2033 {
2034   Internal::Adaptor::GetImplementation( *this ).SetUserAgent( userAgent );
2035 }
2036
2037 void WebEngine::ScrollBy( int32_t dx, int32_t dy )
2038 {
2039   Internal::Adaptor::GetImplementation( *this ).ScrollBy( dx, dy );
2040 }
2041
2042 bool WebEngine::ScrollEdgeBy( int32_t dx, int32_t dy )
2043 {
2044   return Internal::Adaptor::GetImplementation( *this ).ScrollEdgeBy( dx, dy );
2045 }
2046
2047 void WebEngine::SetScrollPosition( int32_t x, int32_t y )
2048 {
2049   Internal::Adaptor::GetImplementation( *this ).SetScrollPosition( x, y );
2050 }
2051
2052 Dali::Vector2 WebEngine::GetScrollPosition() const
2053 {
2054   return Internal::Adaptor::GetImplementation( *this ).GetScrollPosition();
2055 }
2056
2057 Dali::Vector2 WebEngine::GetScrollSize() const
2058 {
2059   return Internal::Adaptor::GetImplementation( *this ).GetScrollSize();
2060 }
2061
2062 Dali::Vector2 WebEngine::GetContentSize() const
2063 {
2064   return Internal::Adaptor::GetImplementation( *this ).GetContentSize();
2065 }
2066
2067 void WebEngine::SetSize( uint32_t width, uint32_t height )
2068 {
2069 }
2070
2071 void WebEngine::SetDocumentBackgroundColor(Dali::Vector4 color)
2072 {
2073 }
2074
2075 void WebEngine::ClearTilesWhenHidden(bool cleared)
2076 {
2077 }
2078
2079 void WebEngine::SetTileCoverAreaMultiplier(float multiplier)
2080 {
2081 }
2082
2083 void WebEngine::EnableCursorByClient(bool enabled)
2084 {
2085 }
2086
2087 std::string WebEngine::GetSelectedText() const
2088 {
2089   return "test";
2090 }
2091
2092 bool WebEngine::SendTouchEvent( const TouchEvent& touch )
2093 {
2094   return true;
2095 }
2096
2097 bool WebEngine::SendKeyEvent( const KeyEvent& event )
2098 {
2099   return true;
2100 }
2101
2102 bool WebEngine::SendHoverEvent( const HoverEvent& event )
2103 {
2104   return true;
2105 }
2106
2107 bool WebEngine::SendWheelEvent( const WheelEvent& event )
2108 {
2109   return true;
2110 }
2111
2112 void WebEngine::SetFocus( bool focused )
2113 {
2114 }
2115
2116 void WebEngine::SetPageZoomFactor(float zoomFactor)
2117 {
2118   Internal::Adaptor::GetImplementation( *this ).SetPageZoomFactor(zoomFactor);
2119 }
2120
2121 float WebEngine::GetPageZoomFactor() const
2122 {
2123   return Internal::Adaptor::GetImplementation( *this ).GetPageZoomFactor();
2124 }
2125
2126 void WebEngine::SetTextZoomFactor(float zoomFactor)
2127 {
2128   Internal::Adaptor::GetImplementation( *this ).SetTextZoomFactor(zoomFactor);
2129 }
2130
2131 float WebEngine::GetTextZoomFactor() const
2132 {
2133   return Internal::Adaptor::GetImplementation( *this ).GetTextZoomFactor();
2134 }
2135
2136 float WebEngine::GetLoadProgressPercentage() const
2137 {
2138   return Internal::Adaptor::GetImplementation( *this ).GetLoadProgressPercentage();
2139 }
2140
2141 void WebEngine::UpdateDisplayArea( Dali::Rect< int32_t > displayArea )
2142 {
2143 }
2144
2145 void WebEngine::EnableVideoHole( bool enabled )
2146 {
2147 }
2148
2149 void WebEngine::EnableMouseEvents( bool enabled )
2150 {
2151 }
2152
2153 void WebEngine::EnableKeyEvents( bool enabled )
2154 {
2155 }
2156
2157 Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadStartedSignal()
2158 {
2159   return Internal::Adaptor::GetImplementation( *this ).PageLoadStartedSignal();
2160 }
2161
2162 Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadInProgressSignal()
2163 {
2164   return Internal::Adaptor::GetImplementation( *this ).PageLoadInProgressSignal();
2165 }
2166
2167 Dali::WebEnginePlugin::WebEnginePageLoadSignalType& WebEngine::PageLoadFinishedSignal()
2168 {
2169   return Internal::Adaptor::GetImplementation( *this ).PageLoadFinishedSignal();
2170 }
2171
2172 Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& WebEngine::PageLoadErrorSignal()
2173 {
2174   return Internal::Adaptor::GetImplementation( *this ).PageLoadErrorSignal();
2175 }
2176
2177 Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType& WebEngine::ScrollEdgeReachedSignal()
2178 {
2179   return Internal::Adaptor::GetImplementation( *this ).ScrollEdgeReachedSignal();
2180 }
2181
2182 Dali::WebEnginePlugin::WebEngineUrlChangedSignalType& WebEngine::UrlChangedSignal()
2183 {
2184   return Internal::Adaptor::GetImplementation( *this ).UrlChangedSignal();
2185 }
2186
2187 Dali::WebEnginePlugin::WebEngineFormRepostDecisionSignalType& WebEngine::FormRepostDecisionSignal()
2188 {
2189   return Internal::Adaptor::GetImplementation(*this).FormRepostDecisionSignal();
2190 }
2191
2192 Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& WebEngine::FrameRenderedSignal()
2193 {
2194   return Internal::Adaptor::GetImplementation(*this).FrameRenderedSignal();
2195 }
2196
2197 Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType& WebEngine::RequestInterceptorSignal()
2198 {
2199   return Internal::Adaptor::GetImplementation(*this).RequestInterceptorSignal();
2200 }
2201
2202 Dali::WebEnginePlugin::WebEngineConsoleMessageSignalType& WebEngine::ConsoleMessageSignal()
2203 {
2204   return Internal::Adaptor::GetImplementation(*this).ConsoleMessageSignal();
2205 }
2206
2207 Dali::WebEnginePlugin::WebEnginePolicyDecisionSignalType& WebEngine::PolicyDecisionSignal()
2208 {
2209   return Internal::Adaptor::GetImplementation(*this).PolicyDecisionSignal();
2210 }
2211
2212 Dali::WebEnginePlugin::WebEngineCertificateSignalType& WebEngine::CertificateConfirmSignal()
2213 {
2214   return Internal::Adaptor::GetImplementation(*this).CertificateConfirmSignal();
2215 }
2216
2217 Dali::WebEnginePlugin::WebEngineCertificateSignalType& WebEngine::SslCertificateChangedSignal()
2218 {
2219   return Internal::Adaptor::GetImplementation(*this).SslCertificateChangedSignal();
2220 }
2221
2222 Dali::WebEnginePlugin::WebEngineHttpAuthHandlerSignalType& WebEngine::HttpAuthHandlerSignal()
2223 {
2224   return Internal::Adaptor::GetImplementation(*this).HttpAuthHandlerSignal();
2225 }
2226
2227 Dali::WebEnginePlugin::WebEngineContextMenuCustomizedSignalType& WebEngine::ContextMenuCustomizedSignal()
2228 {
2229   return Internal::Adaptor::GetImplementation( *this ).ContextMenuCustomizedSignal();
2230 }
2231
2232 Dali::WebEnginePlugin::WebEngineContextMenuItemSelectedSignalType& WebEngine::ContextMenuItemSelectedSignal()
2233 {
2234   return Internal::Adaptor::GetImplementation( *this ).ContextMenuItemSelectedSignal();
2235 }
2236
2237 } // namespace Dali;
2238