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

   1 /*
   2  * Copyright (c) 2020 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-context.h>
  24 #include <dali/devel-api/adaptor-framework/web-engine-cookie-manager.h>
  25 #include <dali/devel-api/adaptor-framework/web-engine-frame.h>
  26 #include <dali/devel-api/adaptor-framework/web-engine-policy-decision.h>
  27 #include <dali/devel-api/adaptor-framework/web-engine-settings.h>
  28 #include <dali/public-api/adaptor-framework/native-image-source.h>
  29 #include <dali/public-api/images/pixel-data.h>
  30 #include <dali/public-api/object/any.h>
  31 #include <dali/public-api/object/base-object.h>
  32 #include <toolkit-application.h>
  33
  34 namespace Dali
  35 {
  36
  37 namespace Internal
  38 {
  39
  40 namespace Adaptor
  41 {
  42
  43 class WebEngine;
  44
  45 namespace
  46 {
  47 static WebEngine* gInstance = NULL;
  48 static int gInstanceCount = 0;
  49
  50 bool OnGoBack();
  51 bool OnGoForward();
  52 bool OnLoadUrl();
  53 bool OnEvaluteJavaScript();
  54 bool OnClearHistory();
  55 bool OnPlainTextReceived();
  56
  57 static void ConnectToGlobalSignal( bool (*func)() )
  58 {
  59   Dali::Timer timer = Dali::Timer::New( 0 );
  60   timer.TickSignal().Connect( func );
  61 }
  62
  63 static void DisconnectFromGlobalSignal( bool (*func)() )
  64 {
  65   Dali::Timer timer = Dali::Timer::New( 0 );
  66   timer.TickSignal().Disconnect( func );
  67 }
  68 }
  69
  70 class MockWebEngineContext : public Dali::WebEngineContext
  71 {
  72 public:
  73   MockWebEngineContext()
  74     : mockModel( Dali::WebEngineContext::CacheModel::DOCUMENT_VIEWER )
  75   {
  76   }
  77
  78   Dali::WebEngineContext::CacheModel GetCacheModel() const override
  79   {
  80     return mockModel;
  81   }
  82
  83   void SetCacheModel( Dali::WebEngineContext::CacheModel cacheModel ) override
  84   {
  85     mockModel = cacheModel;
  86   }
  87
  88   void SetProxyUri( const std::string& uri ) override
  89   {
  90   }
  91
  92   void SetDefaultProxyAuth( const std::string& username, const std::string& password ) override
  93   {
  94   }
  95
  96   void SetCertificateFilePath( const std::string& certificatePath ) override
  97   {
  98   }
  99
 100   void DeleteWebDatabase() override
 101   {
 102   }
 103
 104   void DeleteWebStorage() override
 105   {
 106   }
 107
 108   void DeleteLocalFileSystem() override
 109   {
 110   }
 111
 112   void DisableCache( bool cacheDisabled ) override
 113   {
 114   }
 115
 116   void ClearCache() override
 117   {
 118   }
 119
 120 private:
 121   Dali::WebEngineContext::CacheModel mockModel;
 122 };
 123
 124 class MockWebEngineCookieManager : public Dali::WebEngineCookieManager
 125 {
 126 public:
 127   MockWebEngineCookieManager()
 128     : mockCookieAcceptPolicy( Dali::WebEngineCookieManager::CookieAcceptPolicy::NO_THIRD_PARTY )
 129   {
 130   }
 131
 132   void SetCookieAcceptPolicy( Dali::WebEngineCookieManager::CookieAcceptPolicy policy ) override
 133   {
 134     mockCookieAcceptPolicy = policy;
 135   }
 136
 137   Dali::WebEngineCookieManager::CookieAcceptPolicy GetCookieAcceptPolicy() const override
 138   {
 139     return mockCookieAcceptPolicy;
 140   }
 141
 142   void ClearCookies() override
 143   {
 144   }
 145
 146   void SetPersistentStorage( const std::string& path, Dali::WebEngineCookieManager::CookiePersistentStorage storage ) override
 147   {
 148   }
 149
 150 private:
 151   Dali::WebEngineCookieManager::CookieAcceptPolicy mockCookieAcceptPolicy;
 152 };
 153
 154 class MockWebEngineBackForwardListItem : public Dali::WebEngineBackForwardListItem
 155 {
 156 public:
 157   MockWebEngineBackForwardListItem()
 158     : mockUrl( "http://url" ),
 159       mockTitle( "title" ),
 160       mockOriginalUrl( "http://originalurl" )
 161   {
 162   }
 163
 164   std::string GetUrl() const override
 165   {
 166     return mockUrl;
 167   }
 168
 169   std::string GetTitle() const override
 170   {
 171     return mockTitle;
 172   }
 173
 174   std::string GetOriginalUrl() const override
 175   {
 176     return mockOriginalUrl;
 177   }
 178
 179 private:
 180   std::string mockUrl;
 181   std::string mockTitle;
 182   std::string mockOriginalUrl;
 183 };
 184
 185 class MockWebEngineBackForwardList : public Dali::WebEngineBackForwardList
 186 {
 187 public:
 188   MockWebEngineBackForwardList( )
 189     : mockItem(),
 190       pMockItem( &mockItem )
 191   {
 192   }
 193
 194   Dali::WebEngineBackForwardListItem& GetCurrentItem() const override
 195   {
 196     return *pMockItem;
 197   }
 198
 199   Dali::WebEngineBackForwardListItem& GetItemAtIndex( uint32_t index ) const override
 200   {
 201     return *pMockItem;
 202   }
 203
 204   uint32_t GetItemCount() const override
 205   {
 206     return 1;
 207   }
 208
 209 private:
 210   MockWebEngineBackForwardListItem mockItem;
 211   WebEngineBackForwardListItem* pMockItem;
 212 };
 213
 214 class MockWebEngineFrame : public Dali::WebEngineFrame
 215 {
 216 public:
 217   MockWebEngineFrame()
 218   {
 219   }
 220
 221   bool IsMainFrame() const override
 222   {
 223     return true;
 224   }
 225 };
 226
 227 class MockWebEnginePolicyDecision : public Dali::WebEnginePolicyDecision
 228 {
 229 public:
 230   MockWebEnginePolicyDecision()
 231   {
 232   }
 233
 234   std::string GetUrl() const override
 235   {
 236     return "http://test.html";
 237   }
 238
 239   std::string GetCookie() const override
 240   {
 241     return "test:abc";
 242   }
 243
 244   Dali::WebEnginePolicyDecision::DecisionType GetDecisionType() const
 245   {
 246     return Dali::WebEnginePolicyDecision::DecisionType::USE;
 247   }
 248
 249   std::string GetResponseMime() const
 250   {
 251     return "txt/xml";
 252   }
 253
 254   int32_t GetResponseStatusCode() const
 255   {
 256     return 500;
 257   }
 258
 259   Dali::WebEnginePolicyDecision::NavigationType GetNavigationType() const
 260   {
 261     return Dali::WebEnginePolicyDecision::NavigationType::LINK_CLICKED;
 262   }
 263
 264   Dali::WebEngineFrame& GetFrame() const
 265   {
 266     return *(Dali::WebEngineFrame*)(&mockWebFrame);
 267   }
 268
 269   std::string GetScheme() const
 270   {
 271     return "test";
 272   }
 273
 274   bool Use()
 275   {
 276     return true;
 277   }
 278
 279   bool Ignore()
 280   {
 281     return true;
 282   }
 283
 284   bool Suspend()
 285   {
 286     return true;
 287   }
 288
 289 private:
 290   MockWebEngineFrame mockWebFrame;
 291 };
 292
 293 class MockWebEngineSettings : public WebEngineSettings
 294 {
 295 public:
 296   MockWebEngineSettings()
 297     : mockDefaultFontSize( 16 ),
 298       mockJavaScriptEnabled( true ),
 299       mockImageLoadedAutomatically( true ),
 300       mockDefaultTextEncodingName()
 301   {
 302   }
 303
 304   uint32_t GetDefaultFontSize() const override
 305   {
 306     return mockDefaultFontSize;
 307   }
 308
 309   void SetDefaultFontSize( uint32_t size ) override
 310   {
 311     mockDefaultFontSize = size;
 312   }
 313
 314   bool IsJavaScriptEnabled() const override
 315   {
 316     return mockJavaScriptEnabled;
 317   }
 318
 319   void EnableJavaScript( bool enabled ) override
 320   {
 321     mockJavaScriptEnabled = enabled;
 322   }
 323
 324   bool AreImagesLoadedAutomatically() const override
 325   {
 326     return mockImageLoadedAutomatically;
 327   }
 328
 329   void AllowImagesLoadAutomatically( bool automatic ) override
 330   {
 331     mockImageLoadedAutomatically = automatic;
 332   }
 333
 334   std::string GetDefaultTextEncodingName() const override
 335   {
 336     return mockDefaultTextEncodingName;
 337   }
 338
 339   void SetDefaultTextEncodingName( const std::string& defaultTextEncodingName ) override
 340   {
 341     mockDefaultTextEncodingName = defaultTextEncodingName;
 342   }
 343
 344   void AllowMixedContents( bool allowed ) override
 345   {
 346   }
 347
 348   void EnableSpatialNavigation( bool enabled ) override
 349   {
 350   }
 351
 352   void EnableWebSecurity( bool enabled ) override
 353   {
 354   }
 355
 356   void AllowFileAccessFromExternalUrl( bool allowed ) override
 357   {
 358   }
 359
 360   void AllowScriptsOpenWindows( bool allowed ) override
 361   {
 362   }
 363
 364 private:
 365   int mockDefaultFontSize;
 366   bool mockJavaScriptEnabled;
 367   bool mockImageLoadedAutomatically;
 368   std::string mockDefaultTextEncodingName;
 369 };
 370
 371 class WebEngine: public Dali::BaseObject
 372 {
 373 public:
 374
 375   WebEngine()
 376     : mUrl()
 377     , mCurrentPlusOnePos( 0 )
 378     , mUserAgent()
 379     , mEvaluating( false )
 380     , mScrollPosition( 0, 0 )
 381     , mScrollSize( 500, 500 )
 382     , mContentSize( 500, 500 )
 383   {
 384     gInstanceCount++;
 385     gInstance = this;
 386
 387     mockWebEngineSettings = new MockWebEngineSettings();
 388     mockWebEngineContext = new MockWebEngineContext();
 389     mockWebEngineCookieManager = new MockWebEngineCookieManager();
 390     mockWebEngineBackForwardList = new MockWebEngineBackForwardList();
 391   }
 392
 393   virtual ~WebEngine()
 394   {
 395     gInstanceCount--;
 396     if( !gInstanceCount )
 397     {
 398       gInstance = NULL;
 399     }
 400
 401     delete mockWebEngineSettings;
 402     delete mockWebEngineContext;
 403     delete mockWebEngineCookieManager;
 404     delete mockWebEngineBackForwardList;
 405   }
 406
 407   Dali::WebEngineSettings& GetSettings() const
 408   {
 409     return *mockWebEngineSettings;
 410   }
 411
 412   Dali::WebEngineContext& GetContext() const
 413   {
 414     return *mockWebEngineContext;
 415   }
 416
 417   Dali::WebEngineCookieManager& GetCookieManager() const
 418   {
 419     return *mockWebEngineCookieManager;
 420   }
 421
 422   Dali::WebEngineBackForwardList& GetBackForwardList() const
 423   {
 424     return *mockWebEngineBackForwardList;
 425   }
 426
 427   void LoadUrl( const std::string& url )
 428   {
 429     mUrl = url;
 430     ConnectToGlobalSignal( &OnLoadUrl );
 431   }
 432
 433   const std::string& GetUrl() const
 434   {
 435     return mUrl;
 436   }
 437
 438   std::string GetTitle() const
 439   {
 440     return std::string("title");
 441   }
 442
 443   Dali::PixelData GetFavicon() const
 444   {
 445     uint8_t* faviconData = new uint8_t[ 16 ];
 446
 447     faviconData[ 0 ] = 0xff;
 448     faviconData[ 1 ] = 0x00;
 449     faviconData[ 2 ] = 0x00;
 450     faviconData[ 3 ] = 0xff;
 451     faviconData[ 4 ] = 0xff;
 452     faviconData[ 5 ] = 0x00;
 453     faviconData[ 6 ] = 0x00;
 454     faviconData[ 7 ] = 0xff;
 455     faviconData[ 8 ] = 0xff;
 456     faviconData[ 9 ] = 0x00;
 457     faviconData[ 10 ] = 0x00;
 458     faviconData[ 11 ] = 0xff;
 459     faviconData[ 12 ] = 0xff;
 460     faviconData[ 13 ] = 0x00;
 461     faviconData[ 14 ] = 0x00;
 462     faviconData[ 15 ] = 0xff;
 463
 464     return Dali::PixelData::New( faviconData, 16, 2, 2,
 465                                  Dali::Pixel::Format::RGBA8888,
 466                                  Dali::PixelData::ReleaseFunction::DELETE_ARRAY );
 467   }
 468
 469   bool CanGoForward() const
 470   {
 471     return mHistory.size() > mCurrentPlusOnePos;
 472   }
 473
 474   void GoForward()
 475   {
 476     ConnectToGlobalSignal( &OnGoForward );
 477   }
 478
 479   bool CanGoBack() const
 480   {
 481     return mCurrentPlusOnePos > 1;
 482   }
 483
 484   void GoBack()
 485   {
 486     ConnectToGlobalSignal( &OnGoBack );
 487   }
 488
 489   void EvaluateJavaScript( const std::string& script, Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback resultHandler )
 490   {
 491     if( resultHandler )
 492     {
 493       if( !mEvaluating )
 494       {
 495         ConnectToGlobalSignal( &OnEvaluteJavaScript );
 496       }
 497       mResultCallbacks.push_back( resultHandler );
 498     }
 499   }
 500
 501   void ClearHistory()
 502   {
 503     ConnectToGlobalSignal( &OnClearHistory );
 504   }
 505
 506   const std::string& GetUserAgent() const
 507   {
 508     return mUserAgent;
 509   }
 510
 511   void SetUserAgent( const std::string& userAgent )
 512   {
 513     mUserAgent = userAgent;
 514   }
 515
 516   void ScrollBy( int dx, int dy )
 517   {
 518     mScrollPosition += Dali::Vector2( dx, dy );
 519     if ( mScrollPosition.y + mScrollSize.height > mContentSize.height )
 520     {
 521       gInstance->mScrollEdgeReachedCallback( Dali::WebEnginePlugin::ScrollEdge::BOTTOM );
 522     }
 523   }
 524
 525   void SetScrollPosition( int x, int y )
 526   {
 527     mScrollPosition.x = x;
 528     mScrollPosition.y = y;
 529   }
 530
 531   void GetScrollPosition( int& x, int& y ) const
 532   {
 533     x = mScrollPosition.x;
 534     y = mScrollPosition.y;
 535   }
 536
 537   void GetScrollSize( int& w, int& h ) const
 538   {
 539     w = mScrollSize.width;
 540     h = mScrollSize.height;
 541   }
 542
 543   void GetContentSize( int& w, int& h ) const
 544   {
 545     w = mContentSize.width;
 546     h = mContentSize.height;
 547   }
 548
 549   void RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
 550   {
 551     mPageLoadStartedCallback = callback;
 552   }
 553
 554   void RegisterPageLoadFinishedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
 555   {
 556     mPageLoadFinishedCallback = callback;
 557   }
 558
 559   void RegisterPageLoadErrorCallback(Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback callback)
 560   {
 561     mPageLoadErrorCallback = callback;
 562   }
 563
 564   void RegisterScrollEdgeReachedCallback(Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback callback)
 565   {
 566     mScrollEdgeReachedCallback = callback;
 567   }
 568
 569   void RegisterNavigationPolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback callback)
 570   {
 571     mNavigationPolicyDecisionCallback = callback;
 572   }
 573
 574   void GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
 575   {
 576     if (callback)
 577     {
 578       ConnectToGlobalSignal(&OnPlainTextReceived);
 579       mPlainTextReceivedCallback = callback;
 580     }
 581   }
 582
 583   std::string                                                mUrl;
 584   std::vector< std::string >                                 mHistory;
 585   size_t                                                     mCurrentPlusOnePos;
 586   std::string                                                mUserAgent;
 587
 588   Dali::WebEnginePlugin::WebEnginePageLoadCallback                mPageLoadStartedCallback;
 589   Dali::WebEnginePlugin::WebEnginePageLoadCallback                mPageLoadFinishedCallback;
 590   Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback           mPageLoadErrorCallback;
 591   Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback       mScrollEdgeReachedCallback;
 592   Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback mNavigationPolicyDecisionCallback;
 593
 594   std::vector<Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback> mResultCallbacks;
 595   bool                                                                 mEvaluating;
 596
 597   Dali::Vector2                                               mScrollPosition;
 598   Dali::Vector2                                               mScrollSize;
 599   Dali::Vector2                                               mContentSize;
 600   WebEngineBackForwardList*                                   mockWebEngineBackForwardList;
 601   WebEngineContext*                                           mockWebEngineContext;
 602   WebEngineCookieManager*                                     mockWebEngineCookieManager;
 603   WebEngineSettings*                                          mockWebEngineSettings;
 604   Dali::WebEnginePlugin::PlainTextReceivedCallback            mPlainTextReceivedCallback;
 605 };
 606
 607 inline WebEngine& GetImplementation( Dali::WebEngine& webEngine )
 608 {
 609   DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
 610   BaseObject& handle = webEngine.GetBaseObject();
 611   return static_cast< Internal::Adaptor::WebEngine& >( handle );
 612 }
 613
 614 inline const WebEngine& GetImplementation( const Dali::WebEngine& webEngine )
 615 {
 616   DALI_ASSERT_ALWAYS( webEngine && "WebEngine handle is empty." );
 617   const BaseObject& handle = webEngine.GetBaseObject();
 618   return static_cast< const Internal::Adaptor::WebEngine& >( handle );
 619 }
 620
 621 namespace
 622 {
 623
 624 bool OnGoBack()
 625 {
 626   DisconnectFromGlobalSignal( &OnGoBack );
 627
 628   if( gInstance && gInstance->CanGoBack() )
 629   {
 630     gInstance->mCurrentPlusOnePos--;
 631   }
 632   return false;
 633 }
 634
 635 bool OnGoForward()
 636 {
 637   DisconnectFromGlobalSignal( &OnGoForward );
 638
 639   if( gInstance && gInstance->CanGoForward() )
 640   {
 641     gInstance->mCurrentPlusOnePos++;
 642   }
 643   return false;
 644 }
 645
 646 bool OnLoadUrl()
 647 {
 648   DisconnectFromGlobalSignal( &OnLoadUrl );
 649
 650   if( gInstance )
 651   {
 652     if( gInstance->mHistory.size() > gInstance->mCurrentPlusOnePos )
 653     {
 654       gInstance->mHistory.erase( gInstance->mHistory.begin() + gInstance->mCurrentPlusOnePos, gInstance->mHistory.end() );
 655     }
 656     gInstance->mHistory.push_back( gInstance->mUrl );
 657     gInstance->mCurrentPlusOnePos++;
 658     if (gInstance->mPageLoadStartedCallback)
 659     {
 660       gInstance->mPageLoadStartedCallback( gInstance->mUrl );
 661     }
 662     if (gInstance->mPageLoadFinishedCallback)
 663     {
 664       gInstance->mPageLoadFinishedCallback( gInstance->mUrl );
 665     }
 666     if (gInstance->mPageLoadErrorCallback)
 667     {
 668       gInstance->mPageLoadErrorCallback(gInstance->mUrl, WebView::LoadErrorCode::UNKNOWN);
 669     }
 670     if (gInstance->mNavigationPolicyDecisionCallback)
 671     {
 672       std::unique_ptr<Dali::WebEnginePolicyDecision> policyDecision(new MockWebEnginePolicyDecision());
 673       gInstance->mNavigationPolicyDecisionCallback(std::move(policyDecision));
 674     }
 675   }
 676   return false;
 677 }
 678
 679 bool OnEvaluteJavaScript()
 680 {
 681   DisconnectFromGlobalSignal( &OnEvaluteJavaScript );
 682
 683   if( gInstance )
 684   {
 685     for( auto& func : gInstance->mResultCallbacks )
 686     {
 687       func("undefined");
 688     }
 689     gInstance->mResultCallbacks.clear();
 690   }
 691   return false;
 692 }
 693
 694 bool OnClearHistory()
 695 {
 696   DisconnectFromGlobalSignal( &OnClearHistory );
 697
 698   if( gInstance && gInstance->mCurrentPlusOnePos ) {
 699     std::string url = gInstance->mHistory[ gInstance->mCurrentPlusOnePos - 1 ];
 700     std::vector< std::string >().swap( gInstance->mHistory );
 701     gInstance->mHistory.push_back( url );
 702     gInstance->mCurrentPlusOnePos = 1;
 703   }
 704   return false;
 705 }
 706
 707 bool OnPlainTextReceived()
 708 {
 709   DisconnectFromGlobalSignal(&OnPlainTextReceived);
 710   if (gInstance)
 711   {
 712     std::string dummyResultText;
 713     gInstance->mPlainTextReceivedCallback(dummyResultText);
 714   }
 715   return false;
 716 }
 717
 718 } // namespace
 719
 720 } // namespace Adaptor
 721
 722 } // namespace Internal
 723
 724
 725 // Dali::WebEngine Implementation
 726 WebEngine::WebEngine()
 727 {
 728 }
 729
 730 WebEngine::WebEngine( Internal::Adaptor::WebEngine* internal )
 731 : BaseHandle( internal )
 732 {
 733 }
 734
 735 WebEngine::~WebEngine()
 736 {
 737 }
 738
 739 WebEngine WebEngine::New()
 740 {
 741   Internal::Adaptor::WebEngine* baseObject = new Internal::Adaptor::WebEngine();
 742
 743   return WebEngine( baseObject );
 744 }
 745
 746 WebEngine::WebEngine( const WebEngine& WebEngine )
 747 : BaseHandle( WebEngine )
 748 {
 749 }
 750
 751 WebEngine& WebEngine::operator=( const WebEngine& webEngine )
 752 {
 753   BaseHandle::operator=( webEngine );
 754   return *this;
 755 }
 756
 757 WebEngine WebEngine::DownCast( BaseHandle handle )
 758 {
 759   return WebEngine( dynamic_cast< Internal::Adaptor::WebEngine* >( handle.GetObjectPtr() ) );
 760 }
 761
 762 void WebEngine::Create( int width, int height, const std::string& locale, const std::string& timezoneId )
 763 {
 764 }
 765
 766 void WebEngine::Create( int width, int height, int argc, char** argv )
 767 {
 768 }
 769
 770 void WebEngine::Destroy()
 771 {
 772 }
 773
 774 WebEngineSettings& WebEngine::GetSettings() const
 775 {
 776   return Internal::Adaptor::GetImplementation( *this ).GetSettings();
 777 }
 778
 779 WebEngineContext& WebEngine::GetContext() const
 780 {
 781   return Internal::Adaptor::GetImplementation( *this ).GetContext();
 782 }
 783
 784 WebEngineCookieManager& WebEngine::GetCookieManager() const
 785 {
 786   return Internal::Adaptor::GetImplementation( *this ).GetCookieManager();
 787 }
 788
 789 WebEngineBackForwardList& WebEngine::GetBackForwardList() const
 790 {
 791   return Internal::Adaptor::GetImplementation( *this ).GetBackForwardList();
 792 }
 793
 794 void WebEngine::LoadUrl( const std::string& url )
 795 {
 796   return Internal::Adaptor::GetImplementation( *this ).LoadUrl( url );
 797 }
 798
 799 std::string WebEngine::GetTitle() const
 800 {
 801   return Internal::Adaptor::GetImplementation( *this ).GetTitle();
 802 }
 803
 804 Dali::PixelData WebEngine::GetFavicon() const
 805 {
 806   return Internal::Adaptor::GetImplementation( *this ).GetFavicon();
 807 }
 808
 809 const std::string& WebEngine::GetUrl()
 810 {
 811   return Internal::Adaptor::GetImplementation( *this ).GetUrl();
 812 }
 813
 814 NativeImageInterfacePtr WebEngine::GetNativeImageSource()
 815 {
 816   Any source;
 817   Dali::NativeImageSourcePtr sourcePtr = Dali::NativeImageSource::New( source );
 818   return sourcePtr;
 819 }
 820
 821 void WebEngine::LoadHtmlString( const std::string& htmlString )
 822 {
 823 }
 824
 825 void WebEngine::Reload()
 826 {
 827 }
 828
 829 void WebEngine::StopLoading()
 830 {
 831 }
 832
 833 void WebEngine::Suspend()
 834 {
 835 }
 836
 837 void WebEngine::Resume()
 838 {
 839 }
 840
 841 bool WebEngine::CanGoForward()
 842 {
 843   return Internal::Adaptor::GetImplementation( *this ).CanGoForward();
 844 }
 845
 846 void WebEngine::GoForward()
 847 {
 848   Internal::Adaptor::GetImplementation( *this ).GoForward();
 849 }
 850
 851 bool WebEngine::CanGoBack()
 852 {
 853   return Internal::Adaptor::GetImplementation( *this ).CanGoBack();
 854 }
 855
 856 void WebEngine::GoBack()
 857 {
 858   Internal::Adaptor::GetImplementation( *this ).GoBack();
 859 }
 860
 861 void WebEngine::EvaluateJavaScript( const std::string& script, Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback resultHandler )
 862 {
 863   Internal::Adaptor::GetImplementation( *this ).EvaluateJavaScript( script, resultHandler );
 864 }
 865
 866 void WebEngine::AddJavaScriptMessageHandler( const std::string& exposedObjectName, Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback handler )
 867 {
 868 }
 869
 870 void WebEngine::ClearAllTilesResources()
 871 {
 872 }
 873
 874 void WebEngine::ClearHistory()
 875 {
 876   Internal::Adaptor::GetImplementation( *this ).ClearHistory();
 877 }
 878
 879 const std::string& WebEngine::GetUserAgent() const
 880 {
 881   return Internal::Adaptor::GetImplementation( *this ).GetUserAgent();
 882 }
 883
 884 void WebEngine::SetUserAgent( const std::string& userAgent )
 885 {
 886   Internal::Adaptor::GetImplementation( *this ).SetUserAgent( userAgent );
 887 }
 888
 889 void WebEngine::ScrollBy( int dx, int dy )
 890 {
 891   Internal::Adaptor::GetImplementation( *this ).ScrollBy( dx, dy );
 892 }
 893
 894 void WebEngine::SetScrollPosition( int x, int y )
 895 {
 896   Internal::Adaptor::GetImplementation( *this ).SetScrollPosition( x, y );
 897 }
 898
 899 void WebEngine::GetScrollPosition( int& x, int& y ) const
 900 {
 901   Internal::Adaptor::GetImplementation( *this ).GetScrollPosition( x, y );
 902 }
 903
 904 void WebEngine::GetScrollSize( int& w, int& h ) const
 905 {
 906   Internal::Adaptor::GetImplementation( *this ).GetScrollSize( w, h );
 907 }
 908
 909 void WebEngine::GetContentSize( int& w, int& h ) const
 910 {
 911   Internal::Adaptor::GetImplementation( *this ).GetContentSize( w, h );
 912 }
 913
 914 void WebEngine::SetSize( int width, int height )
 915 {
 916 }
 917
 918 bool WebEngine::SendTouchEvent( const TouchEvent& touch )
 919 {
 920   return true;
 921 }
 922
 923 bool WebEngine::SendKeyEvent( const KeyEvent& event )
 924 {
 925   return true;
 926 }
 927
 928 void WebEngine::SetFocus( bool focused )
 929 {
 930 }
 931
 932 void WebEngine::UpdateDisplayArea( Dali::Rect< int > displayArea )
 933 {
 934 }
 935
 936 void WebEngine::EnableVideoHole( bool enabled )
 937 {
 938 }
 939
 940 void WebEngine::RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
 941 {
 942   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadStartedCallback(callback);
 943 }
 944
 945 void WebEngine::RegisterPageLoadFinishedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
 946 {
 947   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadFinishedCallback(callback);
 948 }
 949
 950 void WebEngine::RegisterPageLoadErrorCallback(Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback callback)
 951 {
 952   Internal::Adaptor::GetImplementation( *this ).RegisterPageLoadErrorCallback(callback);
 953 }
 954
 955 void WebEngine::RegisterScrollEdgeReachedCallback(Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback callback)
 956 {
 957   Internal::Adaptor::GetImplementation( *this ).RegisterScrollEdgeReachedCallback(callback);
 958 }
 959
 960 void WebEngine::RegisterNavigationPolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback callback)
 961 {
 962   Internal::Adaptor::GetImplementation(*this).RegisterNavigationPolicyDecidedCallback(callback);
 963 }
 964
 965 void WebEngine::GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
 966 {
 967   Internal::Adaptor::GetImplementation(*this).GetPlainTextAsynchronously(callback);
 968 }
 969
 970 } // namespace Dali;
 971