dali/internal/web-engine/common/web-engine-impl.cpp

   1 /*
   2  * Copyright (c) 2023 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 // CLASS HEADER
  19 #include <dali/internal/web-engine/common/web-engine-impl.h>
  20
  21 // EXTERNAL INCLUDES
  22 #include <dali/integration-api/debug.h>
  23 #include <dali/public-api/object/type-registry.h>
  24 #include <dlfcn.h>
  25 #include <sstream>
  26
  27 // INTERNAL INCLUDES
  28 #include <dali/devel-api/adaptor-framework/environment-variable.h>
  29 #include <dali/devel-api/adaptor-framework/web-engine/web-engine-back-forward-list.h>
  30 #include <dali/devel-api/adaptor-framework/web-engine/web-engine-certificate.h>
  31 #include <dali/devel-api/adaptor-framework/web-engine/web-engine-console-message.h>
  32 #include <dali/devel-api/adaptor-framework/web-engine/web-engine-context-menu.h>
  33 #include <dali/devel-api/adaptor-framework/web-engine/web-engine-context.h>
  34 #include <dali/devel-api/adaptor-framework/web-engine/web-engine-cookie-manager.h>
  35 #include <dali/devel-api/adaptor-framework/web-engine/web-engine-http-auth-handler.h>
  36 #include <dali/devel-api/adaptor-framework/web-engine/web-engine-load-error.h>
  37 #include <dali/devel-api/adaptor-framework/web-engine/web-engine-policy-decision.h>
  38 #include <dali/devel-api/adaptor-framework/web-engine/web-engine-settings.h>
  39 #include <dali/internal/system/common/environment-variables.h>
  40 #include <dali/public-api/adaptor-framework/native-image-source.h>
  41 #include <dali/public-api/images/pixel-data.h>
  42
  43 namespace Dali
  44 {
  45 namespace Internal
  46 {
  47 namespace Adaptor
  48 {
  49 namespace // unnamed namespace
  50 {
  51 constexpr char const* const kPluginFullNamePrefix  = "libdali2-web-engine-";
  52 constexpr char const* const kPluginFullNamePostfix = "-plugin.so";
  53 constexpr char const* const kPluginFullNameDefault = "libdali2-web-engine-plugin.so";
  54
  55 std::string MakePluginName(const char* environmentName)
  56 {
  57   std::stringstream fullName;
  58   fullName << kPluginFullNamePrefix << environmentName << kPluginFullNamePostfix;
  59   return std::move(fullName.str());
  60 }
  61
  62 Dali::BaseHandle Create()
  63 {
  64   return Dali::WebEngine::New();
  65 }
  66
  67 Dali::TypeRegistration type(typeid(Dali::WebEngine), typeid(Dali::BaseHandle), Create);
  68
  69 /**
  70  * @brief Control the WebEnginePlugin library lifecycle.
  71  * Hold the plugin library handle in static singletone.
  72  * It will makes library handle alives during all WebEngine resources create & destory.
  73  */
  74 struct WebEnginePluginObject
  75 {
  76 public:
  77   static WebEnginePluginObject& GetInstance()
  78   {
  79     static WebEnginePluginObject gPluginHandle;
  80     return gPluginHandle;
  81   }
  82
  83   /**
  84    * @brief Converts an handle to a bool.
  85    *
  86    * This is useful for checking whether the WebEnginePluginObject succes to load library.
  87    * @note We don't check mHandle because it is possible that mHandle load is success but
  88    * Create/Destroy API load failed.
  89    */
  90   explicit operator bool() const
  91   {
  92     return mLoadSucceeded;
  93   }
  94
  95   bool InitializeContextHandle()
  96   {
  97     if(!mHandle)
  98     {
  99       return false;
 100     }
 101
 102     if(!mGetWebEngineContextPtr)
 103     {
 104       mGetWebEngineContextPtr = reinterpret_cast<GetWebEngineContext>(dlsym(mHandle, "GetWebEngineContext"));
 105       if(!mGetWebEngineContextPtr)
 106       {
 107         DALI_LOG_ERROR("Can't load symbol GetWebEngineContext(), error: %s\n", dlerror());
 108         return false;
 109       }
 110     }
 111
 112     return true;
 113   }
 114
 115   bool InitializeCookieManagerHandle()
 116   {
 117     if(!mHandle)
 118     {
 119       return false;
 120     }
 121
 122     if(!mGetWebEngineCookieManagerPtr)
 123     {
 124       mGetWebEngineCookieManagerPtr = reinterpret_cast<GetWebEngineCookieManager>(dlsym(mHandle, "GetWebEngineCookieManager"));
 125       if(!mGetWebEngineCookieManagerPtr)
 126       {
 127         DALI_LOG_ERROR("Can't load symbol GetWebEngineCookieManager(), error: %s\n", dlerror());
 128         return false;
 129       }
 130     }
 131
 132     return true;
 133   }
 134
 135 private:
 136   // Private constructor / destructor
 137   WebEnginePluginObject()
 138   : mLoadSucceeded{false},
 139     mHandle{nullptr},
 140     mCreateWebEnginePtr{nullptr},
 141     mDestroyWebEnginePtr{nullptr},
 142     mGetWebEngineContextPtr{nullptr},
 143     mGetWebEngineCookieManagerPtr{nullptr}
 144   {
 145     std::string pluginName;
 146     const char* name = EnvironmentVariable::GetEnvironmentVariable(DALI_ENV_WEB_ENGINE_NAME);
 147     if(name)
 148     {
 149       pluginName = MakePluginName(name);
 150     }
 151     else
 152     {
 153       pluginName = std::string(kPluginFullNameDefault);
 154     }
 155
 156     mHandle = dlopen(pluginName.c_str(), RTLD_LAZY);
 157     if(!mHandle)
 158     {
 159       DALI_LOG_ERROR("Can't load %s : %s\n", pluginName.c_str(), dlerror());
 160       return;
 161     }
 162
 163     mCreateWebEnginePtr = reinterpret_cast<CreateWebEngineFunction>(dlsym(mHandle, "CreateWebEnginePlugin"));
 164     if(mCreateWebEnginePtr == nullptr)
 165     {
 166       DALI_LOG_ERROR("Can't load symbol CreateWebEnginePlugin(), error: %s\n", dlerror());
 167       return;
 168     }
 169
 170     mDestroyWebEnginePtr = reinterpret_cast<DestroyWebEngineFunction>(dlsym(mHandle, "DestroyWebEnginePlugin"));
 171     if(mDestroyWebEnginePtr == nullptr)
 172     {
 173       DALI_LOG_ERROR("Can't load symbol DestroyWebEnginePlugin(), error: %s\n", dlerror());
 174       return;
 175     }
 176
 177     mLoadSucceeded = true;
 178   }
 179
 180   ~WebEnginePluginObject()
 181   {
 182     if(mHandle)
 183     {
 184       dlclose(mHandle);
 185       mHandle        = nullptr;
 186       mLoadSucceeded = false;
 187     }
 188   }
 189
 190   WebEnginePluginObject(const WebEnginePluginObject&) = delete;
 191   WebEnginePluginObject(WebEnginePluginObject&&)      = delete;
 192   WebEnginePluginObject& operator=(const WebEnginePluginObject&) = delete;
 193   WebEnginePluginObject& operator=(WebEnginePluginObject&&) = delete;
 194
 195 private:
 196   bool mLoadSucceeded; ///< True if library loaded successfully. False otherwise.
 197
 198 public:
 199   using CreateWebEngineFunction  = Dali::WebEnginePlugin* (*)();
 200   using DestroyWebEngineFunction = void (*)(Dali::WebEnginePlugin* plugin);
 201
 202   using GetWebEngineContext       = Dali::WebEngineContext* (*)();
 203   using GetWebEngineCookieManager = Dali::WebEngineCookieManager* (*)();
 204
 205   void*                    mHandle;              ///< Handle for the loaded library
 206   CreateWebEngineFunction  mCreateWebEnginePtr;  ///< Function to create plugin instance
 207   DestroyWebEngineFunction mDestroyWebEnginePtr; ///< Function to destroy plugin instance
 208
 209   GetWebEngineContext       mGetWebEngineContextPtr;       ///< Function to get WebEngineContext
 210   GetWebEngineCookieManager mGetWebEngineCookieManagerPtr; ///< Function to get WebEngineCookieManager
 211 };
 212
 213 } // unnamed namespace
 214
 215 WebEnginePtr WebEngine::New()
 216 {
 217   WebEngine* instance = new WebEngine();
 218   if(!instance->Initialize())
 219   {
 220     delete instance;
 221     return nullptr;
 222   }
 223
 224   return instance;
 225 }
 226
 227 Dali::WebEngineContext* WebEngine::GetContext()
 228 {
 229   if(!WebEnginePluginObject::GetInstance().InitializeContextHandle())
 230   {
 231     return nullptr;
 232   }
 233
 234   if(WebEnginePluginObject::GetInstance().mGetWebEngineContextPtr)
 235   {
 236     return WebEnginePluginObject::GetInstance().mGetWebEngineContextPtr();
 237   }
 238
 239   return nullptr;
 240 }
 241
 242 Dali::WebEngineCookieManager* WebEngine::GetCookieManager()
 243 {
 244   if(!WebEnginePluginObject::GetInstance().InitializeCookieManagerHandle())
 245   {
 246     return nullptr;
 247   }
 248
 249   if(WebEnginePluginObject::GetInstance().mGetWebEngineCookieManagerPtr)
 250   {
 251     return WebEnginePluginObject::GetInstance().mGetWebEngineCookieManagerPtr();
 252   }
 253
 254   return nullptr;
 255 }
 256
 257 WebEngine::WebEngine()
 258 : mPlugin(nullptr)
 259 {
 260 }
 261
 262 WebEngine::~WebEngine()
 263 {
 264   if(mPlugin != nullptr)
 265   {
 266     mPlugin->Destroy();
 267     // Check whether plugin load sccess or not.
 268     if(DALI_LIKELY(WebEnginePluginObject::GetInstance()))
 269     {
 270       WebEnginePluginObject::GetInstance().mDestroyWebEnginePtr(mPlugin);
 271     }
 272     mPlugin = nullptr;
 273   }
 274 }
 275
 276 bool WebEngine::Initialize()
 277 {
 278   // Check whether plugin load sccess or not.
 279   if(!WebEnginePluginObject::GetInstance())
 280   {
 281     return false;
 282   }
 283
 284   mPlugin = WebEnginePluginObject::GetInstance().mCreateWebEnginePtr();
 285   if(mPlugin == nullptr)
 286   {
 287     DALI_LOG_ERROR("Can't create the WebEnginePlugin object\n");
 288     return false;
 289   }
 290   return true;
 291 }
 292
 293 void WebEngine::Create(uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneId)
 294 {
 295   mPlugin->Create(width, height, locale, timezoneId);
 296 }
 297
 298 void WebEngine::Create(uint32_t width, uint32_t height, uint32_t argc, char** argv)
 299 {
 300   mPlugin->Create(width, height, argc, argv);
 301 }
 302
 303 void WebEngine::Destroy()
 304 {
 305   mPlugin->Destroy();
 306 }
 307
 308 Dali::WebEnginePlugin* WebEngine::GetPlugin() const
 309 {
 310   return mPlugin;
 311 }
 312
 313 Dali::NativeImageSourcePtr WebEngine::GetNativeImageSource()
 314 {
 315   return mPlugin->GetNativeImageSource();
 316 }
 317
 318 Dali::WebEngineSettings& WebEngine::GetSettings() const
 319 {
 320   return mPlugin->GetSettings();
 321 }
 322
 323 Dali::WebEngineBackForwardList& WebEngine::GetBackForwardList() const
 324 {
 325   return mPlugin->GetBackForwardList();
 326 }
 327
 328 void WebEngine::LoadUrl(const std::string& url)
 329 {
 330   mPlugin->LoadUrl(url);
 331 }
 332
 333 std::string WebEngine::GetTitle() const
 334 {
 335   return mPlugin->GetTitle();
 336 }
 337
 338 Dali::PixelData WebEngine::GetFavicon() const
 339 {
 340   return mPlugin->GetFavicon();
 341 }
 342
 343 std::string WebEngine::GetUrl() const
 344 {
 345   return mPlugin->GetUrl();
 346 }
 347
 348 std::string WebEngine::GetUserAgent() const
 349 {
 350   return mPlugin->GetUserAgent();
 351 }
 352
 353 void WebEngine::SetUserAgent(const std::string& userAgent)
 354 {
 355   mPlugin->SetUserAgent(userAgent);
 356 }
 357
 358 void WebEngine::LoadHtmlString(const std::string& htmlString)
 359 {
 360   mPlugin->LoadHtmlString(htmlString);
 361 }
 362
 363 bool WebEngine::LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl)
 364 {
 365   return mPlugin->LoadHtmlStringOverrideCurrentEntry(html, basicUri, unreachableUrl);
 366 }
 367
 368 bool WebEngine::LoadContents(const int8_t* contents, uint32_t contentSize, const std::string& mimeType, const std::string& encoding, const std::string& baseUri)
 369 {
 370   return mPlugin->LoadContents(contents, contentSize, mimeType, encoding, baseUri);
 371 }
 372
 373 void WebEngine::Reload()
 374 {
 375   mPlugin->Reload();
 376 }
 377
 378 bool WebEngine::ReloadWithoutCache()
 379 {
 380   return mPlugin->ReloadWithoutCache();
 381 }
 382
 383 void WebEngine::StopLoading()
 384 {
 385   mPlugin->StopLoading();
 386 }
 387
 388 void WebEngine::Suspend()
 389 {
 390   mPlugin->Suspend();
 391 }
 392
 393 void WebEngine::Resume()
 394 {
 395   mPlugin->Resume();
 396 }
 397
 398 void WebEngine::SuspendNetworkLoading()
 399 {
 400   mPlugin->SuspendNetworkLoading();
 401 }
 402
 403 void WebEngine::ResumeNetworkLoading()
 404 {
 405   mPlugin->ResumeNetworkLoading();
 406 }
 407
 408 bool WebEngine::AddCustomHeader(const std::string& name, const std::string& value)
 409 {
 410   return mPlugin->AddCustomHeader(name, value);
 411 }
 412
 413 bool WebEngine::RemoveCustomHeader(const std::string& name)
 414 {
 415   return mPlugin->RemoveCustomHeader(name);
 416 }
 417
 418 uint32_t WebEngine::StartInspectorServer(uint32_t port)
 419 {
 420   return mPlugin->StartInspectorServer(port);
 421 }
 422
 423 bool WebEngine::StopInspectorServer()
 424 {
 425   return mPlugin->StopInspectorServer();
 426 }
 427
 428 void WebEngine::ScrollBy(int32_t deltaX, int32_t deltaY)
 429 {
 430   mPlugin->ScrollBy(deltaX, deltaY);
 431 }
 432
 433 bool WebEngine::ScrollEdgeBy(int32_t deltaX, int32_t deltaY)
 434 {
 435   return mPlugin->ScrollEdgeBy(deltaX, deltaY);
 436 }
 437
 438 void WebEngine::SetScrollPosition(int32_t x, int32_t y)
 439 {
 440   mPlugin->SetScrollPosition(x, y);
 441 }
 442
 443 Dali::Vector2 WebEngine::GetScrollPosition() const
 444 {
 445   return mPlugin->GetScrollPosition();
 446 }
 447
 448 Dali::Vector2 WebEngine::GetScrollSize() const
 449 {
 450   return mPlugin->GetScrollSize();
 451 }
 452
 453 Dali::Vector2 WebEngine::GetContentSize() const
 454 {
 455   return mPlugin->GetContentSize();
 456 }
 457
 458 void WebEngine::RegisterJavaScriptAlertCallback(Dali::WebEnginePlugin::JavaScriptAlertCallback callback)
 459 {
 460   mPlugin->RegisterJavaScriptAlertCallback(callback);
 461 }
 462
 463 void WebEngine::JavaScriptAlertReply()
 464 {
 465   mPlugin->JavaScriptAlertReply();
 466 }
 467
 468 void WebEngine::RegisterJavaScriptConfirmCallback(Dali::WebEnginePlugin::JavaScriptConfirmCallback callback)
 469 {
 470   mPlugin->RegisterJavaScriptConfirmCallback(callback);
 471 }
 472
 473 void WebEngine::JavaScriptConfirmReply(bool confirmed)
 474 {
 475   mPlugin->JavaScriptConfirmReply(confirmed);
 476 }
 477
 478 void WebEngine::RegisterJavaScriptPromptCallback(Dali::WebEnginePlugin::JavaScriptPromptCallback callback)
 479 {
 480   mPlugin->RegisterJavaScriptPromptCallback(callback);
 481 }
 482
 483 void WebEngine::JavaScriptPromptReply(const std::string& result)
 484 {
 485   mPlugin->JavaScriptPromptReply(result);
 486 }
 487
 488 std::unique_ptr<Dali::WebEngineHitTest> WebEngine::CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
 489 {
 490   return mPlugin->CreateHitTest(x, y, mode);
 491 }
 492
 493 bool WebEngine::CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
 494 {
 495   return mPlugin->CreateHitTestAsynchronously(x, y, mode, callback);
 496 }
 497
 498 bool WebEngine::CanGoForward()
 499 {
 500   return mPlugin->CanGoForward();
 501 }
 502
 503 void WebEngine::GoForward()
 504 {
 505   mPlugin->GoForward();
 506 }
 507
 508 bool WebEngine::CanGoBack()
 509 {
 510   return mPlugin->CanGoBack();
 511 }
 512
 513 void WebEngine::GoBack()
 514 {
 515   mPlugin->GoBack();
 516 }
 517
 518 void WebEngine::EvaluateJavaScript(const std::string& script, Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback resultHandler)
 519 {
 520   mPlugin->EvaluateJavaScript(script, resultHandler);
 521 }
 522
 523 void WebEngine::AddJavaScriptMessageHandler(const std::string& exposedObjectName, Dali::WebEnginePlugin::JavaScriptMessageHandlerCallback handler)
 524 {
 525   mPlugin->AddJavaScriptMessageHandler(exposedObjectName, handler);
 526 }
 527
 528 void WebEngine::ClearAllTilesResources()
 529 {
 530   mPlugin->ClearAllTilesResources();
 531 }
 532
 533 void WebEngine::ClearHistory()
 534 {
 535   mPlugin->ClearHistory();
 536 }
 537
 538 void WebEngine::SetSize(uint32_t width, uint32_t height)
 539 {
 540   mPlugin->SetSize(width, height);
 541 }
 542
 543 void WebEngine::EnableMouseEvents(bool enabled)
 544 {
 545   mPlugin->EnableMouseEvents(enabled);
 546 }
 547
 548 void WebEngine::EnableKeyEvents(bool enabled)
 549 {
 550   mPlugin->EnableKeyEvents(enabled);
 551 }
 552
 553 bool WebEngine::SendTouchEvent(const Dali::TouchEvent& touch)
 554 {
 555   return mPlugin->SendTouchEvent(touch);
 556 }
 557
 558 bool WebEngine::SendKeyEvent(const Dali::KeyEvent& event)
 559 {
 560   return mPlugin->SendKeyEvent(event);
 561 }
 562
 563 void WebEngine::SetFocus(bool focused)
 564 {
 565   mPlugin->SetFocus(focused);
 566 }
 567
 568 void WebEngine::SetDocumentBackgroundColor(Dali::Vector4 color)
 569 {
 570   mPlugin->SetDocumentBackgroundColor(color);
 571 }
 572
 573 void WebEngine::ClearTilesWhenHidden(bool cleared)
 574 {
 575   mPlugin->ClearTilesWhenHidden(cleared);
 576 }
 577
 578 void WebEngine::SetTileCoverAreaMultiplier(float multiplier)
 579 {
 580   mPlugin->SetTileCoverAreaMultiplier(multiplier);
 581 }
 582
 583 void WebEngine::EnableCursorByClient(bool enabled)
 584 {
 585   mPlugin->EnableCursorByClient(enabled);
 586 }
 587
 588 std::string WebEngine::GetSelectedText() const
 589 {
 590   return mPlugin->GetSelectedText();
 591 }
 592
 593 void WebEngine::SetPageZoomFactor(float zoomFactor)
 594 {
 595   mPlugin->SetPageZoomFactor(zoomFactor);
 596 }
 597
 598 float WebEngine::GetPageZoomFactor() const
 599 {
 600   return mPlugin->GetPageZoomFactor();
 601 }
 602
 603 void WebEngine::SetTextZoomFactor(float zoomFactor)
 604 {
 605   mPlugin->SetTextZoomFactor(zoomFactor);
 606 }
 607
 608 float WebEngine::GetTextZoomFactor() const
 609 {
 610   return mPlugin->GetTextZoomFactor();
 611 }
 612
 613 float WebEngine::GetLoadProgressPercentage() const
 614 {
 615   return mPlugin->GetLoadProgressPercentage();
 616 }
 617
 618 void WebEngine::SetScaleFactor(float scaleFactor, Dali::Vector2 point)
 619 {
 620   mPlugin->SetScaleFactor(scaleFactor, point);
 621 }
 622
 623 float WebEngine::GetScaleFactor() const
 624 {
 625   return mPlugin->GetScaleFactor();
 626 }
 627
 628 void WebEngine::ActivateAccessibility(bool activated)
 629 {
 630   mPlugin->ActivateAccessibility(activated);
 631 }
 632
 633 Accessibility::Address WebEngine::GetAccessibilityAddress()
 634 {
 635   return mPlugin->GetAccessibilityAddress();
 636 }
 637
 638 bool WebEngine::SetVisibility(bool visible)
 639 {
 640   return mPlugin->SetVisibility(visible);
 641 }
 642
 643 bool WebEngine::HighlightText(const std::string& text, Dali::WebEnginePlugin::FindOption options, uint32_t maxMatchCount)
 644 {
 645   return mPlugin->HighlightText(text, options, maxMatchCount);
 646 }
 647
 648 void WebEngine::AddDynamicCertificatePath(const std::string& host, const std::string& certPath)
 649 {
 650   mPlugin->AddDynamicCertificatePath(host, certPath);
 651 }
 652
 653 Dali::PixelData WebEngine::GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
 654 {
 655   return mPlugin->GetScreenshot(viewArea, scaleFactor);
 656 }
 657
 658 bool WebEngine::GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
 659 {
 660   return mPlugin->GetScreenshotAsynchronously(viewArea, scaleFactor, callback);
 661 }
 662
 663 bool WebEngine::CheckVideoPlayingAsynchronously(Dali::WebEnginePlugin::VideoPlayingCallback callback)
 664 {
 665   return mPlugin->CheckVideoPlayingAsynchronously(callback);
 666 }
 667
 668 void WebEngine::RegisterGeolocationPermissionCallback(Dali::WebEnginePlugin::GeolocationPermissionCallback callback)
 669 {
 670   mPlugin->RegisterGeolocationPermissionCallback(callback);
 671 }
 672
 673 void WebEngine::UpdateDisplayArea(Dali::Rect<int32_t> displayArea)
 674 {
 675   mPlugin->UpdateDisplayArea(displayArea);
 676 }
 677
 678 void WebEngine::EnableVideoHole(bool enabled)
 679 {
 680   mPlugin->EnableVideoHole(enabled);
 681 }
 682
 683 bool WebEngine::SendHoverEvent(const Dali::HoverEvent& event)
 684 {
 685   return mPlugin->SendHoverEvent(event);
 686 }
 687
 688 bool WebEngine::SendWheelEvent(const Dali::WheelEvent& event)
 689 {
 690   return mPlugin->SendWheelEvent(event);
 691 }
 692
 693 void WebEngine::RegisterFrameRenderedCallback(Dali::WebEnginePlugin::WebEngineFrameRenderedCallback callback)
 694 {
 695   mPlugin->RegisterFrameRenderedCallback(callback);
 696 }
 697
 698 void WebEngine::RegisterPageLoadStartedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
 699 {
 700   mPlugin->RegisterPageLoadStartedCallback(callback);
 701 }
 702
 703 void WebEngine::RegisterPageLoadInProgressCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
 704 {
 705   mPlugin->RegisterPageLoadInProgressCallback(callback);
 706 }
 707
 708 void WebEngine::RegisterPageLoadFinishedCallback(Dali::WebEnginePlugin::WebEnginePageLoadCallback callback)
 709 {
 710   mPlugin->RegisterPageLoadFinishedCallback(callback);
 711 }
 712
 713 void WebEngine::RegisterPageLoadErrorCallback(Dali::WebEnginePlugin::WebEnginePageLoadErrorCallback callback)
 714 {
 715   mPlugin->RegisterPageLoadErrorCallback(callback);
 716 }
 717
 718 void WebEngine::RegisterScrollEdgeReachedCallback(Dali::WebEnginePlugin::WebEngineScrollEdgeReachedCallback callback)
 719 {
 720   mPlugin->RegisterScrollEdgeReachedCallback(callback);
 721 }
 722
 723 void WebEngine::RegisterUrlChangedCallback(Dali::WebEnginePlugin::WebEngineUrlChangedCallback callback)
 724 {
 725   mPlugin->RegisterUrlChangedCallback(callback);
 726 }
 727
 728 void WebEngine::RegisterFormRepostDecidedCallback(Dali::WebEnginePlugin::WebEngineFormRepostDecidedCallback callback)
 729 {
 730   mPlugin->RegisterFormRepostDecidedCallback(callback);
 731 }
 732
 733 void WebEngine::RegisterConsoleMessageReceivedCallback(Dali::WebEnginePlugin::WebEngineConsoleMessageReceivedCallback callback)
 734 {
 735   mPlugin->RegisterConsoleMessageReceivedCallback(callback);
 736 }
 737
 738 void WebEngine::RegisterResponsePolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineResponsePolicyDecidedCallback callback)
 739 {
 740   mPlugin->RegisterResponsePolicyDecidedCallback(callback);
 741 }
 742
 743 void WebEngine::RegisterNavigationPolicyDecidedCallback(Dali::WebEnginePlugin::WebEngineNavigationPolicyDecidedCallback callback)
 744 {
 745   mPlugin->RegisterNavigationPolicyDecidedCallback(callback);
 746 }
 747
 748 void WebEngine::RegisterNewWindowCreatedCallback(Dali::WebEnginePlugin::WebEngineNewWindowCreatedCallback callback)
 749 {
 750   mPlugin->RegisterNewWindowCreatedCallback(callback);
 751 }
 752
 753 void WebEngine::RegisterCertificateConfirmedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
 754 {
 755   mPlugin->RegisterCertificateConfirmedCallback(callback);
 756 }
 757
 758 void WebEngine::RegisterSslCertificateChangedCallback(Dali::WebEnginePlugin::WebEngineCertificateCallback callback)
 759 {
 760   mPlugin->RegisterSslCertificateChangedCallback(callback);
 761 }
 762
 763 void WebEngine::RegisterHttpAuthHandlerCallback(Dali::WebEnginePlugin::WebEngineHttpAuthHandlerCallback callback)
 764 {
 765   mPlugin->RegisterHttpAuthHandlerCallback(callback);
 766 }
 767
 768 void WebEngine::RegisterContextMenuShownCallback(Dali::WebEnginePlugin::WebEngineContextMenuShownCallback callback)
 769 {
 770   mPlugin->RegisterContextMenuShownCallback(callback);
 771 }
 772
 773 void WebEngine::RegisterContextMenuHiddenCallback(Dali::WebEnginePlugin::WebEngineContextMenuHiddenCallback callback)
 774 {
 775   mPlugin->RegisterContextMenuHiddenCallback(callback);
 776 }
 777
 778 void WebEngine::GetPlainTextAsynchronously(Dali::WebEnginePlugin::PlainTextReceivedCallback callback)
 779 {
 780   mPlugin->GetPlainTextAsynchronously(callback);
 781 }
 782
 783 } // namespace Adaptor
 784 } // namespace Internal
 785 } // namespace Dali