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