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