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

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