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