dali-extension/web-engine-chromium/tizen-web-engine-chromium.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 "tizen-web-engine-chromium.h"
  19
  20 #include "tizen-web-engine-back-forward-list.h"
  21 #include "tizen-web-engine-certificate.h"
  22 #include "tizen-web-engine-console-message.h"
  23 #include "tizen-web-engine-context.h"
  24 #include "tizen-web-engine-context-menu.h"
  25 #include "tizen-web-engine-context-menu-item.h"
  26 #include "tizen-web-engine-cookie-manager.h"
  27 #include "tizen-web-engine-form-repost-decision.h"
  28 #include "tizen-web-engine-hit-test.h"
  29 #include "tizen-web-engine-http-auth-handler.h"
  30 #include "tizen-web-engine-load-error.h"
  31 #include "tizen-web-engine-policy-decision.h"
  32 #include "tizen-web-engine-request-interceptor.h"
  33 #include "tizen-web-engine-settings.h"
  34
  35 #include <Ecore_Evas.h>
  36 #include <Ecore_Wl2.h>
  37 #include <Elementary.h>
  38 #include <Evas.h>
  39
  40 #include <dali/devel-api/common/stage.h>
  41 #include <dali/integration-api/adaptor-framework/adaptor.h>
  42 #include <dali/integration-api/debug.h>
  43 #include <dali/public-api/images/pixel-data.h>
  44
  45 #include <ewk_main_internal.h>
  46 #include <ewk_settings_product.h>
  47 #include <ewk_view_internal.h>
  48 #include <ewk_view_product.h>
  49
  50 using namespace Dali;
  51
  52 namespace Dali
  53 {
  54 namespace Plugin
  55 {
  56
  57 namespace
  58 {
  59 // const
  60 const std::string EMPTY_STRING;
  61 } // namespace
  62
  63 class WebViewContainerClientPair
  64 {
  65 public:
  66   WebViewContainerClientPair(WebViewContainerClient* client, Evas_Object* webView)
  67   {
  68     mClient = client;
  69     mWebView = webView;
  70   }
  71
  72   WebViewContainerClient* mClient;
  73   Evas_Object*            mWebView;
  74 };
  75
  76 class WebEngineManager
  77 {
  78   //
  79   // A class for managing multiple WebViews
  80   //
  81 public:
  82   static WebEngineManager& Get()
  83   {
  84     static WebEngineManager instance;
  85     return instance;
  86   }
  87
  88   WebEngineManager(WebEngineManager const&) = delete;
  89
  90   void operator=(WebEngineManager const&) = delete;
  91
  92   Ecore_Evas* GetWindow()
  93   {
  94     return mWindow;
  95   }
  96
  97   void AddContainerClient(WebViewContainerClient* client, Evas_Object* webView)
  98   {
  99     mContainerClients.push_back(WebViewContainerClientPair(client, webView));
 100   }
 101
 102   void RemoveContainerClient(Evas_Object* webView)
 103   {
 104     for (auto it = mContainerClients.begin(); it != mContainerClients.end();)
 105     {
 106       if ((*it).mWebView == webView)
 107       {
 108         mContainerClients.erase(it);
 109         break;
 110       }
 111       else
 112       {
 113         ++it;
 114       }
 115     }
 116   }
 117
 118   Evas_Object* FindWebView(WebViewContainerClient* client)
 119   {
 120     for (auto& webViewClient : mContainerClients)
 121     {
 122       if (webViewClient.mClient == client)
 123       {
 124         return webViewClient.mWebView;
 125       }
 126     }
 127     return 0;
 128   }
 129
 130   WebViewContainerClient* FindContainerClient(Evas_Object* o)
 131   {
 132     for (auto& webViewClient : mContainerClients)
 133     {
 134       if (webViewClient.mWebView == o)
 135       {
 136         return webViewClient.mClient;
 137       }
 138     }
 139     return 0;
 140   }
 141
 142 private:
 143   WebEngineManager()
 144   {
 145     elm_init(0, 0);
 146     ewk_init();
 147     mWindow = ecore_evas_new("wayland_egl", 0, 0, 1, 1, 0);
 148   }
 149
 150   Ecore_Evas* mWindow;
 151   std::vector<WebViewContainerClientPair> mContainerClients;
 152 };
 153
 154 class WebViewContainerForDali
 155 {
 156 public:
 157   WebViewContainerForDali(WebViewContainerClient& client, uint32_t width, uint32_t height)
 158     : mWebView(nullptr)
 159     , mClient(client)
 160     , mWidth(width)
 161     , mHeight(height)
 162     , mUserAgent()
 163     , mWebEngineSettings(0)
 164     , mWebEngineContext(0)
 165     , mWebEngineCookieManager(0)
 166     , mWebEngineBackForwardList(0)
 167   {
 168     InitWebView(0, 0);
 169
 170     WebEngineManager::Get().AddContainerClient(&mClient, mWebView);
 171   }
 172
 173   WebViewContainerForDali(WebViewContainerClient& client, uint32_t width, uint32_t height, uint32_t argc, char** argv)
 174     : mWebView(nullptr)
 175     , mClient(client)
 176     , mWidth(width)
 177     , mHeight(height)
 178     , mUserAgent()
 179     , mWebEngineSettings(0)
 180     , mWebEngineContext(0)
 181     , mWebEngineCookieManager(0)
 182     , mWebEngineBackForwardList(0)
 183   {
 184     InitWebView(argc, argv);
 185
 186     WebEngineManager::Get().AddContainerClient(&mClient, mWebView);
 187   }
 188
 189   ~WebViewContainerForDali()
 190   {
 191     WebEngineManager::Get().RemoveContainerClient(mWebView);
 192
 193     evas_object_del(mWebView);
 194   }
 195
 196   void InitWebView(uint32_t argc, char** argv)
 197   {
 198     if (argc > 0)
 199     {
 200       ewk_set_arguments(argc, argv);
 201     }
 202
 203     Ecore_Wl2_Window* win = AnyCast<Ecore_Wl2_Window*>(Adaptor::Get().GetNativeWindowHandle());
 204     Ewk_Context* context = ewk_context_default_get();
 205     ewk_context_max_refresh_rate_set(context, 60);
 206     mWebView = ewk_view_add(ecore_evas_get(WebEngineManager::Get().GetWindow()));
 207     ewk_view_offscreen_rendering_enabled_set(mWebView, true);
 208     ecore_wl2_window_alpha_set(win, false);
 209     ewk_view_ime_window_set(mWebView, win);
 210     ewk_view_set_support_video_hole(mWebView, win, EINA_TRUE, EINA_FALSE);
 211
 212     Ewk_Settings* settings = ewk_view_settings_get(mWebView);
 213     mWebEngineSettings = TizenWebEngineSettings(settings);
 214
 215     context = ewk_view_context_get(mWebView);
 216 #if 0
 217     ewk_context_intercept_request_callback_set(context, &WebViewContainerForDali::OnInterceptRequest, &mClient);
 218 #endif
 219     mWebEngineContext = TizenWebEngineContext(context);
 220
 221     Ewk_Cookie_Manager* manager = ewk_context_cookie_manager_get(context);
 222     mWebEngineCookieManager = TizenWebEngineCookieManager(manager);
 223
 224     Ewk_Back_Forward_List* backForwardList = ewk_view_back_forward_list_get(mWebView);
 225     mWebEngineBackForwardList = TizenWebEngineBackForwardList(backForwardList);
 226
 227     ewk_settings_viewport_meta_tag_set(settings, false);
 228
 229     evas_object_smart_callback_add(mWebView, "offscreen,frame,rendered",
 230                                    &WebViewContainerForDali::OnFrameRendered,
 231                                    &mClient);
 232     evas_object_smart_callback_add(mWebView, "load,started",
 233                                    &WebViewContainerForDali::OnLoadStarted,
 234                                    &mClient);
 235     evas_object_smart_callback_add(mWebView, "load,progress",
 236                                    &WebViewContainerForDali::OnLoadInProgress,
 237                                    &mClient);
 238     evas_object_smart_callback_add(mWebView, "load,finished",
 239                                    &WebViewContainerForDali::OnLoadFinished,
 240                                    &mClient);
 241     evas_object_smart_callback_add(mWebView, "load,error",
 242                                    &WebViewContainerForDali::OnLoadError,
 243                                    &mClient);
 244     evas_object_smart_callback_add(mWebView, "url,changed",
 245                                    &WebViewContainerForDali::OnUrlChanged,
 246                                    &mClient);
 247     evas_object_smart_callback_add(mWebView, "console,message",
 248                                    &WebViewContainerForDali::OnConsoleMessage,
 249                                    &mClient);
 250     evas_object_smart_callback_add(mWebView, "edge,left",
 251                                    &WebViewContainerForDali::OnEdgeLeft,
 252                                    &mClient);
 253     evas_object_smart_callback_add(mWebView, "edge,right",
 254                                    &WebViewContainerForDali::OnEdgeRight,
 255                                    &mClient);
 256     evas_object_smart_callback_add(mWebView, "edge,top",
 257                                    &WebViewContainerForDali::OnEdgeTop,
 258                                    &mClient);
 259     evas_object_smart_callback_add(mWebView, "edge,bottom",
 260                                    &WebViewContainerForDali::OnEdgeBottom,
 261                                    &mClient);
 262     evas_object_smart_callback_add(mWebView, "form,repost,warning,show",
 263                                    &WebViewContainerForDali::OnFormRepostDecisionRequest,
 264                                    &mClient);
 265     evas_object_smart_callback_add(mWebView, "policy,response,decide",
 266                                    &WebViewContainerForDali::OnResponsePolicyDecided,
 267                                    &mClient);
 268     evas_object_smart_callback_add(mWebView, "request,certificate,confirm",
 269                                    &WebViewContainerForDali::OnCertificateConfirmRequest,
 270                                    &mClient);
 271     evas_object_smart_callback_add(mWebView, "ssl,certificate,changed",
 272                                    &WebViewContainerForDali::OnSslCertificateChanged,
 273                                    &mClient);
 274     evas_object_smart_callback_add(mWebView, "contextmenu,customize",
 275                                    &WebViewContainerForDali::OnContextMenuCustomized,
 276                                    &mClient);
 277     evas_object_smart_callback_add(mWebView, "contextmenu,selected",
 278                                    &WebViewContainerForDali::OnContextMenuItemSelected,
 279                                    &mClient);
 280
 281     ewk_view_authentication_callback_set(mWebView, &WebViewContainerForDali::OnAuthenticationChallenge, &mClient);
 282
 283     evas_object_resize(mWebView, mWidth, mHeight);
 284     evas_object_show(mWebView);
 285   }
 286
 287   void LoadUrl(const std::string& url)
 288   {
 289     ewk_view_url_set(mWebView, url.c_str());
 290   }
 291
 292   void LoadHtml(const std::string& html)
 293   {
 294     ewk_view_html_string_load(mWebView, html.c_str(), 0, 0);
 295   }
 296
 297   std::string GetUrl()
 298   {
 299     return std::string(ewk_view_url_get(mWebView));
 300   }
 301
 302   bool LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri,
 303                                           const std::string& unreachableUrl)
 304   {
 305     return ewk_view_html_string_override_current_entry_load(mWebView, html.c_str(), basicUri.c_str(), unreachableUrl.c_str());
 306   }
 307
 308   bool LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType,
 309                     const std::string& encoding, const std::string& baseUri)
 310   {
 311     return ewk_view_contents_set(mWebView, contents.c_str(), contentSize, (char *)mimeType.c_str(),
 312                                  (char *)encoding.c_str(), (char *)baseUri.c_str());
 313   }
 314
 315   std::string GetTitle()
 316   {
 317     return std::string(ewk_view_title_get(mWebView));
 318   }
 319
 320   Dali::PixelData GetFavicon()
 321   {
 322     Evas_Object* iconObject = ewk_view_favicon_get(mWebView);
 323     if (!iconObject)
 324     {
 325       return Dali::PixelData();
 326     }
 327     return ConvertImageColorSpace(iconObject);
 328   }
 329
 330   void Reload()
 331   {
 332     ewk_view_reload(mWebView);
 333   }
 334
 335   void StopLoading()
 336   {
 337     ewk_view_stop(mWebView);
 338   }
 339
 340   bool ReloadWithoutCache()
 341   {
 342     return ewk_view_reload_bypass_cache(mWebView);
 343   }
 344
 345   void Suspend()
 346   {
 347     ewk_view_suspend(mWebView);
 348   }
 349
 350   void Resume()
 351   {
 352     ewk_view_resume(mWebView);
 353   }
 354
 355   void SuspendNetworkLoading()
 356   {
 357     ewk_view_suspend_network_loading(mWebView);
 358   }
 359
 360   void ResumeNetworkLoading()
 361   {
 362     ewk_view_resume_network_loading(mWebView);
 363   }
 364
 365   bool AddCustomHeader(const std::string& name, const std::string& value)
 366   {
 367     return ewk_view_custom_header_add(mWebView, name.c_str(), value.c_str());
 368   }
 369
 370   bool RemoveCustomHeader(const std::string& name)
 371   {
 372     return ewk_view_custom_header_remove(mWebView, name.c_str());
 373   }
 374
 375   uint32_t StartInspectorServer(uint32_t port)
 376   {
 377     return ewk_view_inspector_server_start(mWebView, port);
 378   }
 379
 380   bool StopInspectorServer()
 381   {
 382     return ewk_view_inspector_server_stop(mWebView);
 383   }
 384
 385   void ScrollBy(int32_t deltaX, int32_t deltaY)
 386   {
 387     ewk_view_scroll_by(mWebView, deltaX, deltaY);
 388   }
 389
 390   bool ScrollEdgeBy(int32_t deltaX, int32_t deltaY)
 391   {
 392     return ewk_view_edge_scroll_by(mWebView, deltaX, deltaY);
 393   }
 394
 395   void SetScrollPosition(int32_t x, int32_t y)
 396   {
 397     ewk_view_scroll_set(mWebView, x, y);
 398   }
 399
 400   Dali::Vector2 GetScrollPosition() const
 401   {
 402     int x = 0, y = 0;
 403     ewk_view_scroll_pos_get(mWebView, &x, &y);
 404     return Dali::Vector2(x, y);
 405   }
 406
 407   Dali::Vector2 GetScrollSize() const
 408   {
 409     int width = 0, height = 0;
 410     ewk_view_scroll_size_get(mWebView, &width, &height);
 411     return Dali::Vector2(width, height);
 412   }
 413
 414   Dali::Vector2 GetContentSize() const
 415   {
 416     int width = 0, height = 0;
 417     ewk_view_contents_size_get(mWebView, &width, &height);
 418     return Dali::Vector2(width, height);
 419   }
 420
 421   void GoBack()
 422   {
 423     ewk_view_back(mWebView);
 424   }
 425
 426   void GoForward()
 427   {
 428     ewk_view_forward(mWebView);
 429   }
 430
 431   bool CanGoBack()
 432   {
 433     return ewk_view_back_possible(mWebView);
 434   }
 435
 436   bool CanGoForward()
 437   {
 438     return ewk_view_forward_possible(mWebView);
 439   }
 440
 441   void EvaluateJavaScript(size_t key, const std::string& script)
 442   {
 443     ewk_view_script_execute(mWebView, script.c_str(), OnEvaluateJavaScript, (void*)key);
 444   }
 445
 446   void AddJavaScriptMessageHandler(const std::string& exposedObjectName)
 447   {
 448     // |jsFunctionName| is fixed as "postMessage" so we don't use this.
 449     ewk_view_javascript_message_handler_add(mWebView, &WebViewContainerForDali::OnJavaScriptMessage, exposedObjectName.c_str());
 450   }
 451
 452   void RegisterJavaScriptAlertCallback()
 453   {
 454     ewk_view_javascript_alert_callback_set(mWebView, &WebViewContainerForDali::OnJavaScriptAlert, 0);
 455   }
 456
 457   void JavaScriptAlertReply()
 458   {
 459     ewk_view_javascript_alert_reply(mWebView);
 460   }
 461
 462   void RegisterJavaScriptConfirmCallback()
 463   {
 464     ewk_view_javascript_confirm_callback_set(mWebView, &WebViewContainerForDali::OnJavaScriptConfirm, 0);
 465   }
 466
 467   void JavaScriptConfirmReply(bool confirmed)
 468   {
 469     ewk_view_javascript_confirm_reply(mWebView, confirmed);
 470   }
 471
 472   void RegisterJavaScriptPromptCallback()
 473   {
 474     ewk_view_javascript_prompt_callback_set(mWebView, &WebViewContainerForDali::OnJavaScriptPrompt, 0);
 475   }
 476
 477   void JavaScriptPromptReply(const std::string& result)
 478   {
 479     ewk_view_javascript_prompt_reply(mWebView, result.c_str());
 480   }
 481
 482   void ClearHistory()
 483   {
 484     ewk_view_back_forward_list_clear(mWebView);
 485   }
 486
 487   void ClearAllTilesResources()
 488   {
 489     ewk_view_clear_all_tiles_resources(mWebView);
 490   }
 491
 492   const std::string& GetUserAgent()
 493   {
 494     mUserAgent = std::string(ewk_view_user_agent_get(mWebView));
 495     return mUserAgent;
 496   }
 497
 498   void SetUserAgent(const std::string& userAgent)
 499   {
 500     ewk_view_user_agent_set(mWebView, userAgent.c_str());
 501   }
 502
 503   Dali::WebEngineSettings& GetSettings()
 504   {
 505     return mWebEngineSettings;
 506   }
 507
 508   Dali::WebEngineContext& GetContext()
 509   {
 510     return mWebEngineContext;
 511   }
 512
 513   Dali::WebEngineCookieManager& GetCookieManager()
 514   {
 515     return mWebEngineCookieManager;
 516   }
 517
 518   Dali::WebEngineBackForwardList& GetBackForwardList()
 519   {
 520     return mWebEngineBackForwardList;
 521   }
 522
 523   std::unique_ptr<Dali::WebEngineHitTest> CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
 524   {
 525     // sync...
 526     Evas* evas = ecore_evas_get(WebEngineManager::Get().GetWindow());
 527     Ewk_Hit_Test* hitTest = ewk_view_hit_test_new(mWebView, x, y, (int)mode);
 528     std::unique_ptr<Dali::WebEngineHitTest> webHitTest(new TizenWebEngineHitTest(hitTest, evas, true));
 529     return webHitTest;
 530   }
 531
 532   bool CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
 533   {
 534     // async...
 535     return ewk_view_hit_test_request(mWebView, x, y, (int)mode,
 536                                      &WebViewContainerForDali::OnHitTestCreated,
 537                                      &mClient);
 538   }
 539
 540   void SetSize(uint32_t width, uint32_t height)
 541   {
 542     mWidth = width;
 543     mHeight = height;
 544     evas_object_resize(mWebView, mWidth, mHeight);
 545   }
 546
 547   void EnableMouseEvents(bool enabled)
 548   {
 549     ewk_view_mouse_events_enabled_set(mWebView, enabled);
 550   }
 551
 552   void EnableKeyEvents(bool enabled)
 553   {
 554     ewk_view_key_events_enabled_set(mWebView, enabled);
 555   }
 556
 557   void SetDocumentBackgroundColor(Dali::Vector4 color)
 558   {
 559     ewk_view_bg_color_set(mWebView, color.r * 255, color.g * 255, color.b * 255, color.a * 255);
 560   }
 561
 562   void ClearTilesWhenHidden(bool cleared)
 563   {
 564     ewk_view_clear_tiles_on_hide_enabled_set(mWebView, cleared);
 565   }
 566
 567   void SetTileCoverAreaMultiplier(float multiplier)
 568   {
 569     ewk_view_tile_cover_area_multiplier_set(mWebView, multiplier);
 570   }
 571
 572   void EnableCursorByClient(bool enabled)
 573   {
 574     ewk_view_set_cursor_by_client(mWebView, enabled);
 575   }
 576
 577   std::string GetSelectedText() const
 578   {
 579     return ewk_view_text_selection_text_get(mWebView);
 580   }
 581
 582   bool SendTouchEvent(const TouchEvent& touch)
 583   {
 584     Ewk_Touch_Event_Type type = EWK_TOUCH_START;
 585     Evas_Touch_Point_State state = EVAS_TOUCH_POINT_DOWN;
 586     switch (touch.GetState(0))
 587     {
 588       case PointState::DOWN:
 589       {
 590         type = EWK_TOUCH_START;
 591         state = EVAS_TOUCH_POINT_DOWN;
 592         break;
 593       }
 594       case PointState::UP:
 595       {
 596         type = EWK_TOUCH_END;
 597         state = EVAS_TOUCH_POINT_UP;
 598         break;
 599       }
 600       case PointState::MOTION:
 601       {
 602         type = EWK_TOUCH_MOVE;
 603         state = EVAS_TOUCH_POINT_MOVE;
 604         break;
 605       }
 606       case PointState::INTERRUPTED:
 607       {
 608         type = EWK_TOUCH_CANCEL;
 609         state = EVAS_TOUCH_POINT_CANCEL;
 610         break;
 611       }
 612       default:
 613       {
 614         break;
 615       }
 616     }
 617
 618     Eina_List* pointList = 0;
 619     Ewk_Touch_Point* point = new Ewk_Touch_Point;
 620     point->id = 0;
 621     point->x = touch.GetScreenPosition(0).x;
 622     point->y = touch.GetScreenPosition(0).y;
 623     point->state = state;
 624     pointList = eina_list_append(pointList, point);
 625
 626     ewk_view_feed_touch_event(mWebView, type, pointList, 0);
 627     eina_list_free(pointList);
 628     return false;
 629   }
 630
 631   bool SendKeyEvent(const Dali::KeyEvent& keyEvent)
 632   {
 633     void* evasKeyEvent = 0;
 634     if (keyEvent.GetState() == Dali::KeyEvent::DOWN)
 635     {
 636       Evas_Event_Key_Down downEvent;
 637       memset(&downEvent, 0, sizeof(Evas_Event_Key_Down));
 638       downEvent.key = keyEvent.GetKeyName().c_str();
 639       downEvent.string = keyEvent.GetKeyString().c_str();
 640       evasKeyEvent = static_cast<void*>(&downEvent);
 641       ewk_view_send_key_event(mWebView, evasKeyEvent, true);
 642     }
 643     else
 644     {
 645       Evas_Event_Key_Up upEvent;
 646       memset(&upEvent, 0, sizeof(Evas_Event_Key_Up));
 647       upEvent.key = keyEvent.GetKeyName().c_str();
 648       upEvent.string = keyEvent.GetKeyString().c_str();
 649       evasKeyEvent = static_cast<void*>(&upEvent);
 650       ewk_view_send_key_event(mWebView, evasKeyEvent, false);
 651     }
 652     return false;
 653   }
 654
 655   void SetFocus(bool focused)
 656   {
 657     ecore_evas_focus_set(WebEngineManager::Get().GetWindow(), focused);
 658     ewk_view_focus_set(mWebView, focused);
 659   }
 660
 661   bool SetPageZoomFactor(float zoomFactor)
 662   {
 663     return ewk_view_page_zoom_set(mWebView, zoomFactor);
 664   }
 665
 666   float GetPageZoomFactor() const
 667   {
 668     return ewk_view_page_zoom_get(mWebView);
 669   }
 670
 671   bool SetTextZoomFactor(float zoomFactor)
 672   {
 673     return ewk_view_text_zoom_set(mWebView, zoomFactor);
 674   }
 675
 676   float GetTextZoomFactor() const
 677   {
 678     return ewk_view_text_zoom_get(mWebView);
 679   }
 680
 681   float GetLoadProgressPercentage() const
 682   {
 683     return ewk_view_load_progress_get(mWebView);
 684   }
 685
 686   bool SetScaleFactor(float scaleFactor, Dali::Vector2 point)
 687   {
 688     return ewk_view_scale_set(mWebView, scaleFactor, point.x, point.y);
 689   }
 690
 691   float GetScaleFactor() const
 692   {
 693     return ewk_view_scale_get(mWebView);
 694   }
 695
 696   void ActivateAccessibility(bool activated)
 697   {
 698     ewk_view_atk_deactivation_by_app(mWebView, !activated);
 699   }
 700
 701   bool SetVisibility(bool visible)
 702   {
 703     return ewk_view_visibility_set(mWebView, visible);
 704   }
 705
 706   bool HighlightText(const std::string& text, Dali::WebEnginePlugin::FindOption options, uint32_t maxMatchCount)
 707   {
 708     return ewk_view_text_find(mWebView, text.c_str(), (Ewk_Find_Options)options, maxMatchCount);
 709   }
 710
 711   void AddDynamicCertificatePath(const std::string& host, const std::string& certPath)
 712   {
 713     ewk_view_add_dynamic_certificate_path(mWebView, host.c_str(), certPath.c_str());
 714   }
 715
 716   Dali::PixelData GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
 717   {
 718     Eina_Rectangle rect;
 719     EINA_RECTANGLE_SET(&rect, viewArea.x, viewArea.y, viewArea.width, viewArea.height);
 720     Evas *evas = ecore_evas_get(WebEngineManager::Get().GetWindow());
 721     Evas_Object *snapShotObject = ewk_view_screenshot_contents_get(mWebView, rect, scaleFactor, evas);
 722     if (!snapShotObject)
 723     {
 724       return Dali::PixelData();
 725     }
 726     return ConvertImageColorSpace(snapShotObject);
 727   }
 728
 729   bool GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor)
 730   {
 731     Eina_Rectangle rect;
 732     EINA_RECTANGLE_SET(&rect, viewArea.x, viewArea.y, viewArea.width, viewArea.height);
 733     Evas *evas = ecore_evas_get(WebEngineManager::Get().GetWindow());
 734     return ewk_view_screenshot_contents_get_async(mWebView, rect, scaleFactor, evas, &WebViewContainerForDali::OnScreenshotCaptured, &mClient);
 735   }
 736
 737   bool CheckVideoPlayingAsynchronously()
 738   {
 739     return ewk_view_is_video_playing(mWebView, &WebViewContainerForDali::OnVideoPlaying, &mClient);
 740   }
 741
 742   void RegisterGeolocationPermissionCallback()
 743   {
 744     ewk_view_geolocation_permission_callback_set(mWebView, &WebViewContainerForDali::OnGeolocationPermission, &mClient);
 745   }
 746
 747   void UpdateDisplayArea(Dali::Rect<int32_t> displayArea)
 748   {
 749     evas_object_move(mWebView, displayArea.x, displayArea.y);
 750     SetSize(displayArea.width, displayArea.height);
 751     evas_object_geometry_set(mWebView, displayArea.x, displayArea.y, displayArea.width, displayArea.height);
 752   }
 753
 754   void EnableVideoHole(bool enabled)
 755   {
 756     Ecore_Wl2_Window* win = AnyCast<Ecore_Wl2_Window*>(Adaptor::Get().GetNativeWindowHandle());
 757     ewk_view_set_support_video_hole(mWebView, win, enabled, EINA_FALSE);
 758     ecore_wl2_window_alpha_set(win, !enabled);
 759   }
 760
 761   bool SendHoverEvent(const HoverEvent& hover)
 762   {
 763 #if defined(OS_TIZEN_TV)
 764     //TODO...left/right/middle of mouse could not be acquired now.
 765     Ewk_Mouse_Button_Type type = EWK_Mouse_Button_Left;
 766     switch ( hover.GetState( 0 ) )
 767     {
 768       case PointState::DOWN:
 769       {
 770         float x = hover.GetScreenPosition( 0 ).x;
 771         float y = hover.GetScreenPosition( 0 ).y;
 772         ewk_view_feed_mouse_down( mWebView, type, x, y );
 773         break;
 774       }
 775       case PointState::UP:
 776       {
 777         float x = hover.GetScreenPosition( 0 ).x;
 778         float y = hover.GetScreenPosition( 0 ).y;
 779         ewk_view_feed_mouse_up( mWebView, type, x, y );
 780         break;
 781       }
 782       case PointState::MOTION:
 783       {
 784         float x = hover.GetScreenPosition( 0 ).x;
 785         float y = hover.GetScreenPosition( 0 ).y;
 786         ewk_view_feed_mouse_move( mWebView, x, y );
 787         break;
 788       }
 789       default:
 790       {
 791         break;
 792       }
 793     }
 794 #endif
 795     return false;
 796   }
 797
 798   bool SendWheelEvent(const WheelEvent& wheel)
 799   {
 800 #if defined(OS_TIZEN_TV)
 801     Eina_Bool direction = wheel.GetDirection() ? true : false;
 802     int step = wheel.GetDelta();
 803     float x = wheel.GetPoint().x;
 804     float y = wheel.GetPoint().y;
 805
 806     ewk_view_feed_mouse_wheel( mWebView, direction, step, x, y );
 807 #endif
 808     return false;
 809   }
 810
 811 private:
 812   static Dali::PixelData ConvertImageColorSpace(Evas_Object *image)
 813   {
 814     int width = 0, height = 0;
 815     evas_object_image_size_get(image, &width, &height);
 816
 817     uint32_t bufferSize = width * height * 4;
 818     uint8_t *convertedBuffer = new uint8_t[bufferSize];
 819
 820     // color-space is argb8888.
 821     uint8_t *pixelBuffer = (uint8_t *)evas_object_image_data_get(image, false);
 822
 823     // convert the color-space to rgba8888.
 824     for (uint32_t i = 0; i < bufferSize; i += 4)
 825     {
 826       convertedBuffer[i] = pixelBuffer[i + 1];
 827       convertedBuffer[i + 1] = pixelBuffer[i + 2];
 828       convertedBuffer[i + 2] = pixelBuffer[i + 3];
 829       convertedBuffer[i + 3] = pixelBuffer[i];
 830     }
 831
 832     return Dali::PixelData::New(convertedBuffer, bufferSize, width, height,
 833                                 Dali::Pixel::Format::RGBA8888,
 834                                 Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
 835   }
 836
 837   static void OnFrameRendered(void* data, Evas_Object*, void* buffer)
 838   {
 839     auto client = static_cast<WebViewContainerClient*>(data);
 840     client->UpdateImage(static_cast<tbm_surface_h>(buffer));
 841   }
 842
 843   static void OnLoadStarted(void* data, Evas_Object*, void*)
 844   {
 845     auto client = static_cast<WebViewContainerClient*>(data);
 846     client->LoadStarted();
 847   }
 848
 849   static void OnLoadInProgress(void* data, Evas_Object*, void*)
 850   {
 851     auto client = static_cast<WebViewContainerClient*>(data);
 852     client->LoadInProgress();
 853   }
 854
 855   static void OnLoadFinished(void* data, Evas_Object*, void*)
 856   {
 857     auto client = static_cast<WebViewContainerClient*>(data);
 858     client->LoadFinished();
 859   }
 860
 861   static void OnLoadError(void* data, Evas_Object*, void* rawError)
 862   {
 863     auto client = static_cast<WebViewContainerClient*>(data);
 864     Ewk_Error* error = static_cast<Ewk_Error*>(rawError);
 865     std::shared_ptr<Dali::WebEngineLoadError> loadError(new TizenWebEngineLoadError(error));
 866     client->LoadError(std::move(loadError));
 867   }
 868
 869   static void OnInterceptRequest(Ewk_Context*, Ewk_Intercept_Request* request, void* data)
 870   {
 871     auto client = static_cast<WebViewContainerClient*>(data);
 872     std::shared_ptr<Dali::WebEngineRequestInterceptor> webInterceptor(new TizenWebEngineRequestInterceptor(request));
 873     client->InterceptRequest(std::move(webInterceptor));
 874   }
 875
 876   static void OnUrlChanged(void* data, Evas_Object*, void* newUrl)
 877   {
 878     auto client = static_cast<WebViewContainerClient*>(data);
 879     std::string url = static_cast<char*>(newUrl);
 880     client->UrlChanged(url);
 881   }
 882
 883   static void OnConsoleMessage(void* data, Evas_Object*, void* eventInfo)
 884   {
 885     auto client = static_cast<WebViewContainerClient*>(data);
 886     Ewk_Console_Message* message = static_cast<Ewk_Console_Message*>(eventInfo);
 887     std::shared_ptr<Dali::WebEngineConsoleMessage> webConsoleMessage(new TizenWebEngineConsoleMessage(message));
 888     client->OnConsoleMessage(std::move(webConsoleMessage));
 889   }
 890
 891   static void OnEdgeLeft(void* data, Evas_Object*, void*)
 892   {
 893     auto client = static_cast<WebViewContainerClient*>(data);
 894     client->ScrollEdgeReached(Dali::WebEnginePlugin::ScrollEdge::LEFT);
 895   }
 896
 897   static void OnEdgeRight(void* data, Evas_Object*, void*)
 898   {
 899     auto client = static_cast<WebViewContainerClient*>(data);
 900     client->ScrollEdgeReached(Dali::WebEnginePlugin::ScrollEdge::RIGHT);
 901   }
 902
 903   static void OnEdgeTop(void* data, Evas_Object*, void*)
 904   {
 905     auto client = static_cast<WebViewContainerClient*>(data);
 906     client->ScrollEdgeReached(Dali::WebEnginePlugin::ScrollEdge::TOP);
 907   }
 908
 909   static void OnEdgeBottom(void* data, Evas_Object*, void*)
 910   {
 911     auto client = static_cast<WebViewContainerClient*>(data);
 912     client->ScrollEdgeReached(Dali::WebEnginePlugin::ScrollEdge::BOTTOM);
 913   }
 914
 915   static void OnFormRepostDecisionRequest(void* data, Evas_Object*, void* eventInfo)
 916   {
 917     auto client = static_cast<WebViewContainerClient*>(data);
 918     Ewk_Form_Repost_Decision_Request* decisionRequest = static_cast<Ewk_Form_Repost_Decision_Request*>(eventInfo);
 919     std::shared_ptr<Dali::WebEngineFormRepostDecision> webDecisionRequest(new TizenWebEngineFormRepostDecision(decisionRequest));
 920     client->RequestFormRepostDecision(std::move(webDecisionRequest));
 921   }
 922
 923   static void OnScreenshotCaptured(Evas_Object* image, void* data)
 924   {
 925     auto client = static_cast<WebViewContainerClient*>(data);
 926     Dali::PixelData pixelData = ConvertImageColorSpace(image);
 927     client->ScreenshotCaptured(pixelData);
 928   }
 929
 930   static void OnVideoPlaying(Evas_Object*, Eina_Bool isPlaying, void* data)
 931   {
 932     auto client = static_cast<WebViewContainerClient*>(data);
 933     client->VideoPlaying(isPlaying);
 934   }
 935
 936   static Eina_Bool OnGeolocationPermission(Evas_Object*, Ewk_Geolocation_Permission_Request* request, void* data)
 937   {
 938     auto client = static_cast<WebViewContainerClient*>(data);
 939     const Ewk_Security_Origin* securityOrigin = ewk_geolocation_permission_request_origin_get(request);
 940     std::string host = ewk_security_origin_host_get(securityOrigin);
 941     std::string protocol = ewk_security_origin_protocol_get(securityOrigin);
 942     return client->GeolocationPermission(host, protocol);
 943   }
 944
 945   static void OnResponsePolicyDecided(void* data, Evas_Object*, void* policy)
 946   {
 947     auto client = static_cast<WebViewContainerClient*>(data);
 948     Ewk_Policy_Decision* policyDecision = static_cast<Ewk_Policy_Decision*>(policy);
 949     std::shared_ptr<Dali::WebEnginePolicyDecision> webPolicyDecision(new TizenWebEnginePolicyDecision(policyDecision));
 950     client->ResponsePolicyDecided(std::move(webPolicyDecision));
 951   }
 952
 953   static void OnCertificateConfirmRequest(void* data, Evas_Object*, void* eventInfo)
 954   {
 955     auto client = static_cast<WebViewContainerClient*>(data);
 956     Ewk_Certificate_Policy_Decision* policyDecision = static_cast<Ewk_Certificate_Policy_Decision*>(eventInfo);
 957     std::shared_ptr<Dali::WebEngineCertificate> webPolicyDecision(new TizenWebEngineCertificate(policyDecision));
 958     client->CertificateConfirm(std::move(webPolicyDecision));
 959   }
 960
 961   static void OnSslCertificateChanged(void* data, Evas_Object*, void* eventInfo)
 962   {
 963     auto client = static_cast<WebViewContainerClient*>(data);
 964     Ewk_Certificate_Info* info = static_cast<Ewk_Certificate_Info*>(eventInfo);
 965     std::shared_ptr<Dali::WebEngineCertificate> webCertiInfo(new TizenWebEngineCertificate(info));
 966     client->SslCertificateChanged(std::move(webCertiInfo));
 967   }
 968
 969   static void OnAuthenticationChallenge(Evas_Object*, Ewk_Auth_Challenge* authChallenge, void* data)
 970   {
 971     auto client = static_cast<WebViewContainerClient*>(data);
 972     std::shared_ptr<Dali::WebEngineHttpAuthHandler> authHandler(new TizenWebEngineHttpAuthHandler(authChallenge));
 973     client->AuthenticationChallenge(std::move(authHandler));
 974   }
 975
 976   static void OnContextMenuCustomized(void* data, Evas_Object*, void* eventInfo)
 977   {
 978     auto client = static_cast<WebViewContainerClient *>(data);
 979     Ewk_Context_Menu* menu = (Ewk_Context_Menu *)eventInfo;
 980     std::shared_ptr<Dali::WebEngineContextMenu> contextMenu(new TizenWebEngineContextMenu(menu));
 981     client->ContextMenuCustomized(std::move(contextMenu));
 982   }
 983
 984   static void OnContextMenuItemSelected(void* data, Evas_Object*, void* eventInfo)
 985   {
 986     auto client = static_cast<WebViewContainerClient*>(data);
 987     Ewk_Context_Menu_Item* item = (Ewk_Context_Menu_Item*)eventInfo;
 988     std::shared_ptr<Dali::WebEngineContextMenuItem> contextMenuItem(new TizenWebEngineContextMenuItem(item));
 989     client->ContextMenuItemSelected(std::move(contextMenuItem));
 990   }
 991
 992   static void OnEvaluateJavaScript(Evas_Object* o, const char* result, void* data)
 993   {
 994     auto client = WebEngineManager::Get().FindContainerClient(o);
 995     if (client)
 996     {
 997       client->RunJavaScriptEvaluationResultHandler((size_t)data, result);
 998     }
 999   }
1000
1001   static void OnJavaScriptMessage(Evas_Object* o, Ewk_Script_Message message)
1002   {
1003     auto client = WebEngineManager::Get().FindContainerClient(o);
1004     if (client)
1005     {
1006       client->RunJavaScriptMessageHandler(message.name, static_cast<char*>(message.body));
1007     }
1008   }
1009
1010   static Eina_Bool OnJavaScriptAlert(Evas_Object* o, const char* alert_text, void*)
1011   {
1012     bool result = false;
1013     auto client = WebEngineManager::Get().FindContainerClient(o);
1014     if (client)
1015     {
1016       result = client->JavaScriptAlert(const_cast<char*>(alert_text));
1017     }
1018     return result;
1019   }
1020
1021   static Eina_Bool OnJavaScriptConfirm(Evas_Object* o, const char* message, void*)
1022   {
1023     bool result = false;
1024     auto client = WebEngineManager::Get().FindContainerClient(o);
1025     if (client)
1026     {
1027       result = client->JavaScriptConfirm(const_cast<char*>(message));
1028     }
1029     return result;
1030   }
1031
1032   static Eina_Bool OnJavaScriptPrompt(Evas_Object* o, const char* message, const char* default_value, void*)
1033   {
1034     bool result = false;
1035     auto client = WebEngineManager::Get().FindContainerClient(o);
1036     if (client)
1037     {
1038       result = client->JavaScriptPrompt(const_cast<char*>(message), const_cast<char*>(default_value));
1039     }
1040     return result;
1041   }
1042
1043   static void OnHitTestCreated(Evas_Object*, int x, int y, int hitTestMode, Ewk_Hit_Test* hitTest, void* data)
1044   {
1045     auto client = static_cast<WebViewContainerClient*>(data);
1046     Evas* evas = ecore_evas_get(WebEngineManager::Get().GetWindow());
1047     std::unique_ptr<Dali::WebEngineHitTest> webHitTest(new TizenWebEngineHitTest(hitTest, evas, false));
1048     client->HitTestCreated(std::move(webHitTest));
1049   }
1050
1051 private:
1052   Evas_Object*            mWebView;
1053   WebViewContainerClient& mClient;
1054
1055   uint32_t    mWidth;
1056   uint32_t    mHeight;
1057   std::string mUserAgent;
1058
1059   TizenWebEngineSettings        mWebEngineSettings;
1060   TizenWebEngineContext         mWebEngineContext;
1061   TizenWebEngineCookieManager   mWebEngineCookieManager;
1062   TizenWebEngineBackForwardList mWebEngineBackForwardList;
1063 };
1064
1065 class TBMSurfaceSourceInitializer
1066 {
1067 public:
1068   explicit TBMSurfaceSourceInitializer(NativeImageSourcePtr& imageSrc, uint32_t width, uint32_t height)
1069   {
1070     mSurface = tbm_surface_create(width, height, TBM_FORMAT_ARGB8888);
1071     if (!mSurface)
1072     {
1073       DALI_LOG_ERROR("Failed to create tbm surface.");
1074     }
1075
1076     Any tbmSource(mSurface);
1077     imageSrc = NativeImageSource::New(tbmSource);
1078     Any emptySource(0);
1079     imageSrc->SetSource(emptySource);
1080   }
1081
1082   ~TBMSurfaceSourceInitializer()
1083   {
1084     if (mSurface)
1085     {
1086       if (tbm_surface_destroy(mSurface) != TBM_SURFACE_ERROR_NONE)
1087       {
1088         DALI_LOG_ERROR("Failed to destroy tbm surface.");
1089       }
1090     }
1091   }
1092
1093 private:
1094   tbm_surface_h mSurface;
1095 };
1096
1097 TizenWebEngineChromium::TizenWebEngineChromium()
1098   : mWebViewContainer(0)
1099   , mJavaScriptEvaluationCount(0)
1100 {
1101 }
1102
1103 TizenWebEngineChromium::~TizenWebEngineChromium()
1104 {
1105   Destroy();
1106 }
1107
1108 void TizenWebEngineChromium::Create(uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneID)
1109 {
1110   mWebViewContainer = new WebViewContainerForDali(*this, width, height);
1111   TBMSurfaceSourceInitializer initializer(mDaliImageSrc, width, height);
1112 }
1113
1114 void TizenWebEngineChromium::Create(uint32_t width, uint32_t height, uint32_t argc, char** argv)
1115 {
1116   mWebViewContainer = new WebViewContainerForDali(*this, width, height, argc, argv);
1117   TBMSurfaceSourceInitializer initializer(mDaliImageSrc, width, height);
1118 }
1119
1120 void TizenWebEngineChromium::Destroy()
1121 {
1122   if (mWebViewContainer)
1123   {
1124     mJavaScriptEvaluationResultHandlers.clear();
1125     mJavaScriptMessageHandlers.clear();
1126
1127     delete mWebViewContainer;
1128     mWebViewContainer = 0;
1129   }
1130 }
1131
1132 void TizenWebEngineChromium::LoadUrl(const std::string& path)
1133 {
1134   if (mWebViewContainer)
1135   {
1136     mWebViewContainer->LoadUrl(path);
1137   }
1138 }
1139
1140 std::string TizenWebEngineChromium::GetTitle() const
1141 {
1142   return mWebViewContainer ? mWebViewContainer->GetTitle() : EMPTY_STRING;
1143 }
1144
1145 Dali::PixelData TizenWebEngineChromium::GetFavicon() const
1146 {
1147   return mWebViewContainer ? mWebViewContainer->GetFavicon() : Dali::PixelData();
1148 }
1149
1150 NativeImageInterfacePtr TizenWebEngineChromium::GetNativeImageSource()
1151 {
1152   return mDaliImageSrc;
1153 }
1154
1155 const std::string& TizenWebEngineChromium::GetUrl()
1156 {
1157   if (mWebViewContainer)
1158   {
1159     mUrl = mWebViewContainer->GetUrl();
1160   }
1161   return mUrl;
1162 }
1163
1164 void TizenWebEngineChromium::LoadHtmlString(const std::string& html)
1165 {
1166   if (mWebViewContainer)
1167   {
1168     mWebViewContainer->LoadHtml(html);
1169   }
1170 }
1171
1172 bool TizenWebEngineChromium::LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri,
1173                                                                 const std::string& unreachableUrl)
1174 {
1175   if (mWebViewContainer)
1176   {
1177     return mWebViewContainer->LoadHtmlStringOverrideCurrentEntry(html, basicUri, unreachableUrl);
1178   }
1179   return false;
1180 }
1181
1182 bool TizenWebEngineChromium::LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType,
1183                                           const std::string& encoding, const std::string& baseUri)
1184 {
1185   if (mWebViewContainer)
1186   {
1187     return mWebViewContainer->LoadContents(contents, contentSize, mimeType, encoding, baseUri);
1188   }
1189   return false;
1190 }
1191
1192 void TizenWebEngineChromium::Reload()
1193 {
1194   if (mWebViewContainer)
1195   {
1196     mWebViewContainer->Reload();
1197   }
1198 }
1199
1200 bool TizenWebEngineChromium::ReloadWithoutCache()
1201 {
1202   if (mWebViewContainer)
1203   {
1204     return mWebViewContainer->ReloadWithoutCache();
1205   }
1206   return false;
1207 }
1208
1209 void TizenWebEngineChromium::StopLoading()
1210 {
1211   if (mWebViewContainer)
1212   {
1213     mWebViewContainer->StopLoading();
1214   }
1215 }
1216
1217 void TizenWebEngineChromium::Suspend()
1218 {
1219   if (mWebViewContainer)
1220   {
1221     mWebViewContainer->Suspend();
1222   }
1223 }
1224
1225 void TizenWebEngineChromium::Resume()
1226 {
1227   if (mWebViewContainer)
1228   {
1229     mWebViewContainer->Resume();
1230   }
1231 }
1232
1233 void TizenWebEngineChromium::SuspendNetworkLoading()
1234 {
1235   if (mWebViewContainer)
1236   {
1237     mWebViewContainer->SuspendNetworkLoading();
1238   }
1239 }
1240
1241 void TizenWebEngineChromium::ResumeNetworkLoading()
1242 {
1243   if (mWebViewContainer)
1244   {
1245     mWebViewContainer->ResumeNetworkLoading();
1246   }
1247 }
1248
1249 bool TizenWebEngineChromium::AddCustomHeader(const std::string& name, const std::string& value)
1250 {
1251   if (mWebViewContainer)
1252   {
1253     return mWebViewContainer->AddCustomHeader(name, value);
1254   }
1255   return false;
1256 }
1257
1258 bool TizenWebEngineChromium::RemoveCustomHeader(const std::string& name)
1259 {
1260   if (mWebViewContainer)
1261   {
1262     return mWebViewContainer->RemoveCustomHeader(name);
1263   }
1264   return false;
1265 }
1266
1267 uint32_t TizenWebEngineChromium::StartInspectorServer(uint32_t port)
1268 {
1269   if (mWebViewContainer)
1270   {
1271     return mWebViewContainer->StartInspectorServer(port);
1272   }
1273   return 0;
1274 }
1275
1276 bool TizenWebEngineChromium::StopInspectorServer()
1277 {
1278   if (mWebViewContainer)
1279   {
1280     return mWebViewContainer->StopInspectorServer();
1281   }
1282   return false;
1283 }
1284
1285 void TizenWebEngineChromium::ScrollBy(int32_t deltaX, int32_t deltaY)
1286 {
1287   if (mWebViewContainer)
1288   {
1289     mWebViewContainer->ScrollBy(deltaX, deltaY);
1290   }
1291 }
1292
1293 bool TizenWebEngineChromium::ScrollEdgeBy(int32_t deltaX, int32_t deltaY)
1294 {
1295   if (mWebViewContainer)
1296   {
1297     return mWebViewContainer->ScrollEdgeBy(deltaX, deltaY);
1298   }
1299   return false;
1300 }
1301
1302 void TizenWebEngineChromium::SetScrollPosition(int32_t x, int32_t y)
1303 {
1304   if (mWebViewContainer)
1305   {
1306     mWebViewContainer->SetScrollPosition(x, y);
1307   }
1308 }
1309
1310 Dali::Vector2 TizenWebEngineChromium::GetScrollPosition() const
1311 {
1312   return mWebViewContainer ? mWebViewContainer->GetScrollPosition() : Dali::Vector2::ZERO;
1313 }
1314
1315 Dali::Vector2 TizenWebEngineChromium::GetScrollSize() const
1316 {
1317   return mWebViewContainer ? mWebViewContainer->GetScrollSize() : Dali::Vector2::ZERO;
1318 }
1319
1320 Dali::Vector2 TizenWebEngineChromium::GetContentSize() const
1321 {
1322   return mWebViewContainer ? mWebViewContainer->GetContentSize() : Dali::Vector2::ZERO;
1323 }
1324
1325 bool TizenWebEngineChromium::CanGoForward()
1326 {
1327   if (mWebViewContainer)
1328   {
1329     return mWebViewContainer->CanGoForward();
1330   }
1331   return false;
1332 }
1333
1334 void TizenWebEngineChromium::GoForward()
1335 {
1336   if (mWebViewContainer)
1337   {
1338     mWebViewContainer->GoForward();
1339   }
1340 }
1341
1342 bool TizenWebEngineChromium::CanGoBack()
1343 {
1344   if (mWebViewContainer)
1345   {
1346     return mWebViewContainer->CanGoBack();
1347   }
1348   return false;
1349 }
1350
1351 void TizenWebEngineChromium::GoBack()
1352 {
1353   if (mWebViewContainer)
1354   {
1355     mWebViewContainer->GoBack();
1356   }
1357 }
1358
1359 void TizenWebEngineChromium::EvaluateJavaScript(const std::string& script, std::function<void(const std::string&)> resultHandler)
1360 {
1361   if (mWebViewContainer)
1362   {
1363     bool badAlloc = false;
1364
1365     try
1366     {
1367       mJavaScriptEvaluationResultHandlers.emplace(mJavaScriptEvaluationCount, resultHandler);
1368     }
1369     catch (std::bad_alloc& e)
1370     {
1371       badAlloc = true;
1372       DALI_LOG_ERROR("Too many ongoing JavaScript evaluations.");
1373     }
1374
1375     if (!badAlloc)
1376     {
1377       mWebViewContainer->EvaluateJavaScript(mJavaScriptEvaluationCount++, script);
1378     }
1379   }
1380 }
1381
1382 void TizenWebEngineChromium::AddJavaScriptMessageHandler(const std::string& exposedObjectName, std::function<void(const std::string&)> handler)
1383 {
1384   if (mWebViewContainer)
1385   {
1386     if (mJavaScriptMessageHandlers.emplace(exposedObjectName, handler).second)
1387     {
1388       mWebViewContainer->AddJavaScriptMessageHandler(exposedObjectName);
1389     }
1390     else
1391     {
1392       DALI_LOG_ERROR("Callback for (%s) already exists.", exposedObjectName.c_str());
1393     }
1394   }
1395 }
1396
1397 void TizenWebEngineChromium::RegisterJavaScriptAlertCallback(Dali::WebEnginePlugin::JavaScriptAlertCallback callback)
1398 {
1399   if (!mWebViewContainer)
1400     return;
1401
1402   mJavaScriptAlertCallback = callback;
1403   mWebViewContainer->RegisterJavaScriptAlertCallback();
1404 }
1405
1406 void TizenWebEngineChromium::JavaScriptAlertReply()
1407 {
1408   if (mWebViewContainer)
1409   {
1410     mWebViewContainer->JavaScriptAlertReply();
1411   }
1412 }
1413
1414 void TizenWebEngineChromium::RegisterJavaScriptConfirmCallback(Dali::WebEnginePlugin::JavaScriptConfirmCallback callback)
1415 {
1416   if (!mWebViewContainer)
1417     return;
1418
1419   mJavaScriptConfirmCallback = callback;
1420   mWebViewContainer->RegisterJavaScriptConfirmCallback();
1421 }
1422
1423 void TizenWebEngineChromium::JavaScriptConfirmReply(bool confirmed)
1424 {
1425   if (mWebViewContainer)
1426   {
1427     mWebViewContainer->JavaScriptConfirmReply(confirmed);
1428   }
1429 }
1430
1431 void TizenWebEngineChromium::RegisterJavaScriptPromptCallback(Dali::WebEnginePlugin::JavaScriptPromptCallback callback)
1432 {
1433   if (!mWebViewContainer)
1434     return;
1435
1436   mJavaScriptPromptCallback = callback;
1437   mWebViewContainer->RegisterJavaScriptPromptCallback();
1438 }
1439
1440 void TizenWebEngineChromium::JavaScriptPromptReply(const std::string& result)
1441 {
1442   if (mWebViewContainer)
1443   {
1444     mWebViewContainer->JavaScriptPromptReply(result);
1445   }
1446 }
1447
1448 void TizenWebEngineChromium::ClearHistory()
1449 {
1450   if (mWebViewContainer)
1451   {
1452     mWebViewContainer->ClearHistory();
1453   }
1454 }
1455
1456 void TizenWebEngineChromium::ClearAllTilesResources()
1457 {
1458   if (mWebViewContainer)
1459   {
1460     mWebViewContainer->ClearAllTilesResources();
1461   }
1462 }
1463
1464 const std::string& TizenWebEngineChromium::GetUserAgent() const
1465 {
1466   if (mWebViewContainer)
1467   {
1468     return mWebViewContainer->GetUserAgent();
1469   }
1470   return EMPTY_STRING;
1471 }
1472
1473 void TizenWebEngineChromium::SetUserAgent(const std::string& userAgent)
1474 {
1475   if (mWebViewContainer)
1476   {
1477     mWebViewContainer->SetUserAgent(userAgent);
1478   }
1479 }
1480
1481 Dali::WebEngineSettings& TizenWebEngineChromium::GetSettings() const
1482 {
1483   if (mWebViewContainer)
1484   {
1485     return mWebViewContainer->GetSettings();
1486   }
1487
1488   DALI_LOG_ERROR("WebViewContainer is null.");
1489   static TizenWebEngineSettings dummy(nullptr);
1490
1491   return dummy;
1492 }
1493
1494 Dali::WebEngineContext& TizenWebEngineChromium::GetContext() const
1495 {
1496   if (mWebViewContainer)
1497   {
1498     return mWebViewContainer->GetContext();
1499   }
1500
1501   DALI_LOG_ERROR("WebViewContainer is null.");
1502   static TizenWebEngineContext dummy(nullptr);
1503
1504   return dummy;
1505 }
1506
1507 Dali::WebEngineCookieManager& TizenWebEngineChromium::GetCookieManager() const
1508 {
1509   if (mWebViewContainer)
1510   {
1511     return mWebViewContainer->GetCookieManager();
1512   }
1513
1514   DALI_LOG_ERROR("WebViewContainer is null.");
1515   static TizenWebEngineCookieManager dummy(nullptr);
1516
1517   return dummy;
1518 }
1519
1520 Dali::WebEngineBackForwardList& TizenWebEngineChromium::GetBackForwardList() const
1521 {
1522   if (mWebViewContainer)
1523   {
1524     return mWebViewContainer->GetBackForwardList();
1525   }
1526
1527   DALI_LOG_ERROR("WebViewContainer is null.");
1528   static TizenWebEngineBackForwardList dummy(nullptr);
1529
1530   return dummy;
1531 }
1532
1533 std::unique_ptr<Dali::WebEngineHitTest> TizenWebEngineChromium::CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
1534 {
1535   if (mWebViewContainer)
1536   {
1537     return mWebViewContainer->CreateHitTest(x, y, mode);
1538   }
1539   return nullptr;
1540 }
1541
1542 bool TizenWebEngineChromium::CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, Dali::WebEnginePlugin::WebEngineHitTestCreatedCallback callback)
1543 {
1544   bool result = false;
1545   if (mWebViewContainer)
1546   {
1547     mHitTestCreatedCallback = callback;
1548     result = mWebViewContainer->CreateHitTestAsynchronously(x, y, mode);
1549   }
1550   return result;
1551 }
1552
1553 void TizenWebEngineChromium::SetSize(uint32_t width, uint32_t height)
1554 {
1555   if (mWebViewContainer)
1556   {
1557     mWebViewContainer->SetSize(width, height);
1558   }
1559 }
1560
1561 void TizenWebEngineChromium::SetDocumentBackgroundColor(Dali::Vector4 color)
1562 {
1563   if(mWebViewContainer)
1564   {
1565     mWebViewContainer->SetDocumentBackgroundColor(color);
1566   }
1567 }
1568
1569 void TizenWebEngineChromium::ClearTilesWhenHidden(bool cleared)
1570 {
1571   if(mWebViewContainer)
1572   {
1573     mWebViewContainer->ClearTilesWhenHidden(cleared);
1574   }
1575 }
1576
1577 void TizenWebEngineChromium::SetTileCoverAreaMultiplier(float multiplier)
1578 {
1579   if(mWebViewContainer)
1580   {
1581     mWebViewContainer->SetTileCoverAreaMultiplier(multiplier);
1582   }
1583 }
1584
1585 void TizenWebEngineChromium::EnableCursorByClient(bool enabled)
1586 {
1587   if(mWebViewContainer)
1588   {
1589     mWebViewContainer->EnableCursorByClient(enabled);
1590   }
1591 }
1592
1593 std::string TizenWebEngineChromium::GetSelectedText() const
1594 {
1595   if(mWebViewContainer)
1596   {
1597     return mWebViewContainer->GetSelectedText();
1598   }
1599   return EMPTY_STRING;
1600 }
1601
1602 bool TizenWebEngineChromium::SendTouchEvent(const Dali::TouchEvent& touch)
1603 {
1604   if(mWebViewContainer)
1605   {
1606     return mWebViewContainer->SendTouchEvent(touch);
1607   }
1608   return false;
1609 }
1610
1611 bool TizenWebEngineChromium::SendKeyEvent(const Dali::KeyEvent& event)
1612 {
1613   if (mWebViewContainer)
1614   {
1615     return mWebViewContainer->SendKeyEvent(event);
1616   }
1617   return false;
1618 }
1619
1620 void TizenWebEngineChromium::SetFocus(bool focused)
1621 {
1622   if (mWebViewContainer)
1623   {
1624     return mWebViewContainer->SetFocus(focused);
1625   }
1626 }
1627
1628 void TizenWebEngineChromium::EnableMouseEvents(bool enabled)
1629 {
1630   if(mWebViewContainer)
1631   {
1632     mWebViewContainer->EnableMouseEvents(enabled);
1633   }
1634 }
1635
1636 void TizenWebEngineChromium::EnableKeyEvents(bool enabled)
1637 {
1638   if(mWebViewContainer)
1639   {
1640     mWebViewContainer->EnableKeyEvents(enabled);
1641   }
1642 }
1643
1644 void TizenWebEngineChromium::SetPageZoomFactor(float zoomFactor)
1645 {
1646   if (mWebViewContainer)
1647   {
1648     mWebViewContainer->SetPageZoomFactor(zoomFactor);
1649   }
1650 }
1651
1652 float TizenWebEngineChromium::GetPageZoomFactor() const
1653 {
1654   if (mWebViewContainer)
1655   {
1656     return mWebViewContainer->GetPageZoomFactor();
1657   }
1658   return 0.0f;
1659 }
1660
1661 void TizenWebEngineChromium::SetTextZoomFactor(float zoomFactor)
1662 {
1663   if (mWebViewContainer)
1664   {
1665     mWebViewContainer->SetTextZoomFactor(zoomFactor);
1666   }
1667 }
1668
1669 float TizenWebEngineChromium::GetTextZoomFactor() const
1670 {
1671   if (mWebViewContainer)
1672   {
1673     return mWebViewContainer->GetTextZoomFactor();
1674   }
1675   return 0.0f;
1676 }
1677
1678 float TizenWebEngineChromium::GetLoadProgressPercentage() const
1679 {
1680   if (mWebViewContainer)
1681   {
1682     return mWebViewContainer->GetLoadProgressPercentage();
1683   }
1684   return 0.0f;
1685 }
1686
1687 void TizenWebEngineChromium::SetScaleFactor(float scaleFactor, Dali::Vector2 point)
1688 {
1689   if (mWebViewContainer)
1690   {
1691     mWebViewContainer->SetScaleFactor(scaleFactor, point);
1692   }
1693 }
1694
1695 float TizenWebEngineChromium::GetScaleFactor() const
1696 {
1697   if (mWebViewContainer)
1698   {
1699     return mWebViewContainer->GetScaleFactor();
1700   }
1701   return 0.0f;
1702 }
1703
1704 void TizenWebEngineChromium::ActivateAccessibility(bool activated)
1705 {
1706   if (mWebViewContainer)
1707   {
1708     mWebViewContainer->ActivateAccessibility(activated);
1709   }
1710 }
1711
1712 bool TizenWebEngineChromium::SetVisibility(bool visible)
1713 {
1714   if (mWebViewContainer)
1715   {
1716     return mWebViewContainer->SetVisibility(visible);
1717   }
1718   return false;
1719 }
1720
1721 bool TizenWebEngineChromium::HighlightText(const std::string& text, Dali::WebEnginePlugin::FindOption options, uint32_t maxMatchCount)
1722 {
1723   if (mWebViewContainer)
1724   {
1725     return mWebViewContainer->HighlightText(text, options, maxMatchCount);
1726   }
1727   return false;
1728 }
1729
1730 void TizenWebEngineChromium::AddDynamicCertificatePath(const std::string& host, const std::string& certPath)
1731 {
1732   if (mWebViewContainer)
1733   {
1734     mWebViewContainer->AddDynamicCertificatePath(host, certPath);
1735   }
1736 }
1737
1738 Dali::PixelData TizenWebEngineChromium::GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
1739 {
1740   if (mWebViewContainer)
1741   {
1742     return mWebViewContainer->GetScreenshot(viewArea, scaleFactor);
1743   }
1744   return Dali::PixelData();
1745 }
1746
1747 bool TizenWebEngineChromium::GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, Dali::WebEnginePlugin::ScreenshotCapturedCallback callback)
1748 {
1749   if (mWebViewContainer)
1750   {
1751     mScreenshotCapturedCallback = callback;
1752     return mWebViewContainer->GetScreenshotAsynchronously(viewArea, scaleFactor);
1753   }
1754   return false;
1755 }
1756
1757 bool TizenWebEngineChromium::CheckVideoPlayingAsynchronously(Dali::WebEnginePlugin::VideoPlayingCallback callback)
1758 {
1759   if (mWebViewContainer)
1760   {
1761     mVideoPlayingCallback = callback;
1762     return mWebViewContainer->CheckVideoPlayingAsynchronously();
1763   }
1764   return false;
1765 }
1766
1767 void TizenWebEngineChromium::RegisterGeolocationPermissionCallback(GeolocationPermissionCallback callback)
1768 {
1769   if (mWebViewContainer)
1770   {
1771     mGeolocationPermissionCallback = callback;
1772     mWebViewContainer->RegisterGeolocationPermissionCallback();
1773   }
1774 }
1775
1776 void TizenWebEngineChromium::UpdateDisplayArea(Dali::Rect<int32_t> displayArea)
1777 {
1778   if (mWebViewContainer)
1779   {
1780     mWebViewContainer->UpdateDisplayArea(displayArea);
1781   }
1782 }
1783
1784 void TizenWebEngineChromium::EnableVideoHole(bool enabled)
1785 {
1786   if (mWebViewContainer)
1787   {
1788     return mWebViewContainer->EnableVideoHole(enabled);
1789   }
1790 }
1791
1792 bool TizenWebEngineChromium::SendHoverEvent(const Dali::HoverEvent& event)
1793 {
1794   if(mWebViewContainer)
1795   {
1796     return mWebViewContainer->SendHoverEvent( event );
1797   }
1798   return false;
1799 }
1800
1801 bool TizenWebEngineChromium::SendWheelEvent( const Dali::WheelEvent& event )
1802 {
1803   if( mWebViewContainer )
1804   {
1805     return mWebViewContainer->SendWheelEvent( event );
1806   }
1807   return false;
1808 }
1809
1810 Dali::WebEnginePlugin::WebEnginePageLoadSignalType& TizenWebEngineChromium::PageLoadStartedSignal()
1811 {
1812   return mLoadStartedSignal;
1813 }
1814
1815 Dali::WebEnginePlugin::WebEnginePageLoadSignalType& TizenWebEngineChromium::PageLoadInProgressSignal()
1816 {
1817   return mLoadInProgressSignal;
1818 }
1819
1820 Dali::WebEnginePlugin::WebEnginePageLoadSignalType& TizenWebEngineChromium::PageLoadFinishedSignal()
1821 {
1822   return mLoadFinishedSignal;
1823 }
1824
1825 Dali::WebEnginePlugin::WebEnginePageLoadErrorSignalType& TizenWebEngineChromium::PageLoadErrorSignal()
1826 {
1827   return mLoadErrorSignal;
1828 }
1829
1830 Dali::WebEnginePlugin::WebEngineScrollEdgeReachedSignalType& TizenWebEngineChromium::ScrollEdgeReachedSignal()
1831 {
1832   return mScrollEdgeReachedSignal;
1833 }
1834
1835 Dali::WebEnginePlugin::WebEngineUrlChangedSignalType& TizenWebEngineChromium::UrlChangedSignal()
1836 {
1837   return mUrlChangedSignal;
1838 }
1839
1840 Dali::WebEnginePlugin::WebEngineFormRepostDecisionSignalType& TizenWebEngineChromium::FormRepostDecisionSignal()
1841 {
1842   return mFormRepostDecisionSignal;
1843 }
1844
1845 Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& TizenWebEngineChromium::FrameRenderedSignal()
1846 {
1847   return mFrameRenderedSignal;
1848 }
1849
1850 Dali::WebEnginePlugin::WebEngineRequestInterceptorSignalType& TizenWebEngineChromium::RequestInterceptorSignal()
1851 {
1852   return mRequestInterceptorSignal;
1853 }
1854
1855 Dali::WebEnginePlugin::WebEngineConsoleMessageSignalType& TizenWebEngineChromium::ConsoleMessageSignal()
1856 {
1857   return mConsoleMessageSignal;
1858 }
1859
1860 Dali::WebEnginePlugin::WebEngineResponsePolicyDecisionSignalType& TizenWebEngineChromium::ResponsePolicyDecisionSignal()
1861 {
1862   return mResponsePolicyDecisionSignal;
1863 }
1864
1865 Dali::WebEnginePlugin::WebEngineCertificateSignalType& TizenWebEngineChromium::CertificateConfirmSignal()
1866 {
1867   return mCertificateConfirmSignal;
1868 }
1869
1870 Dali::WebEnginePlugin::WebEngineCertificateSignalType& TizenWebEngineChromium::SslCertificateChangedSignal()
1871 {
1872   return mSslCertificateChangedSignal;
1873 }
1874
1875 Dali::WebEnginePlugin::WebEngineHttpAuthHandlerSignalType& TizenWebEngineChromium::HttpAuthHandlerSignal()
1876 {
1877   return mHttpAuthHandlerSignal;
1878 }
1879
1880 Dali::WebEnginePlugin::WebEngineContextMenuCustomizedSignalType& TizenWebEngineChromium::ContextMenuCustomizedSignal()
1881 {
1882   return mContextMenuCustomizedSignal;
1883 }
1884
1885 Dali::WebEnginePlugin::WebEngineContextMenuItemSelectedSignalType& TizenWebEngineChromium::ContextMenuItemSelectedSignal()
1886 {
1887   return mContextMenuItemSelectedSignal;
1888 }
1889
1890 // WebViewContainerClient Interface
1891 void TizenWebEngineChromium::UpdateImage(tbm_surface_h buffer)
1892 {
1893   if (!buffer)
1894   {
1895     return;
1896   }
1897
1898   Any source(buffer);
1899   mDaliImageSrc->SetSource(source);
1900   Dali::Stage::GetCurrent().KeepRendering(0.0f);
1901
1902   mFrameRenderedSignal.Emit();
1903 }
1904
1905 void TizenWebEngineChromium::LoadStarted()
1906 {
1907   DALI_LOG_RELEASE_INFO("#LoadStarted : %s\n", GetUrl().c_str());
1908   mLoadStartedSignal.Emit(GetUrl());
1909 }
1910
1911 void TizenWebEngineChromium::LoadInProgress()
1912 {
1913   DALI_LOG_RELEASE_INFO("#LoadInProgress : %s\n", GetUrl().c_str());
1914   mLoadInProgressSignal.Emit("");
1915 }
1916
1917 void TizenWebEngineChromium::LoadFinished()
1918 {
1919   DALI_LOG_RELEASE_INFO("#LoadFinished : %s\n", GetUrl().c_str());
1920   mLoadFinishedSignal.Emit(GetUrl());
1921 }
1922
1923 void TizenWebEngineChromium::LoadError(std::shared_ptr<Dali::WebEngineLoadError> error)
1924 {
1925   DALI_LOG_RELEASE_INFO("#LoadError : %s\n", error->GetUrl().c_str());
1926   if (!mLoadErrorSignal.Empty())
1927   {
1928     mLoadErrorSignal.Emit(std::move(error));
1929   }
1930 }
1931
1932 void TizenWebEngineChromium::ScrollEdgeReached(Dali::WebEnginePlugin::ScrollEdge edge)
1933 {
1934   DALI_LOG_RELEASE_INFO("#ScrollEdgeReached : %d\n", edge);
1935   mScrollEdgeReachedSignal.Emit(edge);
1936 }
1937
1938 void TizenWebEngineChromium::UrlChanged(const std::string& url)
1939 {
1940   DALI_LOG_RELEASE_INFO("#UrlChanged : %s\n", url.c_str());
1941   mUrlChangedSignal.Emit(url);
1942 }
1943
1944 void TizenWebEngineChromium::RequestFormRepostDecision(std::shared_ptr<Dali::WebEngineFormRepostDecision> decision)
1945 {
1946   DALI_LOG_RELEASE_INFO("#FormRepostDecisionRequest\n");
1947   if (!mFormRepostDecisionSignal.Empty())
1948   {
1949     mFormRepostDecisionSignal.Emit(std::move(decision));
1950   }
1951 }
1952
1953 void TizenWebEngineChromium::InterceptRequest(std::shared_ptr<Dali::WebEngineRequestInterceptor> interceptor)
1954 {
1955   DALI_LOG_RELEASE_INFO("#InterceptRequest.\n");
1956   if (!mRequestInterceptorSignal.Empty())
1957   {
1958     mRequestInterceptorSignal.Emit(std::move(interceptor));
1959   }
1960 }
1961
1962 void TizenWebEngineChromium::OnConsoleMessage(std::shared_ptr<Dali::WebEngineConsoleMessage> message)
1963 {
1964   DALI_LOG_RELEASE_INFO("#OnConsoleMessage : %s\n", message->GetText());
1965   if (!mConsoleMessageSignal.Empty())
1966   {
1967     mConsoleMessageSignal.Emit(std::move(message));
1968   }
1969 }
1970
1971 void TizenWebEngineChromium::ResponsePolicyDecided(std::shared_ptr<Dali::WebEnginePolicyDecision> decision)
1972 {
1973   DALI_LOG_RELEASE_INFO("#ResponsePolicyDecided.\n");
1974   if (!mResponsePolicyDecisionSignal.Empty())
1975   {
1976     mResponsePolicyDecisionSignal.Emit(std::move(decision));
1977   }
1978 }
1979
1980 void TizenWebEngineChromium::CertificateConfirm(std::shared_ptr<Dali::WebEngineCertificate> confirm)
1981 {
1982   DALI_LOG_RELEASE_INFO("#CertificateConfirm.\n");
1983   if (!mCertificateConfirmSignal.Empty())
1984   {
1985     mCertificateConfirmSignal.Emit(std::move(confirm));
1986   }
1987 }
1988
1989 void TizenWebEngineChromium::SslCertificateChanged(std::shared_ptr<Dali::WebEngineCertificate> info)
1990 {
1991   DALI_LOG_RELEASE_INFO("#SslCertificateChanged.\n");
1992   if (!mSslCertificateChangedSignal.Empty())
1993   {
1994     mSslCertificateChangedSignal.Emit(std::move(info));
1995   }
1996 }
1997
1998 void TizenWebEngineChromium::AuthenticationChallenge(std::shared_ptr<Dali::WebEngineHttpAuthHandler> handler)
1999 {
2000   DALI_LOG_RELEASE_INFO("#AuthenticationChallenge.\n");
2001   if (!mHttpAuthHandlerSignal.Empty())
2002   {
2003     mHttpAuthHandlerSignal.Emit(std::move(handler));
2004   }
2005 }
2006
2007 void TizenWebEngineChromium::ContextMenuCustomized(std::shared_ptr<Dali::WebEngineContextMenu> menu)
2008 {
2009   DALI_LOG_RELEASE_INFO("#ContextMenuCustomized.\n");
2010   if (!mContextMenuCustomizedSignal.Empty())
2011   {
2012     mContextMenuCustomizedSignal.Emit(std::move(menu));
2013   }
2014 }
2015
2016 void TizenWebEngineChromium::ContextMenuItemSelected(std::shared_ptr<Dali::WebEngineContextMenuItem> item)
2017 {
2018   DALI_LOG_RELEASE_INFO("#ContextMenuItemSelected.\n");
2019   if (!mContextMenuItemSelectedSignal.Empty())
2020   {
2021     mContextMenuItemSelectedSignal.Emit(std::move(item));
2022   }
2023 }
2024
2025 void TizenWebEngineChromium::RunJavaScriptEvaluationResultHandler(size_t key, const char* result)
2026 {
2027   auto handler = mJavaScriptEvaluationResultHandlers.find(key);
2028   if (handler == mJavaScriptEvaluationResultHandlers.end())
2029   {
2030     return;
2031   }
2032
2033   if (handler->second)
2034   {
2035     std::string stored(result);
2036     handler->second(stored);
2037   }
2038
2039   mJavaScriptEvaluationResultHandlers.erase(handler);
2040 }
2041
2042 void TizenWebEngineChromium::RunJavaScriptMessageHandler(const std::string& objectName, const std::string& message)
2043 {
2044   auto handler = mJavaScriptMessageHandlers.find(objectName);
2045   if (handler == mJavaScriptMessageHandlers.end())
2046   {
2047     return;
2048   }
2049
2050   handler->second(message);
2051 }
2052
2053 bool TizenWebEngineChromium::JavaScriptAlert(const std::string& alert_text)
2054 {
2055   bool result = false;
2056   if (mJavaScriptAlertCallback)
2057   {
2058     result = mJavaScriptAlertCallback(alert_text);
2059   }
2060   return result;
2061 }
2062
2063 bool TizenWebEngineChromium::JavaScriptConfirm(const std::string& message)
2064 {
2065   bool result = false;
2066   if (mJavaScriptConfirmCallback)
2067   {
2068     result = mJavaScriptConfirmCallback(message);
2069   }
2070   return result;
2071 }
2072
2073 bool TizenWebEngineChromium::JavaScriptPrompt(const std::string& message, const std::string& default_value)
2074 {
2075   bool result = false;
2076   if (mJavaScriptPromptCallback)
2077   {
2078     result = mJavaScriptPromptCallback(message, default_value);
2079   }
2080   return result;
2081 }
2082
2083 void TizenWebEngineChromium::ScreenshotCaptured(Dali::PixelData pixelData)
2084 {
2085   if (mScreenshotCapturedCallback)
2086   {
2087     mScreenshotCapturedCallback(pixelData);
2088   }
2089 }
2090
2091 void TizenWebEngineChromium::VideoPlaying(bool isPlaying)
2092 {
2093   if (mVideoPlayingCallback)
2094   {
2095     mVideoPlayingCallback(isPlaying);
2096   }
2097 }
2098
2099 bool TizenWebEngineChromium::GeolocationPermission(const std::string& host, const std::string& protocol)
2100 {
2101   bool result = false;
2102   if (mGeolocationPermissionCallback)
2103   {
2104     result = mGeolocationPermissionCallback(host, protocol);
2105   }
2106   return result;
2107 }
2108
2109 bool TizenWebEngineChromium::HitTestCreated(std::unique_ptr<Dali::WebEngineHitTest> hitTest)
2110 {
2111   bool result = false;
2112   if (mHitTestCreatedCallback)
2113   {
2114     result = mHitTestCreatedCallback(std::move(hitTest));
2115   }
2116   return result;
2117 }
2118
2119 } // namespace Plugin
2120 } // namespace Dali
2121
2122 extern "C" DALI_EXPORT_API Dali::WebEnginePlugin* CreateWebEnginePlugin()
2123 {
2124   return new Dali::Plugin::TizenWebEngineChromium();
2125 }
2126
2127 extern "C" DALI_EXPORT_API void DestroyWebEnginePlugin(Dali::WebEnginePlugin* plugin)
2128 {
2129   if (plugin)
2130   {
2131     delete plugin;
2132   }
2133 }