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 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::PixelData GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
1459   {
1460     uint32_t bufferSize = viewArea.width * viewArea.height * 4 ;
1461     uint8_t* pixel = new uint8_t[ bufferSize ];
1462     memset(pixel, 0xff, bufferSize);
1463     return Dali::PixelData::New( pixel, bufferSize, viewArea.width, viewArea.height,
1464                                  Dali::Pixel::Format::RGBA8888,
1465                                  Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
1466   }
1467
1468   bool GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
1469   {
1470     if ( callback )
1471     {
1472       ConnectToGlobalSignal( &OnScreenshotCaptured );
1473       mScreenshotCapturedCallback = callback;
1474     }
1475     return true;
1476   }
1477
1478   bool CheckVideoPlayingAsynchronously(Dali::WebEnginePlugin::VideoPlayingCallback callback)
1479   {
1480     if ( callback )
1481     {
1482       ConnectToGlobalSignal( &OnVideoPlaying );
1483       mVideoPlayingCallback = callback;
1484     }
1485     return true;
1486   }
1487
1488   void RegisterGeolocationPermissionCallback(Dali::WebEnginePlugin::GeolocationPermissionCallback callback)
1489   {
1490     if ( callback )
1491     {
1492       ConnectToGlobalSignal( &OnGeolocationPermission );
1493       mGeolocationPermissionCallback = callback;
1494     }
1495   }
1496
1497   Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& FrameRenderedSignal()
1498   {
1499     return mFrameRenderedSignal;
1500   }
1501
1502   void RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
1503   {
1504     mPageLoadStartedCallback = callback;
1505   }
1506
1507   void RegisterPageLoadInProgressCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
1508   {
1509     mPageLoadInProgressCallback = callback;
1510   }
1511
1512   void RegisterPageLoadFinishedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
1513   {
1514     mPageLoadFinishedCallback = callback;
1515   }
1516
1517   void RegisterPageLoadErrorCallback(Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback callback)
1518   {
1519     mPageLoadErrorCallback = callback;
1520   }
1521
1522   void RegisterScrollEdgeReachedCallback(Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback callback)
1523   {
1524     mScrollEdgeReachedCallback = callback;
1525   }
1526
1527   void RegisterUrlChangedCallback(Dali::WebEnginePlugin::WebEngineUrlChangedCallback callback)
1528   {
1529     mUrlChangedCallback = callback;
1530   }
1531
1532   void RegisterFormRepostDecidedCallback(Dali::WebEnginePlugin::WebEngineFormRepostDecidedCallback callback)
1533   {
1534     mFormRepostDecidedCallback = callback;
1535   }
1536
1537   void RegisterConsoleMessageReceivedCallback(Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback callback)
1538   {
1539     mConsoleMessageCallback = callback;
1540   }
1541
1542   void RegisterResponsePolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback callback)
1543   {
1544     mResponsePolicyDecisionCallback = callback;
1545   }
1546
1547   void RegisterNavigationPolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback callback)
1548   {
1549     mNavigationPolicyDecisionCallback = callback;
1550   }
1551
1552   void RegisterCertificateConfirmedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
1553   {
1554     mCertificateConfirmCallback = callback;
1555   }
1556
1557   void RegisterSslCertificateChangedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
1558   {
1559     mSslCertificateChangedCallback = callback;
1560   }
1561
1562   void RegisterHttpAuthHandlerCallback(Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback callback)
1563   {
1564     mHttpAuthHandlerCallback = callback;
1565   }
1566
1567   void RegisterContextMenuShownCallback(Dali::WebEnginePlugin::WebEngineContextMenuShownCallback callback)
1568   {
1569     mContextMenuShownCallback = callback;
1570   }
1571
1572   void RegisterContextMenuHiddenCallback(Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback callback)
1573   {
1574     mContextMenuHiddenCallback = callback;
1575   }
1576
1577   void GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
1578   {
1579     if (callback)
1580     {
1581       ConnectToGlobalSignal(&OnPlainTextReceived);
1582       mPlainTextReceivedCallback = callback;
1583     }
1584   }
1585
1586   std::string              mUrl;
1587   std::vector<std::string> mHistory;
1588   size_t                   mCurrentPlusOnePos;
1589   std::string              mUserAgent;
1590
1591   Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType mFrameRenderedSignal;
1592
1593   bool  mEvaluating;
1594   float mPageZoomFactor;
1595   float mTextZoomFactor;
1596   float mScaleFactor;
1597
1598   Dali::Vector2             mScrollPosition;
1599   Dali::Vector2             mScrollSize;
1600   Dali::Vector2             mContentSize;
1601   WebEngineBackForwardList* mockWebEngineBackForwardList;
1602   WebEngineContext*         mockWebEngineContext;
1603   WebEngineCookieManager*   mockWebEngineCookieManager;
1604   WebEngineSettings*        mockWebEngineSettings;
1605
1606   std::vector<Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback> mResultCallbacks;
1607
1608   Dali::WebEnginePlugin::WebEnginePageLoadCallback                mPageLoadStartedCallback;
1609   Dali::WebEnginePlugin::WebEnginePageLoadCallback                mPageLoadInProgressCallback;
1610   Dali::WebEnginePlugin::WebEnginePageLoadCallback                mPageLoadFinishedCallback;
1611   Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback           mPageLoadErrorCallback;
1612   Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback       mScrollEdgeReachedCallback;
1613   Dali::WebEnginePlugin::WebEngineUrlChangedCallback              mUrlChangedCallback;
1614   Dali::WebEnginePlugin::WebEngineFormRepostDecidedCallback       mFormRepostDecidedCallback;
1615   Dali::WebEnginePlugin::WebEngineFrameRenderedCallback           mFrameRenderedCallback;
1616   Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback  mConsoleMessageCallback;
1617   Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback   mResponsePolicyDecisionCallback;
1618   Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback mNavigationPolicyDecisionCallback;
1619   Dali::WebEnginePlugin::WebEngineCertificateCallback             mCertificateConfirmCallback;
1620   Dali::WebEnginePlugin::WebEngineCertificateCallback             mSslCertificateChangedCallback;
1621   Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback         mHttpAuthHandlerCallback;
1622   Dali::WebEnginePlugin::WebEngineContextMenuShownCallback        mContextMenuShownCallback;
1623   Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback       mContextMenuHiddenCallback;
1624   Dali::WebEnginePlugin::JavaScriptAlertCallback                  mJavaScriptAlertCallback;
1625   Dali::WebEnginePlugin::JavaScriptConfirmCallback                mJavaScriptConfirmCallback;
1626   Dali::WebEnginePlugin::JavaScriptPromptCallback                 mJavaScriptPromptCallback;
1627   Dali::WebEnginePlugin::ScreenshotCapturedCallback               mScreenshotCapturedCallback;
1628   Dali::WebEnginePlugin::VideoPlayingCallback                     mVideoPlayingCallback;
1629   Dali::WebEnginePlugin::GeolocationPermissionCallback            mGeolocationPermissionCallback;
1630   Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback          mHitTestCreatedCallback;
1631   Dali::WebEnginePlugin::PlainTextReceivedCallback                mPlainTextReceivedCallback;
1632 };
1633
1634
1635 namespace
1636 {
1637
1638 bool OnGoBack()
1639 {
1640   DisconnectFromGlobalSignal( &OnGoBack );
1641
1642   if( gInstance && gInstance->CanGoBack() )
1643   {
1644     gInstance->mCurrentPlusOnePos--;
1645   }
1646   return false;
1647 }
1648
1649 bool OnGoForward()
1650 {
1651   DisconnectFromGlobalSignal( &OnGoForward );
1652
1653   if( gInstance && gInstance->CanGoForward() )
1654   {
1655     gInstance->mCurrentPlusOnePos++;
1656   }
1657   return false;
1658 }
1659
1660 bool OnLoadUrl()
1661 {
1662   DisconnectFromGlobalSignal( &OnLoadUrl );
1663
1664   if( gInstance )
1665   {
1666     if( gInstance->mHistory.size() > gInstance->mCurrentPlusOnePos )
1667     {
1668       gInstance->mHistory.erase( gInstance->mHistory.begin() + gInstance->mCurrentPlusOnePos, gInstance->mHistory.end() );
1669     }
1670     gInstance->mHistory.push_back( gInstance->mUrl );
1671     gInstance->mCurrentPlusOnePos++;
1672     if (gInstance->mPageLoadStartedCallback)
1673     {
1674       gInstance->mPageLoadStartedCallback( gInstance->mUrl );
1675     }
1676     if (gInstance->mPageLoadInProgressCallback)
1677     {
1678       gInstance->mPageLoadInProgressCallback( gInstance->mUrl );
1679     }
1680     if (gInstance->mPageLoadFinishedCallback)
1681     {
1682       gInstance->mPageLoadFinishedCallback( gInstance->mUrl );
1683     }
1684     if (gInstance->mPageLoadErrorCallback)
1685     {
1686       std::unique_ptr<Dali::WebEngineLoadError> error(new MockWebEngineLoadError(gInstance->mUrl));
1687       gInstance->mPageLoadErrorCallback(std::move(error));
1688     }
1689     if (gInstance->mUrlChangedCallback)
1690     {
1691       gInstance->mUrlChangedCallback( "http://new-test" );
1692     }
1693     if (gInstance->mFormRepostDecidedCallback)
1694     {
1695       std::unique_ptr<Dali::WebEngineFormRepostDecision> repostDecision(new MockWebEngineFormRepostDecision());
1696       gInstance->mFormRepostDecidedCallback(std::move(repostDecision));
1697     }
1698     gInstance->mFrameRenderedSignal.Emit();
1699     if (gInstance->mFrameRenderedCallback)
1700     {
1701       gInstance->mFrameRenderedCallback();
1702     }
1703     if (gInstance->mConsoleMessageCallback)
1704     {
1705       std::unique_ptr<Dali::WebEngineConsoleMessage> message(new MockWebEngineConsoleMessage());
1706       gInstance->mConsoleMessageCallback(std::move(message));
1707     }
1708     if (gInstance->mResponsePolicyDecisionCallback)
1709     {
1710       std::unique_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
1711       gInstance->mResponsePolicyDecisionCallback(std::move(policyDecision));
1712     }
1713     if (gInstance->mNavigationPolicyDecisionCallback)
1714     {
1715       std::unique_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
1716       gInstance->mNavigationPolicyDecisionCallback(std::move(policyDecision));
1717     }
1718     if (gInstance->mCertificateConfirmCallback)
1719     {
1720       std::unique_ptr<Dali::WebEngineCertificate> certificate(new MockWebEngineCertificate());
1721       gInstance->mCertificateConfirmCallback(std::move(certificate));
1722     }
1723     if (gInstance->mSslCertificateChangedCallback)
1724     {
1725       std::unique_ptr<Dali::WebEngineCertificate> sslCertificate(new MockWebEngineCertificate());
1726       gInstance->mSslCertificateChangedCallback(std::move(sslCertificate));
1727     }
1728     if (gInstance->mHttpAuthHandlerCallback)
1729     {
1730       std::unique_ptr<Dali::WebEngineHttpAuthHandler> handler(new MockWebEngineHttpAuthHandler());
1731       gInstance->mHttpAuthHandlerCallback(std::move(handler));
1732     }
1733     if (gInstance->mContextMenuShownCallback)
1734     {
1735       std::unique_ptr<Dali::WebEngineContextMenu> menu(new MockWebEngineContextMenu());
1736       gInstance->mContextMenuShownCallback(std::move(menu));
1737     }
1738     if (gInstance->mContextMenuHiddenCallback)
1739     {
1740       std::unique_ptr<Dali::WebEngineContextMenu> hiddenMenu(new MockWebEngineContextMenu());
1741       gInstance->mContextMenuHiddenCallback(std::move(hiddenMenu));
1742     }
1743   }
1744   return false;
1745 }
1746
1747 bool OnScrollEdge()
1748 {
1749   DisconnectFromGlobalSignal( &OnScrollEdge );
1750
1751   if( gInstance && gInstance->mScrollEdgeReachedCallback )
1752   {
1753     gInstance->mScrollEdgeReachedCallback( Dali::WebEnginePlugin::ScrollEdge::BOTTOM );
1754   }
1755
1756   return false;
1757 }
1758
1759 bool OnEvaluteJavaScript()
1760 {
1761   DisconnectFromGlobalSignal( &OnEvaluteJavaScript );
1762
1763   if( gInstance )
1764   {
1765     for( auto& func : gInstance->mResultCallbacks )
1766     {
1767       func("undefined");
1768     }
1769     gInstance->mResultCallbacks.clear();
1770   }
1771   return false;
1772 }
1773
1774 bool OnJavaScriptAlert()
1775 {
1776   DisconnectFromGlobalSignal( &OnJavaScriptAlert );
1777   if ( gInstance )
1778   {
1779     gInstance->mJavaScriptAlertCallback( "this is an alert popup." );
1780   }
1781   return false;
1782 }
1783
1784 bool OnJavaScriptConfirm()
1785 {
1786   DisconnectFromGlobalSignal( &OnJavaScriptConfirm );
1787   if ( gInstance )
1788   {
1789     gInstance->mJavaScriptConfirmCallback( "this is a confirm popup." );
1790   }
1791   return false;
1792 }
1793
1794 bool OnJavaScriptPrompt()
1795 {
1796   DisconnectFromGlobalSignal( &OnJavaScriptPrompt );
1797   if ( gInstance )
1798   {
1799     gInstance->mJavaScriptPromptCallback( "this is a prompt pompt.", "" );
1800   }
1801   return false;
1802 }
1803
1804 bool OnScreenshotCaptured()
1805 {
1806   DisconnectFromGlobalSignal( &OnScreenshotCaptured );
1807   if ( gInstance )
1808   {
1809     uint8_t* pixel = new uint8_t[ 2 * 2 * 4 ];
1810     memset(pixel, 0xff, 2 * 2 * 4);
1811     Dali::PixelData data = Dali::PixelData::New( pixel, 2 * 2 * 4, 2, 2,
1812                                  Dali::Pixel::Format::RGBA8888,
1813                                  Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
1814     gInstance->mScreenshotCapturedCallback( data );
1815   }
1816   return false;
1817 }
1818
1819 bool OnVideoPlaying()
1820 {
1821   DisconnectFromGlobalSignal( &OnVideoPlaying );
1822   if ( gInstance )
1823   {
1824     gInstance->mVideoPlayingCallback( true );
1825   }
1826   return false;
1827 }
1828
1829 bool OnGeolocationPermission()
1830 {
1831   DisconnectFromGlobalSignal( &OnGeolocationPermission );
1832   if ( gInstance )
1833   {
1834     gInstance->mGeolocationPermissionCallback( "", "" );
1835   }
1836   return false;
1837 }
1838
1839 bool OnHitTestCreated()
1840 {
1841   DisconnectFromGlobalSignal(&OnHitTestCreated);
1842   if (gInstance)
1843   {
1844     std::unique_ptr<Dali::WebEngineHitTest> test(new MockWebEngineHitTest());
1845     gInstance->mHitTestCreatedCallback(std::move(test));
1846   }
1847   return false;
1848 }
1849
1850 bool OnClearHistory()
1851 {
1852   DisconnectFromGlobalSignal( &OnClearHistory );
1853
1854   if( gInstance && gInstance->mCurrentPlusOnePos )
1855   {
1856     std::string url = gInstance->mHistory[ gInstance->mCurrentPlusOnePos - 1 ];
1857     std::vector< std::string >().swap( gInstance->mHistory );
1858     gInstance->mHistory.push_back( url );
1859     gInstance->mCurrentPlusOnePos = 1;
1860   }
1861   return false;
1862 }
1863
1864 bool OnSecurityOriginAcquired()
1865 {
1866   DisconnectFromGlobalSignal(&OnSecurityOriginAcquired);
1867   if (gWebEngineContextInstance)
1868   {
1869     std::vector<std::unique_ptr<Dali::WebEngineSecurityOrigin>> securityOriginList;
1870     std::unique_ptr<Dali::WebEngineSecurityOrigin> origin(new MockWebEngineSecurityOrigin());
1871     securityOriginList.push_back(std::move(origin));
1872     gWebEngineContextInstance->mSecurityOriginAcquiredCallback(securityOriginList);
1873   }
1874   return false;
1875 }
1876
1877 bool OnStorageUsageAcquired()
1878 {
1879   DisconnectFromGlobalSignal(&OnStorageUsageAcquired);
1880   if (gWebEngineContextInstance)
1881   {
1882     gWebEngineContextInstance->mStorageUsageAcquiredCallback(0);
1883   }
1884   return false;
1885 }
1886
1887 bool OnFormPasswordAcquired()
1888 {
1889   DisconnectFromGlobalSignal(&OnFormPasswordAcquired);
1890   if (gWebEngineContextInstance)
1891   {
1892     std::vector<std::unique_ptr<Dali::WebEngineContext::PasswordData>> formPasswordList;
1893     std::unique_ptr<Dali::WebEngineContext::PasswordData> data(new Dali::WebEngineContext::PasswordData());
1894     data->url = "http://test.html";
1895     data->useFingerprint = false;
1896     formPasswordList.push_back(std::move(data));
1897     gWebEngineContextInstance->mFormPasswordAcquiredCallback(formPasswordList);
1898   }
1899   return false;
1900 }
1901
1902 bool OnDownloadStarted()
1903 {
1904   DisconnectFromGlobalSignal(&OnDownloadStarted);
1905   if (gWebEngineContextInstance)
1906   {
1907     gWebEngineContextInstance->mDownloadStartedCallback("http://test.html");
1908   }
1909   return false;
1910 }
1911
1912 bool OnMimeOverridden()
1913 {
1914   DisconnectFromGlobalSignal(&OnMimeOverridden);
1915   if (gWebEngineContextInstance)
1916   {
1917     std::string newMime;
1918     gWebEngineContextInstance->mMimeOverriddenCallback("http://test.html", "txt/xml", newMime);
1919   }
1920   return false;
1921 }
1922
1923 bool OnRequestIntercepted()
1924 {
1925   DisconnectFromGlobalSignal(&OnRequestIntercepted);
1926   if (gWebEngineContextInstance)
1927   {
1928     Dali::WebEngineRequestInterceptorPtr interceptor = new MockWebEngineRequestInterceptor();
1929     gWebEngineContextInstance->mRequestInterceptedCallback(interceptor);
1930   }
1931   return false;
1932 }
1933
1934 bool OnChangesWatch()
1935 {
1936   DisconnectFromGlobalSignal( &OnChangesWatch );
1937
1938   if ( gInstance )
1939   {
1940     MockWebEngineCookieManager* temp = (MockWebEngineCookieManager *)(&(gInstance->GetCookieManager()));
1941     if ( temp )
1942     {
1943       temp->mChangesWatchCallback();
1944     }
1945   }
1946
1947   return false;
1948 }
1949
1950 bool OnPlainTextReceived()
1951 {
1952   DisconnectFromGlobalSignal(&OnPlainTextReceived);
1953   if (gInstance)
1954   {
1955     std::string dummyResultText;
1956     gInstance->mPlainTextReceivedCallback(dummyResultText);
1957   }
1958   return false;
1959 }
1960
1961 } // namespace
1962
1963 inline WebEngine& GetImplementation( Dali::WebEngine& webEngine )
1964 {
1965   DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
1966   BaseObject& handle = webEngine.GetBaseObject();
1967   return static_cast< Internal::Adaptor::WebEngine& >( handle );
1968 }
1969
1970 inline const WebEngine& GetImplementation( const Dali::WebEngine& webEngine )
1971 {
1972   DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
1973   const BaseObject& handle = webEngine.GetBaseObject();
1974   return static_cast< const Internal::Adaptor::WebEngine& >( handle );
1975 }
1976
1977 } // namespace Adaptor
1978
1979 } // namespace Internal
1980
1981 // Dali::WebEngine Implementation
1982 WebEngine::WebEngine()
1983 {
1984 }
1985
1986 WebEngine::WebEngine( Internal::Adaptor::WebEngine* internal )
1987 : BaseHandle( internal )
1988 {
1989 }
1990
1991 WebEngine::~WebEngine()
1992 {
1993 }
1994
1995 WebEngine WebEngine::New()
1996 {
1997   Internal::Adaptor::WebEngine* baseObject = new Internal::Adaptor::WebEngine();
1998
1999   return WebEngine( baseObject );
2000 }
2001
2002 WebEngine::WebEngine( const WebEngine& WebEngine )
2003 : BaseHandle( WebEngine )
2004 {
2005 }
2006
2007 WebEngine& WebEngine::operator=( const WebEngine& webEngine )
2008 {
2009   BaseHandle::operator=( webEngine );
2010   return *this;
2011 }
2012
2013 WebEngine WebEngine::DownCast( BaseHandle handle )
2014 {
2015   return WebEngine( dynamic_cast< Internal::Adaptor::WebEngine* >( handle.GetObjectPtr() ) );
2016 }
2017
2018 void WebEngine::Create( uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneId )
2019 {
2020 }
2021
2022 void WebEngine::Create( uint32_t width, uint32_t height, uint32_t argc, char** argv )
2023 {
2024 }
2025
2026 void WebEngine::Destroy()
2027 {
2028 }
2029
2030 WebEngineSettings& WebEngine::GetSettings() const
2031 {
2032   return Internal::Adaptor::GetImplementation( *this ).GetSettings();
2033 }
2034
2035 WebEngineContext& WebEngine::GetContext() const
2036 {
2037   return Internal::Adaptor::GetImplementation( *this ).GetContext();
2038 }
2039
2040 WebEngineCookieManager& WebEngine::GetCookieManager() const
2041 {
2042   return Internal::Adaptor::GetImplementation( *this ).GetCookieManager();
2043 }
2044
2045 WebEngineBackForwardList& WebEngine::GetBackForwardList() const
2046 {
2047   return Internal::Adaptor::GetImplementation( *this ).GetBackForwardList();
2048 }
2049
2050 void WebEngine::LoadUrl( const std::string& url )
2051 {
2052   return Internal::Adaptor::GetImplementation( *this ).LoadUrl( url );
2053 }
2054
2055 std::string WebEngine::GetTitle() const
2056 {
2057   return Internal::Adaptor::GetImplementation( *this ).GetTitle();
2058 }
2059
2060 Dali::PixelData WebEngine::GetFavicon() const
2061 {
2062   return Internal::Adaptor::GetImplementation( *this ).GetFavicon();
2063 }
2064
2065 std::string WebEngine::GetUrl() const
2066 {
2067   return Internal::Adaptor::GetImplementation( *this ).GetUrl();
2068 }
2069
2070 NativeImageSourcePtr WebEngine::GetNativeImageSource()
2071 {
2072   Any source;
2073   Dali::NativeImageSourcePtr sourcePtr = Dali::NativeImageSource::New( source );
2074   return sourcePtr;
2075 }
2076
2077 void WebEngine::LoadHtmlString( const std::string& htmlString )
2078 {
2079 }
2080
2081 bool WebEngine::LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl)
2082 {
2083   return true;
2084 }
2085
2086 bool WebEngine::LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri)
2087 {
2088   return true;
2089 }
2090
2091 void WebEngine::Reload()
2092 {
2093 }
2094
2095 bool WebEngine::ReloadWithoutCache()
2096 {
2097   return true;
2098 }
2099
2100 void WebEngine::StopLoading()
2101 {
2102 }
2103
2104 void WebEngine::Suspend()
2105 {
2106 }
2107
2108 void WebEngine::Resume()
2109 {
2110 }
2111
2112 void WebEngine::SuspendNetworkLoading()
2113 {
2114 }
2115
2116 void WebEngine::ResumeNetworkLoading()
2117 {
2118 }
2119
2120 bool WebEngine::AddCustomHeader(const std::string& name, const std::string& value)
2121 {
2122   return true;
2123 }
2124
2125 bool WebEngine::RemoveCustomHeader(const std::string& name)
2126 {
2127   return true;
2128 }
2129
2130 uint32_t WebEngine::StartInspectorServer(uint32_t port)
2131 {
2132   return port;
2133 }
2134
2135 bool WebEngine::StopInspectorServer()
2136 {
2137   return true;
2138 }
2139
2140 bool WebEngine::CanGoForward()
2141 {
2142   return Internal::Adaptor::GetImplementation( *this ).CanGoForward();
2143 }
2144
2145 void WebEngine::GoForward()
2146 {
2147   Internal::Adaptor::GetImplementation( *this ).GoForward();
2148 }
2149
2150 bool WebEngine::CanGoBack()
2151 {
2152   return Internal::Adaptor::GetImplementation( *this ).CanGoBack();
2153 }
2154
2155 void WebEngine::GoBack()
2156 {
2157   Internal::Adaptor::GetImplementation( *this ).GoBack();
2158 }
2159
2160 void WebEngine::EvaluateJavaScript( const std::string& script, std::function< void( const std::string& ) > resultHandler )
2161 {
2162   Internal::Adaptor::GetImplementation( *this ).EvaluateJavaScript( script, resultHandler );
2163 }
2164
2165 void WebEngine::AddJavaScriptMessageHandler( const std::string& exposedObjectName, std::function< void(const std::string&) > handler )
2166 {
2167 }
2168
2169 void WebEngine::RegisterJavaScriptAlertCallback( Dali::WebEnginePlugin::JavaScriptAlertCallback callback )
2170 {
2171   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptAlertCallback( callback );
2172 }
2173
2174 void WebEngine::JavaScriptAlertReply()
2175 {
2176 }
2177
2178 void WebEngine::RegisterJavaScriptConfirmCallback( Dali::WebEnginePlugin::JavaScriptConfirmCallback callback )
2179 {
2180   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptConfirmCallback( callback );
2181 }
2182
2183 void WebEngine::JavaScriptConfirmReply( bool confirmed )
2184 {
2185 }
2186
2187 void WebEngine::RegisterJavaScriptPromptCallback( Dali::WebEnginePlugin::JavaScriptPromptCallback callback )
2188 {
2189   Internal::Adaptor::GetImplementation( *this ).RegisterJavaScriptPromptCallback( callback );
2190 }
2191
2192 void WebEngine::JavaScriptPromptReply( const std::string& result )
2193 {
2194 }
2195
2196 std::unique_ptr<Dali::WebEngineHitTest> WebEngine::CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
2197 {
2198   return Internal::Adaptor::GetImplementation(*this).CreateHitTest(x, y, mode);
2199 }
2200
2201 bool WebEngine::CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
2202 {
2203   return Internal::Adaptor::GetImplementation(*this).CreateHitTestAsynchronously(x, y, mode, callback);
2204 }
2205
2206 void WebEngine::ClearAllTilesResources()
2207 {
2208 }
2209
2210 void WebEngine::ClearHistory()
2211 {
2212   Internal::Adaptor::GetImplementation( *this ).ClearHistory();
2213 }
2214
2215 void WebEngine::SetScaleFactor(float scaleFactor, Dali::Vector2 point)
2216 {
2217   Internal::Adaptor::GetImplementation( *this ).SetScaleFactor(scaleFactor, point);
2218 }
2219
2220 float WebEngine::GetScaleFactor() const
2221 {
2222   return Internal::Adaptor::GetImplementation( *this ).GetScaleFactor();
2223 }
2224
2225 void WebEngine::ActivateAccessibility(bool activated)
2226 {
2227 }
2228
2229 bool WebEngine::HighlightText(const std::string& text, Dali::WebEnginePlugin::FindOption options, uint32_t maxMatchCount)
2230 {
2231   return true;
2232 }
2233
2234 void WebEngine::AddDynamicCertificatePath(const std::string& host, const std::string& certPath)
2235 {
2236 }
2237
2238 Dali::PixelData WebEngine::GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
2239 {
2240   return Internal::Adaptor::GetImplementation( *this ).GetScreenshot(viewArea, scaleFactor);
2241 }
2242
2243 bool WebEngine::GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
2244 {
2245   return Internal::Adaptor::GetImplementation( *this ).GetScreenshotAsynchronously(viewArea, scaleFactor, callback);
2246 }
2247
2248 bool WebEngine::CheckVideoPlayingAsynchronously(Dali::WebEnginePlugin::VideoPlayingCallback callback)
2249 {
2250   return Internal::Adaptor::GetImplementation( *this ).CheckVideoPlayingAsynchronously(callback);
2251 }
2252
2253 void WebEngine::RegisterGeolocationPermissionCallback(Dali::WebEnginePlugin::GeolocationPermissionCallback callback)
2254 {
2255   Internal::Adaptor::GetImplementation( *this ).RegisterGeolocationPermissionCallback(callback);
2256 }
2257
2258 std::string WebEngine::GetUserAgent() const
2259 {
2260   return Internal::Adaptor::GetImplementation( *this ).GetUserAgent();
2261 }
2262
2263 void WebEngine::SetUserAgent( const std::string& userAgent )
2264 {
2265   Internal::Adaptor::GetImplementation( *this ).SetUserAgent( userAgent );
2266 }
2267
2268 void WebEngine::ScrollBy( int32_t dx, int32_t dy )
2269 {
2270   Internal::Adaptor::GetImplementation( *this ).ScrollBy( dx, dy );
2271 }
2272
2273 bool WebEngine::ScrollEdgeBy( int32_t dx, int32_t dy )
2274 {
2275   return Internal::Adaptor::GetImplementation( *this ).ScrollEdgeBy( dx, dy );
2276 }
2277
2278 void WebEngine::SetScrollPosition( int32_t x, int32_t y )
2279 {
2280   Internal::Adaptor::GetImplementation( *this ).SetScrollPosition( x, y );
2281 }
2282
2283 Dali::Vector2 WebEngine::GetScrollPosition() const
2284 {
2285   return Internal::Adaptor::GetImplementation( *this ).GetScrollPosition();
2286 }
2287
2288 Dali::Vector2 WebEngine::GetScrollSize() const
2289 {
2290   return Internal::Adaptor::GetImplementation( *this ).GetScrollSize();
2291 }
2292
2293 Dali::Vector2 WebEngine::GetContentSize() const
2294 {
2295   return Internal::Adaptor::GetImplementation( *this ).GetContentSize();
2296 }
2297
2298 void WebEngine::SetSize( uint32_t width, uint32_t height )
2299 {
2300 }
2301
2302 void WebEngine::SetDocumentBackgroundColor(Dali::Vector4 color)
2303 {
2304 }
2305
2306 void WebEngine::ClearTilesWhenHidden(bool cleared)
2307 {
2308 }
2309
2310 void WebEngine::SetTileCoverAreaMultiplier(float multiplier)
2311 {
2312 }
2313
2314 void WebEngine::EnableCursorByClient(bool enabled)
2315 {
2316 }
2317
2318 std::string WebEngine::GetSelectedText() const
2319 {
2320   return "test";
2321 }
2322
2323 bool WebEngine::SendTouchEvent( const TouchEvent& touch )
2324 {
2325   return true;
2326 }
2327
2328 bool WebEngine::SendKeyEvent( const KeyEvent& event )
2329 {
2330   return true;
2331 }
2332
2333 bool WebEngine::SendHoverEvent( const HoverEvent& event )
2334 {
2335   return true;
2336 }
2337
2338 bool WebEngine::SendWheelEvent( const WheelEvent& event )
2339 {
2340   return true;
2341 }
2342
2343 void WebEngine::SetFocus( bool focused )
2344 {
2345 }
2346
2347 void WebEngine::SetPageZoomFactor(float zoomFactor)
2348 {
2349   Internal::Adaptor::GetImplementation( *this ).SetPageZoomFactor(zoomFactor);
2350 }
2351
2352 float WebEngine::GetPageZoomFactor() const
2353 {
2354   return Internal::Adaptor::GetImplementation( *this ).GetPageZoomFactor();
2355 }
2356
2357 void WebEngine::SetTextZoomFactor(float zoomFactor)
2358 {
2359   Internal::Adaptor::GetImplementation( *this ).SetTextZoomFactor(zoomFactor);
2360 }
2361
2362 float WebEngine::GetTextZoomFactor() const
2363 {
2364   return Internal::Adaptor::GetImplementation( *this ).GetTextZoomFactor();
2365 }
2366
2367 float WebEngine::GetLoadProgressPercentage() const
2368 {
2369   return Internal::Adaptor::GetImplementation( *this ).GetLoadProgressPercentage();
2370 }
2371
2372 void WebEngine::UpdateDisplayArea( Dali::Rect< int32_t > displayArea )
2373 {
2374 }
2375
2376 void WebEngine::EnableVideoHole( bool enabled )
2377 {
2378 }
2379
2380 void WebEngine::EnableMouseEvents( bool enabled )
2381 {
2382 }
2383
2384 void WebEngine::EnableKeyEvents( bool enabled )
2385 {
2386 }
2387
2388 Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& WebEngine::FrameRenderedSignal()
2389 {
2390   return Internal::Adaptor::GetImplementation(*this).FrameRenderedSignal();
2391 }
2392
2393 void WebEngine::RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
2394 {
2395   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadStartedCallback(callback);
2396 }
2397
2398 void WebEngine::RegisterPageLoadInProgressCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
2399 {
2400   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadInProgressCallback(callback);
2401 }
2402
2403 void WebEngine::RegisterPageLoadFinishedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
2404 {
2405   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadFinishedCallback(callback);
2406 }
2407
2408 void WebEngine::RegisterPageLoadErrorCallback(Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback callback)
2409 {
2410   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadErrorCallback(callback);
2411 }
2412
2413 void WebEngine::RegisterScrollEdgeReachedCallback(Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback callback)
2414 {
2415   Internal::Adaptor::GetImplementation( *this ).RegisterScrollEdgeReachedCallback(callback);
2416 }
2417
2418 void WebEngine::RegisterUrlChangedCallback(Dali::WebEnginePlugin::WebEngineUrlChangedCallback callback)
2419 {
2420   Internal::Adaptor::GetImplementation( *this ).RegisterUrlChangedCallback(callback);
2421 }
2422
2423 void WebEngine::RegisterFormRepostDecidedCallback(Dali::WebEnginePlugin::WebEngineFormRepostDecidedCallback callback)
2424 {
2425   Internal::Adaptor::GetImplementation( *this ).RegisterFormRepostDecidedCallback(callback);
2426 }
2427
2428 void WebEngine::RegisterConsoleMessageReceivedCallback(Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback callback)
2429 {
2430   Internal::Adaptor::GetImplementation( *this ).RegisterConsoleMessageReceivedCallback(callback);
2431 }
2432
2433 void WebEngine::RegisterResponsePolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback callback)
2434 {
2435   Internal::Adaptor::GetImplementation( *this ).RegisterResponsePolicyDecidedCallback(callback);
2436 }
2437
2438 void WebEngine::RegisterNavigationPolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback callback)
2439 {
2440   Internal::Adaptor::GetImplementation(*this).RegisterNavigationPolicyDecidedCallback(callback);
2441 }
2442
2443 void WebEngine::RegisterCertificateConfirmedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
2444 {
2445   Internal::Adaptor::GetImplementation( *this ).RegisterCertificateConfirmedCallback(callback);
2446 }
2447
2448 void WebEngine::RegisterSslCertificateChangedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
2449 {
2450   Internal::Adaptor::GetImplementation( *this ).RegisterSslCertificateChangedCallback(callback);
2451 }
2452
2453 void WebEngine::RegisterHttpAuthHandlerCallback(Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback callback)
2454 {
2455   Internal::Adaptor::GetImplementation( *this ).RegisterHttpAuthHandlerCallback(callback);
2456 }
2457
2458 void WebEngine::RegisterContextMenuShownCallback(Dali::WebEnginePlugin::WebEngineContextMenuShownCallback callback)
2459 {
2460   Internal::Adaptor::GetImplementation( *this ).RegisterContextMenuShownCallback(callback);
2461 }
2462
2463 void WebEngine::RegisterContextMenuHiddenCallback(Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback callback)
2464 {
2465   Internal::Adaptor::GetImplementation( *this ).RegisterContextMenuHiddenCallback(callback);
2466 }
2467
2468 void WebEngine::GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
2469 {
2470   Internal::Adaptor::GetImplementation(*this).GetPlainTextAsynchronously(callback);
2471 }
2472
2473 } // namespace Dali;
2474