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