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