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

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