dali-extension/web-engine-chromium/tizen-web-engine-chromium.cpp

   1 /*
   2  * Copyright (c) 2022 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-menu.h"
  24 #include "tizen-web-engine-context-menu-item.h"
  25 #include "tizen-web-engine-form-repost-decision.h"
  26 #include "tizen-web-engine-hit-test.h"
  27 #include "tizen-web-engine-http-auth-handler.h"
  28 #include "tizen-web-engine-load-error.h"
  29 #include "tizen-web-engine-manager.h"
  30 #include "tizen-web-engine-policy-decision.h"
  31 #include "tizen-web-engine-settings.h"
  32
  33 #include <Ecore_Evas.h>
  34 #include <Ecore_Wl2.h>
  35
  36 #include <dali/devel-api/common/stage.h>
  37 #include <dali/integration-api/adaptor-framework/adaptor.h>
  38 #include <dali/integration-api/debug.h>
  39 #include <dali/public-api/images/pixel-data.h>
  40
  41 #include <ewk_main_internal.h>
  42 #include <ewk_settings_product.h>
  43 #include <ewk_view_product.h>
  44
  45 using namespace Dali;
  46
  47 namespace Dali
  48 {
  49 namespace Plugin
  50 {
  51
  52 namespace
  53 {
  54
  55 template <typename Callback, typename... Args>
  56 void ExecuteCallback(Callback callback, Args... args)
  57 {
  58   if (callback)
  59   {
  60     callback(args...);
  61   }
  62 }
  63
  64 template <typename Callback, typename Arg>
  65 void ExecuteCallback(Callback callback, std::unique_ptr<Arg> arg)
  66 {
  67   if (callback)
  68   {
  69     callback(std::move(arg));
  70   }
  71 }
  72
  73 template <typename Ret, typename Callback, typename... Args>
  74 Ret ExecuteCallbackReturn(Callback callback, Args... args)
  75 {
  76   Ret returnVal = Ret();
  77   if (callback)
  78   {
  79     returnVal = callback(args...);
  80   }
  81   return returnVal;
  82 }
  83
  84 template <typename Ret, typename Callback, typename Arg>
  85 Ret ExecuteCallbackReturn(Callback callback, std::unique_ptr<Arg> arg)
  86 {
  87   Ret returnVal = Ret();
  88   if (callback)
  89   {
  90     returnVal = callback(std::move(arg));
  91   }
  92   return returnVal;
  93 }
  94
  95 } // Anonymous namespace
  96
  97 class TBMSurfaceSourceInitializer
  98 {
  99 public:
 100   explicit TBMSurfaceSourceInitializer(NativeImageSourcePtr& imageSrc, uint32_t width, uint32_t height)
 101   {
 102     mSurface = tbm_surface_create(width, height, TBM_FORMAT_ARGB8888);
 103     if (!mSurface)
 104     {
 105       DALI_LOG_ERROR("Failed to create tbm surface.");
 106     }
 107
 108     Any tbmSource(mSurface);
 109     imageSrc = NativeImageSource::New(tbmSource);
 110     Any emptySource(0);
 111     imageSrc->SetSource(emptySource);
 112   }
 113
 114   ~TBMSurfaceSourceInitializer()
 115   {
 116     if (mSurface)
 117     {
 118       if (tbm_surface_destroy(mSurface) != TBM_SURFACE_ERROR_NONE)
 119       {
 120         DALI_LOG_ERROR("Failed to destroy tbm surface.");
 121       }
 122     }
 123   }
 124
 125 private:
 126   tbm_surface_h mSurface;
 127 };
 128
 129 TizenWebEngineChromium::TizenWebEngineChromium()
 130   : mWebView(nullptr)
 131   , mWidth(0)
 132   , mHeight(0)
 133   , mJavaScriptEvaluationCount(0)
 134 {
 135 }
 136
 137 TizenWebEngineChromium::~TizenWebEngineChromium()
 138 {
 139   Destroy();
 140 }
 141
 142 void TizenWebEngineChromium::Create(uint32_t width, uint32_t height, const std::string& locale, const std::string& timezoneID)
 143 {
 144   mWidth = width;
 145   mHeight = height;
 146   InitWebView(0, nullptr);
 147   WebEngineManager::Get().Add(mWebView, this);
 148   TBMSurfaceSourceInitializer initializer(mDaliImageSrc, mWidth, mHeight);
 149 }
 150
 151 void TizenWebEngineChromium::Create(uint32_t width, uint32_t height, uint32_t argc, char** argv)
 152 {
 153   mWidth = width;
 154   mHeight = height;
 155   InitWebView(argc, argv);
 156   WebEngineManager::Get().Add(mWebView, this);
 157   TBMSurfaceSourceInitializer initializer(mDaliImageSrc, mWidth, mHeight);
 158 }
 159
 160 void TizenWebEngineChromium::Destroy()
 161 {
 162   mJavaScriptEvaluationResultHandlers.clear();
 163   mJavaScriptMessageHandlers.clear();
 164
 165   WebEngineManager::Get().Remove(mWebView);
 166   evas_object_del(mWebView);
 167 }
 168
 169 void TizenWebEngineChromium::LoadUrl(const std::string& path)
 170 {
 171   ewk_view_url_set(mWebView, path.c_str());
 172 }
 173
 174 std::string TizenWebEngineChromium::GetTitle() const
 175 {
 176   const char* title = ewk_view_title_get(mWebView);
 177   return title ? std::string(title) : std::string();
 178 }
 179
 180 Dali::PixelData TizenWebEngineChromium::GetFavicon() const
 181 {
 182   Evas_Object* iconObject = ewk_view_favicon_get(mWebView);
 183   if (!iconObject)
 184   {
 185     return Dali::PixelData();
 186   }
 187   return ConvertImageColorSpace(iconObject);
 188 }
 189
 190 NativeImageSourcePtr TizenWebEngineChromium::GetNativeImageSource()
 191 {
 192   return mDaliImageSrc;
 193 }
 194
 195 std::string TizenWebEngineChromium::GetUrl() const
 196 {
 197   const char* url = ewk_view_url_get(mWebView);
 198   return url ? std::string(url) : std::string();
 199 }
 200
 201 void TizenWebEngineChromium::LoadHtmlString(const std::string& html)
 202 {
 203   ewk_view_html_string_load(mWebView, html.c_str(), 0, 0);
 204 }
 205
 206 bool TizenWebEngineChromium::LoadHtmlStringOverrideCurrentEntry(const std::string& html, const std::string& basicUri, const std::string& unreachableUrl)
 207 {
 208   char* cBasicUri = basicUri.length() ?  (char *)basicUri.c_str() : nullptr;
 209   char* cUnreachableUrl = unreachableUrl.length() ?  (char *)unreachableUrl.c_str() : nullptr;
 210   return ewk_view_html_string_override_current_entry_load(mWebView, html.c_str(), cBasicUri, cUnreachableUrl);
 211 }
 212
 213 bool TizenWebEngineChromium::LoadContents(const std::string& contents, uint32_t contentSize, const std::string& mimeType,
 214                                           const std::string& encoding, const std::string& baseUri)
 215 {
 216   char* cMimeType = mimeType.length() ?  (char *)mimeType.c_str() : nullptr;
 217   char* cEncoding = encoding.length() ?  (char *)encoding.c_str() : nullptr;
 218   char* cBaseUri = baseUri.length() ?  (char *)baseUri.c_str() : nullptr;
 219   return ewk_view_contents_set(mWebView, contents.c_str(), contentSize, cMimeType, cEncoding, cBaseUri);
 220 }
 221
 222 void TizenWebEngineChromium::Reload()
 223 {
 224   ewk_view_reload(mWebView);
 225 }
 226
 227 bool TizenWebEngineChromium::ReloadWithoutCache()
 228 {
 229   return ewk_view_reload_bypass_cache(mWebView);
 230 }
 231
 232 void TizenWebEngineChromium::StopLoading()
 233 {
 234   ewk_view_stop(mWebView);
 235 }
 236
 237 void TizenWebEngineChromium::Suspend()
 238 {
 239   ewk_view_suspend(mWebView);
 240 }
 241
 242 void TizenWebEngineChromium::Resume()
 243 {
 244   ewk_view_resume(mWebView);
 245 }
 246
 247 void TizenWebEngineChromium::SuspendNetworkLoading()
 248 {
 249   ewk_view_suspend_network_loading(mWebView);
 250 }
 251
 252 void TizenWebEngineChromium::ResumeNetworkLoading()
 253 {
 254   ewk_view_resume_network_loading(mWebView);
 255 }
 256
 257 bool TizenWebEngineChromium::AddCustomHeader(const std::string& name, const std::string& value)
 258 {
 259   return ewk_view_custom_header_add(mWebView, name.c_str(), value.c_str());
 260 }
 261
 262 bool TizenWebEngineChromium::RemoveCustomHeader(const std::string& name)
 263 {
 264   return ewk_view_custom_header_remove(mWebView, name.c_str());
 265 }
 266
 267 uint32_t TizenWebEngineChromium::StartInspectorServer(uint32_t port)
 268 {
 269   return ewk_view_inspector_server_start(mWebView, port);
 270 }
 271
 272 bool TizenWebEngineChromium::StopInspectorServer()
 273 {
 274   return ewk_view_inspector_server_stop(mWebView);
 275 }
 276
 277 void TizenWebEngineChromium::ScrollBy(int32_t deltaX, int32_t deltaY)
 278 {
 279   ewk_view_scroll_by(mWebView, deltaX, deltaY);
 280 }
 281
 282 bool TizenWebEngineChromium::ScrollEdgeBy(int32_t deltaX, int32_t deltaY)
 283 {
 284   return ewk_view_edge_scroll_by(mWebView, deltaX, deltaY);
 285 }
 286
 287 void TizenWebEngineChromium::SetScrollPosition(int32_t x, int32_t y)
 288 {
 289   ewk_view_scroll_set(mWebView, x, y);
 290 }
 291
 292 Dali::Vector2 TizenWebEngineChromium::GetScrollPosition() const
 293 {
 294   int x = 0, y = 0;
 295   ewk_view_scroll_pos_get(mWebView, &x, &y);
 296   return Dali::Vector2(x, y);
 297 }
 298
 299 Dali::Vector2 TizenWebEngineChromium::GetScrollSize() const
 300 {
 301   int width = 0, height = 0;
 302   ewk_view_scroll_size_get(mWebView, &width, &height);
 303   return Dali::Vector2(width, height);
 304 }
 305
 306 Dali::Vector2 TizenWebEngineChromium::GetContentSize() const
 307 {
 308   int width = 0, height = 0;
 309   ewk_view_contents_size_get(mWebView, &width, &height);
 310   return Dali::Vector2(width, height);
 311 }
 312
 313 bool TizenWebEngineChromium::CanGoForward()
 314 {
 315   return ewk_view_forward_possible(mWebView);
 316 }
 317
 318 void TizenWebEngineChromium::GoForward()
 319 {
 320   ewk_view_forward(mWebView);
 321 }
 322
 323 bool TizenWebEngineChromium::CanGoBack()
 324 {
 325   return ewk_view_back_possible(mWebView);
 326 }
 327
 328 void TizenWebEngineChromium::GoBack()
 329 {
 330   ewk_view_back(mWebView);
 331 }
 332
 333 void TizenWebEngineChromium::EvaluateJavaScript(const std::string& script, JavaScriptMessageHandlerCallback resultHandler)
 334 {
 335   bool badAlloc = false;
 336
 337   try
 338   {
 339     mJavaScriptEvaluationResultHandlers.emplace(mJavaScriptEvaluationCount, resultHandler);
 340   }
 341   catch (std::bad_alloc& e)
 342   {
 343     badAlloc = true;
 344     DALI_LOG_ERROR("Too many ongoing JavaScript evaluations.");
 345   }
 346
 347   if (!badAlloc)
 348   {
 349     ewk_view_script_execute(mWebView, script.c_str(), &TizenWebEngineChromium::OnEvaluateJavaScript, (void*)mJavaScriptEvaluationCount);
 350     mJavaScriptEvaluationCount++;
 351   }
 352 }
 353
 354 void TizenWebEngineChromium::AddJavaScriptMessageHandler(const std::string& exposedObjectName, JavaScriptMessageHandlerCallback handler)
 355 {
 356   if (mJavaScriptMessageHandlers.emplace(exposedObjectName, handler).second)
 357   {
 358     ewk_view_javascript_message_handler_add(mWebView, &TizenWebEngineChromium::OnJavaScriptMessage, exposedObjectName.c_str());
 359   }
 360   else
 361   {
 362     DALI_LOG_ERROR("Callback for (%s) already exists.", exposedObjectName.c_str());
 363   }
 364 }
 365
 366 void TizenWebEngineChromium::RegisterJavaScriptAlertCallback(JavaScriptAlertCallback callback)
 367 {
 368   mJavaScriptAlertCallback = callback;
 369   ewk_view_javascript_alert_callback_set(mWebView, &TizenWebEngineChromium::OnJavaScriptAlert, this);
 370 }
 371
 372 void TizenWebEngineChromium::JavaScriptAlertReply()
 373 {
 374   ewk_view_javascript_alert_reply(mWebView);
 375 }
 376
 377 void TizenWebEngineChromium::RegisterJavaScriptConfirmCallback(JavaScriptConfirmCallback callback)
 378 {
 379   mJavaScriptConfirmCallback = callback;
 380   ewk_view_javascript_confirm_callback_set(mWebView, &TizenWebEngineChromium::OnJavaScriptConfirm, this);
 381 }
 382
 383 void TizenWebEngineChromium::JavaScriptConfirmReply(bool confirmed)
 384 {
 385   ewk_view_javascript_confirm_reply(mWebView, confirmed);
 386 }
 387
 388 void TizenWebEngineChromium::RegisterJavaScriptPromptCallback(JavaScriptPromptCallback callback)
 389 {
 390   mJavaScriptPromptCallback = callback;
 391   ewk_view_javascript_prompt_callback_set(mWebView, &TizenWebEngineChromium::OnJavaScriptPrompt, this);
 392 }
 393
 394 void TizenWebEngineChromium::JavaScriptPromptReply(const std::string& result)
 395 {
 396   ewk_view_javascript_prompt_reply(mWebView, result.c_str());
 397 }
 398
 399 void TizenWebEngineChromium::ClearHistory()
 400 {
 401   ewk_view_back_forward_list_clear(mWebView);
 402 }
 403
 404 void TizenWebEngineChromium::ClearAllTilesResources()
 405 {
 406   ewk_view_clear_all_tiles_resources(mWebView);
 407 }
 408
 409 std::string TizenWebEngineChromium::GetUserAgent() const
 410 {
 411   const char* agent = ewk_view_user_agent_get(mWebView);
 412   return agent ? std::string(agent) : std::string();
 413 }
 414
 415 void TizenWebEngineChromium::SetUserAgent(const std::string& userAgent)
 416 {
 417   ewk_view_user_agent_set(mWebView, userAgent.c_str());
 418 }
 419
 420 Dali::WebEngineSettings& TizenWebEngineChromium::GetSettings() const
 421 {
 422   static TizenWebEngineSettings dummy(nullptr);
 423   return mWebEngineSettings ? *mWebEngineSettings : dummy;
 424 }
 425
 426 Dali::WebEngineBackForwardList& TizenWebEngineChromium::GetBackForwardList() const
 427 {
 428   static TizenWebEngineBackForwardList dummy(nullptr);
 429   return mWebEngineBackForwardList ? *mWebEngineBackForwardList : dummy;
 430 }
 431
 432 std::unique_ptr<Dali::WebEngineHitTest> TizenWebEngineChromium::CreateHitTest(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode)
 433 {
 434   // sync...
 435   Evas* evas = ecore_evas_get(WebEngineManager::Get().GetWindow());
 436   Ewk_Hit_Test* hitTest = ewk_view_hit_test_new(mWebView, x, y, (int)mode);
 437   std::unique_ptr<Dali::WebEngineHitTest> webHitTest(new TizenWebEngineHitTest(hitTest, evas, true));
 438   return webHitTest;
 439 }
 440
 441 bool TizenWebEngineChromium::CreateHitTestAsynchronously(int32_t x, int32_t y, Dali::WebEngineHitTest::HitTestMode mode, WebEngineHitTestCreatedCallback callback)
 442 {
 443   mHitTestCreatedCallback = callback;
 444   bool result = ewk_view_hit_test_request(mWebView, x, y, (int)mode, &TizenWebEngineChromium::OnHitTestCreated, this);
 445   return result;
 446 }
 447
 448 void TizenWebEngineChromium::SetSize(uint32_t width, uint32_t height)
 449 {
 450   mWidth = width;
 451   mHeight = height;
 452   evas_object_resize(mWebView, mWidth, mHeight);
 453 }
 454
 455 void TizenWebEngineChromium::SetDocumentBackgroundColor(Dali::Vector4 color)
 456 {
 457   ewk_view_bg_color_set(mWebView, color.r * 255, color.g * 255, color.b * 255, color.a * 255);
 458 }
 459
 460 void TizenWebEngineChromium::ClearTilesWhenHidden(bool cleared)
 461 {
 462   ewk_view_clear_tiles_on_hide_enabled_set(mWebView, cleared);
 463 }
 464
 465 void TizenWebEngineChromium::SetTileCoverAreaMultiplier(float multiplier)
 466 {
 467   ewk_view_tile_cover_area_multiplier_set(mWebView, multiplier);
 468 }
 469
 470 void TizenWebEngineChromium::EnableCursorByClient(bool enabled)
 471 {
 472   ewk_view_set_cursor_by_client(mWebView, enabled);
 473 }
 474
 475 std::string TizenWebEngineChromium::GetSelectedText() const
 476 {
 477   const char* text = ewk_view_text_selection_text_get(mWebView);
 478   return text ? std::string(text) : std::string();
 479 }
 480
 481 bool TizenWebEngineChromium::SendTouchEvent(const Dali::TouchEvent& touch)
 482 {
 483 #if defined(OS_TIZEN_TV)
 484   return FeedMouseEvent(touch);
 485 #else
 486   return FeedTouchEvent(touch);
 487 #endif
 488 }
 489
 490 bool TizenWebEngineChromium::SendKeyEvent(const Dali::KeyEvent& keyEvent)
 491 {
 492   void* evasKeyEvent = 0;
 493   if (keyEvent.GetState() == Dali::KeyEvent::DOWN)
 494   {
 495     Evas_Event_Key_Down downEvent;
 496     memset(&downEvent, 0, sizeof(Evas_Event_Key_Down));
 497     downEvent.key = keyEvent.GetKeyName().c_str();
 498     downEvent.string = keyEvent.GetKeyString().c_str();
 499     evasKeyEvent = static_cast<void*>(&downEvent);
 500     ewk_view_send_key_event(mWebView, evasKeyEvent, true);
 501   }
 502   else
 503   {
 504     Evas_Event_Key_Up upEvent;
 505     memset(&upEvent, 0, sizeof(Evas_Event_Key_Up));
 506     upEvent.key = keyEvent.GetKeyName().c_str();
 507     upEvent.string = keyEvent.GetKeyString().c_str();
 508     evasKeyEvent = static_cast<void*>(&upEvent);
 509     ewk_view_send_key_event(mWebView, evasKeyEvent, false);
 510   }
 511   return false;
 512 }
 513
 514 bool TizenWebEngineChromium::SendHoverEvent(const Dali::HoverEvent& event)
 515 {
 516   return false;
 517 }
 518
 519 bool TizenWebEngineChromium::SendWheelEvent(const Dali::WheelEvent& wheel)
 520 {
 521   Eina_Bool direction = wheel.GetDirection() ? false : true;
 522   int step = wheel.GetDelta();
 523   float x = wheel.GetPoint().x;
 524   float y = wheel.GetPoint().y;
 525   ewk_view_feed_mouse_wheel(mWebView, direction, step, x, y);
 526   return false;
 527 }
 528
 529 void TizenWebEngineChromium::SetFocus(bool focused)
 530 {
 531   ecore_evas_focus_set(WebEngineManager::Get().GetWindow(), focused);
 532   ewk_view_focus_set(mWebView, focused);
 533 }
 534
 535 void TizenWebEngineChromium::EnableMouseEvents(bool enabled)
 536 {
 537   ewk_view_mouse_events_enabled_set(mWebView, enabled);
 538 }
 539
 540 void TizenWebEngineChromium::EnableKeyEvents(bool enabled)
 541 {
 542   ewk_view_key_events_enabled_set(mWebView, enabled);
 543 }
 544
 545 void TizenWebEngineChromium::SetPageZoomFactor(float zoomFactor)
 546 {
 547   ewk_view_page_zoom_set(mWebView, zoomFactor);
 548 }
 549
 550 float TizenWebEngineChromium::GetPageZoomFactor() const
 551 {
 552   return ewk_view_page_zoom_get(mWebView);
 553 }
 554
 555 void TizenWebEngineChromium::SetTextZoomFactor(float zoomFactor)
 556 {
 557   ewk_view_text_zoom_set(mWebView, zoomFactor);
 558 }
 559
 560 float TizenWebEngineChromium::GetTextZoomFactor() const
 561 {
 562   return ewk_view_text_zoom_get(mWebView);
 563 }
 564
 565 float TizenWebEngineChromium::GetLoadProgressPercentage() const
 566 {
 567   return ewk_view_load_progress_get(mWebView);
 568 }
 569
 570 void TizenWebEngineChromium::SetScaleFactor(float scaleFactor, Dali::Vector2 point)
 571 {
 572   ewk_view_scale_set(mWebView, scaleFactor, point.x, point.y);
 573 }
 574
 575 float TizenWebEngineChromium::GetScaleFactor() const
 576 {
 577   return ewk_view_scale_get(mWebView);
 578 }
 579
 580 void TizenWebEngineChromium::ActivateAccessibility(bool activated)
 581 {
 582   ewk_view_atk_deactivation_by_app(mWebView, !activated);
 583 }
 584
 585 Accessibility::Address TizenWebEngineChromium::GetAccessibilityAddress()
 586 {
 587   static const char plugIdKey[] = "__PlugID";
 588   static const char rootPath[]  = "root";
 589
 590   std::string_view plugId;
 591
 592   if (auto* data = static_cast<const char*>(evas_object_data_get(mWebView, plugIdKey)))
 593   {
 594     plugId = {data};
 595   }
 596
 597   // We expect plugId to be of the form ":1.23:/org/a11y/atspi/accessible/root"
 598   auto pos = plugId.rfind(':');
 599   if (pos == std::string_view::npos || pos == 0)
 600   {
 601     DALI_LOG_ERROR("Cannot parse PlugID set by Chromium: %s = \"%s\"", plugIdKey, plugId.data());
 602     return {};
 603   }
 604
 605   return {std::string{plugId.substr(0, pos)}, rootPath};
 606 }
 607
 608 bool TizenWebEngineChromium::SetVisibility(bool visible)
 609 {
 610   return ewk_view_visibility_set(mWebView, visible);
 611 }
 612
 613 bool TizenWebEngineChromium::HighlightText(const std::string& text, Dali::WebEnginePlugin::FindOption options, uint32_t maxMatchCount)
 614 {
 615   return ewk_view_text_find(mWebView, text.c_str(), (Ewk_Find_Options)options, maxMatchCount);
 616 }
 617
 618 void TizenWebEngineChromium::AddDynamicCertificatePath(const std::string& host, const std::string& certPath)
 619 {
 620   ewk_view_add_dynamic_certificate_path(mWebView, host.c_str(), certPath.c_str());
 621 }
 622
 623 Dali::PixelData TizenWebEngineChromium::GetScreenshot(Dali::Rect<int32_t> viewArea, float scaleFactor)
 624 {
 625   Eina_Rectangle rect;
 626   EINA_RECTANGLE_SET(&rect, viewArea.x, viewArea.y, viewArea.width, viewArea.height);
 627   Evas *evas = ecore_evas_get(WebEngineManager::Get().GetWindow());
 628   Evas_Object *snapShotObject = ewk_view_screenshot_contents_get(mWebView, rect, scaleFactor, evas);
 629   if (!snapShotObject)
 630   {
 631     return Dali::PixelData();
 632   }
 633   return ConvertImageColorSpace(snapShotObject);
 634 }
 635
 636 bool TizenWebEngineChromium::GetScreenshotAsynchronously(Dali::Rect<int32_t> viewArea, float scaleFactor, ScreenshotCapturedCallback callback)
 637 {
 638   Eina_Rectangle rect;
 639   EINA_RECTANGLE_SET(&rect, viewArea.x, viewArea.y, viewArea.width, viewArea.height);
 640   Evas *evas = ecore_evas_get(WebEngineManager::Get().GetWindow());
 641   return ewk_view_screenshot_contents_get_async(mWebView, rect, scaleFactor, evas, &TizenWebEngineChromium::OnScreenshotCaptured, this);
 642 }
 643
 644 bool TizenWebEngineChromium::CheckVideoPlayingAsynchronously(VideoPlayingCallback callback)
 645 {
 646   return ewk_view_is_video_playing(mWebView, &TizenWebEngineChromium::OnVideoPlaying, this);
 647 }
 648
 649 void TizenWebEngineChromium::GetPlainTextAsynchronously(PlainTextReceivedCallback callback)
 650 {
 651   mPlainTextReceivedCallback = callback;
 652   ewk_view_plain_text_get(mWebView, &TizenWebEngineChromium::OnPlainTextReceived, this);
 653 }
 654
 655 void TizenWebEngineChromium::RegisterGeolocationPermissionCallback(GeolocationPermissionCallback callback)
 656 {
 657   ewk_view_geolocation_permission_callback_set(mWebView, &TizenWebEngineChromium::OnGeolocationPermission, this);
 658 }
 659
 660 void TizenWebEngineChromium::UpdateDisplayArea(Dali::Rect<int32_t> displayArea)
 661 {
 662   evas_object_move(mWebView, displayArea.x, displayArea.y);
 663   SetSize(displayArea.width, displayArea.height);
 664   evas_object_geometry_set(mWebView, displayArea.x, displayArea.y, displayArea.width, displayArea.height);
 665 }
 666
 667 void TizenWebEngineChromium::EnableVideoHole(bool enabled)
 668 {
 669   Ecore_Wl2_Window* win = AnyCast<Ecore_Wl2_Window*>(Adaptor::Get().GetNativeWindowHandle());
 670   ewk_view_set_support_video_hole(mWebView, win, enabled, EINA_FALSE);
 671 }
 672
 673 Dali::WebEnginePlugin::WebEngineFrameRenderedSignalType& TizenWebEngineChromium::FrameRenderedSignal()
 674 {
 675   return mFrameRenderedSignal;
 676 }
 677
 678 void TizenWebEngineChromium::RegisterPageLoadStartedCallback(WebEnginePageLoadCallback callback)
 679 {
 680   mLoadStartedCallback = callback;
 681 }
 682
 683 void TizenWebEngineChromium::RegisterPageLoadInProgressCallback(WebEnginePageLoadCallback callback)
 684 {
 685   mLoadInProgressCallback = callback;
 686 }
 687
 688 void TizenWebEngineChromium::RegisterPageLoadFinishedCallback(WebEnginePageLoadCallback callback)
 689 {
 690   mLoadFinishedCallback = callback;
 691 }
 692
 693 void TizenWebEngineChromium::RegisterPageLoadErrorCallback(WebEnginePageLoadErrorCallback callback)
 694 {
 695   mLoadErrorCallback = callback;
 696 }
 697
 698 void TizenWebEngineChromium::RegisterScrollEdgeReachedCallback(WebEngineScrollEdgeReachedCallback callback)
 699 {
 700   mScrollEdgeReachedCallback = callback;
 701 }
 702
 703 void TizenWebEngineChromium::RegisterUrlChangedCallback(WebEngineUrlChangedCallback callback)
 704 {
 705   mUrlChangedCallback = callback;
 706 }
 707
 708 void TizenWebEngineChromium::RegisterFormRepostDecidedCallback(WebEngineFormRepostDecidedCallback callback)
 709 {
 710   mFormRepostDecidedCallback = callback;
 711 }
 712
 713 void TizenWebEngineChromium::RegisterConsoleMessageReceivedCallback(WebEngineConsoleMessageReceivedCallback callback)
 714 {
 715   mConsoleMessageReceivedCallback = callback;
 716 }
 717
 718 void TizenWebEngineChromium::RegisterResponsePolicyDecidedCallback(WebEngineResponsePolicyDecidedCallback callback)
 719 {
 720   mResponsePolicyDecidedCallback = callback;
 721 }
 722
 723 void TizenWebEngineChromium::RegisterNavigationPolicyDecidedCallback(WebEngineNavigationPolicyDecidedCallback callback)
 724 {
 725   mNavigationPolicyDecidedCallback = callback;
 726 }
 727
 728 void TizenWebEngineChromium::RegisterCertificateConfirmedCallback(WebEngineCertificateCallback callback)
 729 {
 730   mCertificateConfirmedCallback = callback;
 731 }
 732
 733 void TizenWebEngineChromium::RegisterSslCertificateChangedCallback(WebEngineCertificateCallback callback)
 734 {
 735   mSslCertificateChangedCallback = callback;
 736 }
 737
 738 void TizenWebEngineChromium::RegisterHttpAuthHandlerCallback(WebEngineHttpAuthHandlerCallback callback)
 739 {
 740   mHttpAuthHandlerCallback = callback;
 741 }
 742
 743 void TizenWebEngineChromium::RegisterContextMenuShownCallback(WebEngineContextMenuShownCallback callback)
 744 {
 745   mContextMenuShownCallback = callback;
 746 }
 747
 748 void TizenWebEngineChromium::RegisterContextMenuHiddenCallback(WebEngineContextMenuHiddenCallback callback)
 749 {
 750   mContextMenuHiddenCallback = callback;
 751 }
 752
 753 void TizenWebEngineChromium::RunJavaScriptEvaluationResultHandler(size_t key, const char* result)
 754 {
 755   auto handler = mJavaScriptEvaluationResultHandlers.find(key);
 756   if (handler == mJavaScriptEvaluationResultHandlers.end())
 757   {
 758     return;
 759   }
 760
 761   if (handler->second)
 762   {
 763     std::string stored(result);
 764     handler->second(stored);
 765   }
 766
 767   mJavaScriptEvaluationResultHandlers.erase(handler);
 768 }
 769
 770 void TizenWebEngineChromium::RunJavaScriptMessageHandler(const std::string& objectName, const std::string& message)
 771 {
 772   auto handler = mJavaScriptMessageHandlers.find(objectName);
 773   if (handler == mJavaScriptMessageHandlers.end())
 774   {
 775     return;
 776   }
 777
 778   handler->second(message);
 779 }
 780
 781 bool TizenWebEngineChromium::JavaScriptAlert(const std::string& alert_text)
 782 {
 783   return ExecuteCallbackReturn<bool>(mJavaScriptAlertCallback, alert_text);
 784 }
 785
 786 bool TizenWebEngineChromium::JavaScriptConfirm(const std::string& message)
 787 {
 788   return ExecuteCallbackReturn<bool>(mJavaScriptConfirmCallback, message);
 789 }
 790
 791 bool TizenWebEngineChromium::JavaScriptPrompt(const std::string& message, const std::string& default_value)
 792 {
 793   return ExecuteCallbackReturn<bool>(mJavaScriptPromptCallback, message, default_value);
 794 }
 795
 796 void TizenWebEngineChromium::ScreenshotCaptured(Dali::PixelData pixelData)
 797 {
 798   DALI_LOG_RELEASE_INFO("#ScreenshotCaptured.\n");
 799   ExecuteCallback(mScreenshotCapturedCallback, pixelData);
 800 }
 801
 802 void TizenWebEngineChromium::VideoPlaying(bool isPlaying)
 803 {
 804   ExecuteCallback(mVideoPlayingCallback, isPlaying);
 805 }
 806
 807 bool TizenWebEngineChromium::GeolocationPermission(const std::string& host, const std::string& protocol)
 808 {
 809   return ExecuteCallbackReturn<bool>(mGeolocationPermissionCallback, host, protocol);
 810 }
 811
 812 bool TizenWebEngineChromium::HitTestCreated(std::unique_ptr<Dali::WebEngineHitTest> hitTest)
 813 {
 814   return ExecuteCallbackReturn<bool>(mHitTestCreatedCallback, std::move(hitTest));
 815 }
 816
 817 void TizenWebEngineChromium::PlainTextRecieved(const std::string& plainText)
 818 {
 819   ExecuteCallback(mPlainTextReceivedCallback, plainText);
 820 }
 821
 822 void TizenWebEngineChromium::InitWebView(uint32_t argc, char** argv)
 823 {
 824   if (argc > 0)
 825   {
 826     ewk_set_arguments(argc, argv);
 827   }
 828
 829   Ecore_Wl2_Window* win = AnyCast<Ecore_Wl2_Window*>(Adaptor::Get().GetNativeWindowHandle());
 830   Ewk_Context* context = ewk_context_default_get();
 831   ewk_context_max_refresh_rate_set(context, 60);
 832   mWebView = ewk_view_add(ecore_evas_get(WebEngineManager::Get().GetWindow()));
 833   ewk_view_offscreen_rendering_enabled_set(mWebView, true);
 834   ewk_view_ime_window_set(mWebView, win);
 835
 836   Ewk_Settings* settings = ewk_view_settings_get(mWebView);
 837   mWebEngineSettings.reset(new TizenWebEngineSettings(settings));
 838
 839   Ewk_Back_Forward_List* backForwardList = ewk_view_back_forward_list_get(mWebView);
 840   mWebEngineBackForwardList.reset(new TizenWebEngineBackForwardList(backForwardList));
 841
 842   ewk_settings_viewport_meta_tag_set(settings, false);
 843
 844   evas_object_smart_callback_add(mWebView, "offscreen,frame,rendered",
 845                                  &TizenWebEngineChromium::OnFrameRendered,
 846                                  this);
 847   evas_object_smart_callback_add(mWebView, "load,started",
 848                                  &TizenWebEngineChromium::OnLoadStarted,
 849                                  this);
 850   evas_object_smart_callback_add(mWebView, "load,progress",
 851                                  &TizenWebEngineChromium::OnLoadInProgress,
 852                                  this);
 853   evas_object_smart_callback_add(mWebView, "load,finished",
 854                                  &TizenWebEngineChromium::OnLoadFinished,
 855                                  this);
 856   evas_object_smart_callback_add(mWebView, "load,error",
 857                                  &TizenWebEngineChromium::OnLoadError,
 858                                  this);
 859   evas_object_smart_callback_add(mWebView, "url,changed",
 860                                  &TizenWebEngineChromium::OnUrlChanged,
 861                                  this);
 862   evas_object_smart_callback_add(mWebView, "console,message",
 863                                  &TizenWebEngineChromium::OnConsoleMessageReceived,
 864                                  this);
 865   evas_object_smart_callback_add(mWebView, "edge,left",
 866                                  &TizenWebEngineChromium::OnEdgeLeft,
 867                                  this);
 868   evas_object_smart_callback_add(mWebView, "edge,right",
 869                                  &TizenWebEngineChromium::OnEdgeRight,
 870                                  this);
 871   evas_object_smart_callback_add(mWebView, "edge,top",
 872                                  &TizenWebEngineChromium::OnEdgeTop,
 873                                  this);
 874   evas_object_smart_callback_add(mWebView, "edge,bottom",
 875                                  &TizenWebEngineChromium::OnEdgeBottom,
 876                                  this);
 877   evas_object_smart_callback_add(mWebView, "form,repost,warning,show",
 878                                  &TizenWebEngineChromium::OnFormRepostDecided,
 879                                  this);
 880   evas_object_smart_callback_add(mWebView, "policy,response,decide",
 881                                  &TizenWebEngineChromium::OnResponsePolicyDecided,
 882                                  this);
 883   evas_object_smart_callback_add(mWebView, "policy,navigation,decide",
 884                                  &TizenWebEngineChromium::OnNavigationPolicyDecided,
 885                                  this);
 886   evas_object_smart_callback_add(mWebView, "request,certificate,confirm",
 887                                  &TizenWebEngineChromium::OnCertificateConfirmed,
 888                                  this);
 889   evas_object_smart_callback_add(mWebView, "ssl,certificate,changed",
 890                                  &TizenWebEngineChromium::OnSslCertificateChanged,
 891                                  this);
 892   evas_object_smart_callback_add(mWebView, "contextmenu,show",
 893                                  &TizenWebEngineChromium::OnContextMenuShown,
 894                                  this);
 895   evas_object_smart_callback_add(mWebView, "contextmenu,hide",
 896                                  &TizenWebEngineChromium::OnContextMenuHidden,
 897                                  this);
 898
 899   ewk_view_authentication_callback_set(mWebView, &TizenWebEngineChromium::OnAuthenticationChallenged, this);
 900
 901   evas_object_resize(mWebView, mWidth, mHeight);
 902   evas_object_show(mWebView);
 903 }
 904
 905 bool TizenWebEngineChromium::FeedMouseEvent(const TouchEvent& touch)
 906 {
 907   Ewk_Mouse_Button_Type type = (Ewk_Mouse_Button_Type)0;
 908   switch (touch.GetMouseButton(0))
 909   {
 910     case MouseButton::PRIMARY:
 911     {
 912       type = EWK_Mouse_Button_Left;
 913       break;
 914     }
 915     case MouseButton::TERTIARY:
 916     {
 917       type = EWK_Mouse_Button_Middle;
 918       break;
 919     }
 920     case MouseButton::SECONDARY:
 921     {
 922       type = EWK_Mouse_Button_Right;
 923       break;
 924     }
 925     default:
 926     {
 927       break;
 928     }
 929   }
 930
 931   switch (touch.GetState(0))
 932   {
 933     case PointState::DOWN:
 934     {
 935       float x = touch.GetScreenPosition(0).x;
 936       float y = touch.GetScreenPosition(0).y;
 937       ewk_view_feed_mouse_down(mWebView, type, x, y);
 938       break;
 939     }
 940     case PointState::UP:
 941     {
 942       float x = touch.GetScreenPosition(0).x;
 943       float y = touch.GetScreenPosition(0).y;
 944       ewk_view_feed_mouse_up(mWebView, type, x, y);
 945       break;
 946     }
 947     case PointState::MOTION:
 948     {
 949       float x = touch.GetScreenPosition(0).x;
 950       float y = touch.GetScreenPosition(0).y;
 951       ewk_view_feed_mouse_move(mWebView, x, y);
 952       break;
 953     }
 954     default:
 955     {
 956       break;
 957     }
 958   }
 959   return false;
 960 }
 961
 962 bool TizenWebEngineChromium::FeedTouchEvent(const TouchEvent& touch)
 963 {
 964   Ewk_Touch_Event_Type type = EWK_TOUCH_START;
 965   Evas_Touch_Point_State state = EVAS_TOUCH_POINT_DOWN;
 966   switch (touch.GetState(0))
 967   {
 968     case PointState::DOWN:
 969     {
 970       type = EWK_TOUCH_START;
 971       state = EVAS_TOUCH_POINT_DOWN;
 972       break;
 973     }
 974     case PointState::UP:
 975     {
 976       type = EWK_TOUCH_END;
 977       state = EVAS_TOUCH_POINT_UP;
 978       break;
 979     }
 980     case PointState::MOTION:
 981     {
 982       type = EWK_TOUCH_MOVE;
 983       state = EVAS_TOUCH_POINT_MOVE;
 984       break;
 985     }
 986     case PointState::INTERRUPTED:
 987     {
 988       type = EWK_TOUCH_CANCEL;
 989       state = EVAS_TOUCH_POINT_CANCEL;
 990       break;
 991     }
 992     default:
 993     {
 994       break;
 995     }
 996   }
 997
 998   Eina_List* pointList = 0;
 999   Ewk_Touch_Point point;
1000   point.id = 0;
1001   point.x = touch.GetScreenPosition(0).x;
1002   point.y = touch.GetScreenPosition(0).y;
1003   point.state = state;
1004   pointList = eina_list_append(pointList, &point);
1005
1006   ewk_view_feed_touch_event(mWebView, type, pointList, 0);
1007   eina_list_free(pointList);
1008   return false;
1009 }
1010
1011 Dali::PixelData TizenWebEngineChromium::ConvertImageColorSpace(Evas_Object* image)
1012 {
1013   // color-space is argb8888.
1014   uint8_t* pixelBuffer = (uint8_t*)evas_object_image_data_get(image, false);
1015   if (!pixelBuffer)
1016   {
1017     return Dali::PixelData();
1018   }
1019
1020   int width = 0, height = 0;
1021   evas_object_image_size_get(image, &width, &height);
1022
1023   uint32_t bufferSize = width * height * 4;
1024   uint8_t* convertedBuffer = new uint8_t[bufferSize];
1025
1026   // convert the color-space to rgba8888.
1027   for (uint32_t i = 0; i < bufferSize; i += 4)
1028   {
1029     convertedBuffer[i] = pixelBuffer[i + 1];
1030     convertedBuffer[i + 1] = pixelBuffer[i + 2];
1031     convertedBuffer[i + 2] = pixelBuffer[i + 3];
1032     convertedBuffer[i + 3] = pixelBuffer[i];
1033   }
1034
1035   return Dali::PixelData::New(convertedBuffer, bufferSize, width, height,
1036                               Dali::Pixel::Format::RGBA8888,
1037                               Dali::PixelData::ReleaseFunction::DELETE_ARRAY);
1038 }
1039
1040 void TizenWebEngineChromium::OnFrameRendered(void* data, Evas_Object*, void* buffer)
1041 {
1042   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1043   pThis->UpdateImage(static_cast<tbm_surface_h>(buffer));
1044 }
1045
1046 void TizenWebEngineChromium::OnLoadStarted(void* data, Evas_Object*, void*)
1047 {
1048   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1049   pThis->LoadStarted();
1050 }
1051
1052 void TizenWebEngineChromium::OnLoadInProgress(void* data, Evas_Object*, void*)
1053 {
1054   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1055   pThis->LoadInProgress();
1056 }
1057
1058 void TizenWebEngineChromium::OnLoadFinished(void* data, Evas_Object*, void*)
1059 {
1060   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1061   pThis->LoadFinished();
1062 }
1063
1064 void TizenWebEngineChromium::OnLoadError(void* data, Evas_Object*, void* rawError)
1065 {
1066   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1067   Ewk_Error* error = static_cast<Ewk_Error*>(rawError);
1068   std::unique_ptr<Dali::WebEngineLoadError> loadError(new TizenWebEngineLoadError(error));
1069   pThis->LoadError(std::move(loadError));
1070 }
1071
1072 void TizenWebEngineChromium::OnUrlChanged(void* data, Evas_Object*, void* newUrl)
1073 {
1074   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1075   std::string url = static_cast<char*>(newUrl);
1076   pThis->UrlChanged(url);
1077 }
1078
1079 void TizenWebEngineChromium::OnConsoleMessageReceived(void* data, Evas_Object*, void* eventInfo)
1080 {
1081   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1082   Ewk_Console_Message* message = static_cast<Ewk_Console_Message*>(eventInfo);
1083   std::unique_ptr<Dali::WebEngineConsoleMessage> webConsoleMessage(new TizenWebEngineConsoleMessage(message));
1084   pThis->ConsoleMessageReceived(std::move(webConsoleMessage));
1085 }
1086
1087 void TizenWebEngineChromium::OnEdgeLeft(void* data, Evas_Object*, void*)
1088 {
1089   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1090   pThis->ScrollEdgeReached(Dali::WebEnginePlugin::ScrollEdge::LEFT);
1091 }
1092
1093 void TizenWebEngineChromium::OnEdgeRight(void* data, Evas_Object*, void*)
1094 {
1095   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1096   pThis->ScrollEdgeReached(Dali::WebEnginePlugin::ScrollEdge::RIGHT);
1097 }
1098
1099 void TizenWebEngineChromium::OnEdgeTop(void* data, Evas_Object*, void*)
1100 {
1101   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1102   pThis->ScrollEdgeReached(Dali::WebEnginePlugin::ScrollEdge::TOP);
1103 }
1104
1105 void TizenWebEngineChromium::OnEdgeBottom(void* data, Evas_Object*, void*)
1106 {
1107   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1108   pThis->ScrollEdgeReached(Dali::WebEnginePlugin::ScrollEdge::BOTTOM);
1109 }
1110
1111 void TizenWebEngineChromium::OnFormRepostDecided(void* data, Evas_Object*, void* eventInfo)
1112 {
1113   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1114   Ewk_Form_Repost_Decision_Request* decisionRequest = static_cast<Ewk_Form_Repost_Decision_Request*>(eventInfo);
1115   std::unique_ptr<Dali::WebEngineFormRepostDecision> webDecisionRequest(new TizenWebEngineFormRepostDecision(decisionRequest));
1116   pThis->RequestFormRepostDecided(std::move(webDecisionRequest));
1117 }
1118
1119 void TizenWebEngineChromium::OnResponsePolicyDecided(void* data, Evas_Object*, void* policy)
1120 {
1121   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1122   Ewk_Policy_Decision* policyDecision = static_cast<Ewk_Policy_Decision*>(policy);
1123   std::unique_ptr<Dali::WebEnginePolicyDecision> webPolicyDecision(new TizenWebEnginePolicyDecision(policyDecision));
1124   pThis->ResponsePolicyDecided(std::move(webPolicyDecision));
1125 }
1126
1127 void TizenWebEngineChromium::OnNavigationPolicyDecided(void* data, Evas_Object*, void* policy)
1128 {
1129   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1130   Ewk_Policy_Decision* policyDecision = static_cast<Ewk_Policy_Decision*>(policy);
1131   std::unique_ptr<Dali::WebEnginePolicyDecision> webPolicyDecision(new TizenWebEnginePolicyDecision(policyDecision));
1132   pThis->NavigationPolicyDecided(std::move(webPolicyDecision));
1133 }
1134
1135 void TizenWebEngineChromium::OnCertificateConfirmed(void* data, Evas_Object*, void* eventInfo)
1136 {
1137   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1138   Ewk_Certificate_Policy_Decision* policyDecision = static_cast<Ewk_Certificate_Policy_Decision*>(eventInfo);
1139   std::unique_ptr<Dali::WebEngineCertificate> webPolicyDecision(new TizenWebEngineCertificate(policyDecision));
1140   pThis->CertificateConfirmed(std::move(webPolicyDecision));
1141 }
1142
1143 void TizenWebEngineChromium::OnSslCertificateChanged(void* data, Evas_Object*, void* eventInfo)
1144 {
1145   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1146   Ewk_Certificate_Info* info = static_cast<Ewk_Certificate_Info*>(eventInfo);
1147   std::unique_ptr<Dali::WebEngineCertificate> webCertiInfo(new TizenWebEngineCertificate(info));
1148   pThis->SslCertificateChanged(std::move(webCertiInfo));
1149 }
1150
1151 void TizenWebEngineChromium::OnContextMenuShown(void* data, Evas_Object*, void* eventInfo)
1152 {
1153   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1154   Ewk_Context_Menu* menu = (Ewk_Context_Menu*)eventInfo;
1155   std::unique_ptr<Dali::WebEngineContextMenu> contextMenu(new TizenWebEngineContextMenu(menu));
1156   pThis->ContextMenuShown(std::move(contextMenu));
1157 }
1158
1159 void TizenWebEngineChromium::OnContextMenuHidden(void* data, Evas_Object*, void* eventInfo)
1160 {
1161   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1162   Ewk_Context_Menu* menu = (Ewk_Context_Menu*)eventInfo;
1163   std::unique_ptr<Dali::WebEngineContextMenu> contextMenu(new TizenWebEngineContextMenu(menu));
1164   pThis->ContextMenuHidden(std::move(contextMenu));
1165 }
1166
1167 void TizenWebEngineChromium::OnAuthenticationChallenged(Evas_Object*, Ewk_Auth_Challenge* authChallenge, void* data)
1168 {
1169   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1170   std::unique_ptr<Dali::WebEngineHttpAuthHandler> authHandler(new TizenWebEngineHttpAuthHandler(authChallenge));
1171   pThis->AuthenticationChallenged(std::move(authHandler));
1172 }
1173
1174 void TizenWebEngineChromium::OnEvaluateJavaScript(Evas_Object* o, const char* result, void* data)
1175 {
1176   auto plugin = WebEngineManager::Get().Find(o);
1177   if (plugin)
1178   {
1179     auto pThis = static_cast<TizenWebEngineChromium*>(plugin);
1180     pThis->RunJavaScriptEvaluationResultHandler((size_t)data, result);
1181   }
1182 }
1183
1184 void TizenWebEngineChromium::OnJavaScriptMessage(Evas_Object* o, Ewk_Script_Message message)
1185 {
1186   auto plugin = WebEngineManager::Get().Find(o);
1187   if (plugin)
1188   {
1189     auto pThis = static_cast<TizenWebEngineChromium*>(plugin);
1190     pThis->RunJavaScriptMessageHandler(message.name, static_cast<char*>(message.body));
1191   }
1192 }
1193
1194 Eina_Bool TizenWebEngineChromium::OnJavaScriptAlert(Evas_Object* o, const char* alert_text, void* data)
1195 {
1196   bool result = false;
1197   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1198   if (pThis)
1199   {
1200     result = pThis->JavaScriptAlert(const_cast<char*>(alert_text));
1201   }
1202   return result;
1203 }
1204
1205 Eina_Bool TizenWebEngineChromium::OnJavaScriptConfirm(Evas_Object* o, const char* message, void* data)
1206 {
1207   bool result = false;
1208   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1209   if (pThis)
1210   {
1211     result = pThis->JavaScriptConfirm(const_cast<char*>(message));
1212   }
1213   return result;
1214 }
1215
1216 Eina_Bool TizenWebEngineChromium::OnJavaScriptPrompt(Evas_Object* o, const char* message, const char* default_value, void* data)
1217 {
1218   bool result = false;
1219   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1220   if (pThis)
1221   {
1222     result = pThis->JavaScriptPrompt(const_cast<char*>(message), const_cast<char*>(default_value));
1223   }
1224   return result;
1225 }
1226
1227 void TizenWebEngineChromium::OnHitTestCreated(Evas_Object*, int x, int y, int hitTestMode, Ewk_Hit_Test* hitTest, void* data)
1228 {
1229   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1230   Evas* evas = ecore_evas_get(WebEngineManager::Get().GetWindow());
1231   std::unique_ptr<Dali::WebEngineHitTest> webHitTest(new TizenWebEngineHitTest(hitTest, evas, false));
1232   pThis->HitTestCreated(std::move(webHitTest));
1233 }
1234
1235 void TizenWebEngineChromium::OnScreenshotCaptured(Evas_Object* image, void* data)
1236 {
1237   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1238   Dali::PixelData pixelData = ConvertImageColorSpace(image);
1239   pThis->ScreenshotCaptured(pixelData);
1240 }
1241
1242 void TizenWebEngineChromium::OnVideoPlaying(Evas_Object*, Eina_Bool isPlaying, void* data)
1243 {
1244   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1245   pThis->VideoPlaying(isPlaying);
1246 }
1247
1248 void TizenWebEngineChromium::OnPlainTextReceived(Evas_Object* o, const char* plainText, void* data)
1249 {
1250   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1251   std::string resultText;
1252
1253   if (plainText != nullptr)
1254   {
1255     resultText = std::string(plainText);
1256   }
1257
1258   pThis->PlainTextRecieved(resultText);
1259 }
1260
1261 Eina_Bool TizenWebEngineChromium::OnGeolocationPermission(Evas_Object*, Ewk_Geolocation_Permission_Request* request, void* data)
1262 {
1263   auto pThis = static_cast<TizenWebEngineChromium*>(data);
1264   const Ewk_Security_Origin* securityOrigin = ewk_geolocation_permission_request_origin_get(request);
1265   std::string host = ewk_security_origin_host_get(securityOrigin);
1266   std::string protocol = ewk_security_origin_protocol_get(securityOrigin);
1267   return pThis->GeolocationPermission(host, protocol);
1268 }
1269
1270 void TizenWebEngineChromium::UpdateImage(tbm_surface_h buffer)
1271 {
1272   if (!buffer)
1273   {
1274     return;
1275   }
1276   Any source(buffer);
1277   mDaliImageSrc->SetSource(source);
1278   Dali::Stage::GetCurrent().KeepRendering(0.0f);
1279   mFrameRenderedSignal.Emit();
1280 }
1281
1282 void TizenWebEngineChromium::LoadStarted()
1283 {
1284   DALI_LOG_RELEASE_INFO("#LoadStarted : %s\n", GetUrl().c_str());
1285   ExecuteCallback(mLoadStartedCallback, GetUrl());
1286 }
1287
1288 void TizenWebEngineChromium::LoadInProgress()
1289 {
1290   DALI_LOG_RELEASE_INFO("#LoadInProgress : %s\n", GetUrl().c_str());
1291   ExecuteCallback(mLoadInProgressCallback, "");
1292 }
1293
1294 void TizenWebEngineChromium::LoadFinished()
1295 {
1296   DALI_LOG_RELEASE_INFO("#LoadFinished : %s\n", GetUrl().c_str());
1297   ExecuteCallback(mLoadFinishedCallback, GetUrl());
1298 }
1299
1300 void TizenWebEngineChromium::LoadError(std::unique_ptr<Dali::WebEngineLoadError> error)
1301 {
1302   DALI_LOG_RELEASE_INFO("#LoadError : %s\n", error->GetUrl().c_str());
1303   ExecuteCallback(mLoadErrorCallback, std::move(error));
1304 }
1305
1306 void TizenWebEngineChromium::ScrollEdgeReached(Dali::WebEnginePlugin::ScrollEdge edge)
1307 {
1308   DALI_LOG_RELEASE_INFO("#ScrollEdgeReached : %d\n", edge);
1309   ExecuteCallback(mScrollEdgeReachedCallback, edge);
1310 }
1311
1312 void TizenWebEngineChromium::UrlChanged(const std::string& url)
1313 {
1314   DALI_LOG_RELEASE_INFO("#UrlChanged : %s\n", url.c_str());
1315   ExecuteCallback(mUrlChangedCallback, url);
1316 }
1317
1318 void TizenWebEngineChromium::RequestFormRepostDecided(std::unique_ptr<Dali::WebEngineFormRepostDecision> decision)
1319 {
1320   DALI_LOG_RELEASE_INFO("#FormRepostDecidedRequest\n");
1321   ExecuteCallback(mFormRepostDecidedCallback, std::move(decision));
1322 }
1323
1324 void TizenWebEngineChromium::ConsoleMessageReceived(std::unique_ptr<Dali::WebEngineConsoleMessage> message)
1325 {
1326   DALI_LOG_RELEASE_INFO("#ConsoleMessageReceived : %s\n", message->GetSource().c_str());
1327   ExecuteCallback(mConsoleMessageReceivedCallback, std::move(message));
1328 }
1329
1330 void TizenWebEngineChromium::ResponsePolicyDecided(std::unique_ptr<Dali::WebEnginePolicyDecision> decision)
1331 {
1332   DALI_LOG_RELEASE_INFO("#ResponsePolicyDecided.\n");
1333   ExecuteCallback(mResponsePolicyDecidedCallback, std::move(decision));
1334 }
1335
1336 void TizenWebEngineChromium::NavigationPolicyDecided(std::unique_ptr<Dali::WebEnginePolicyDecision> decision)
1337 {
1338   DALI_LOG_RELEASE_INFO("#NavigationPolicyDecided.\n");
1339   ExecuteCallback(mNavigationPolicyDecidedCallback, std::move(decision));
1340 }
1341
1342 void TizenWebEngineChromium::CertificateConfirmed(std::unique_ptr<Dali::WebEngineCertificate> confirm)
1343 {
1344   DALI_LOG_RELEASE_INFO("#CertificateConfirmed.\n");
1345   ExecuteCallback(mCertificateConfirmedCallback, std::move(confirm));
1346 }
1347
1348 void TizenWebEngineChromium::SslCertificateChanged(std::unique_ptr<Dali::WebEngineCertificate> info)
1349 {
1350   DALI_LOG_RELEASE_INFO("#SslCertificateChanged.\n");
1351   ExecuteCallback(mSslCertificateChangedCallback, std::move(info));
1352 }
1353
1354 void TizenWebEngineChromium::AuthenticationChallenged(std::unique_ptr<Dali::WebEngineHttpAuthHandler> handler)
1355 {
1356   DALI_LOG_RELEASE_INFO("#AuthenticationChallenged.\n");
1357   ExecuteCallback(mHttpAuthHandlerCallback, std::move(handler));
1358 }
1359
1360 void TizenWebEngineChromium::ContextMenuShown(std::unique_ptr<Dali::WebEngineContextMenu> menu)
1361 {
1362   DALI_LOG_RELEASE_INFO("#ContextMenuShown.\n");
1363   ExecuteCallback(mContextMenuShownCallback, std::move(menu));
1364 }
1365
1366 void TizenWebEngineChromium::ContextMenuHidden(std::unique_ptr<Dali::WebEngineContextMenu> menu)
1367 {
1368   DALI_LOG_RELEASE_INFO("#ContextMenuHidden.\n");
1369   ExecuteCallback(mContextMenuHiddenCallback, std::move(menu));
1370 }
1371
1372 } // namespace Plugin
1373 } // namespace Dali
1374
1375 extern "C" DALI_EXPORT_API Dali::WebEnginePlugin* CreateWebEnginePlugin()
1376 {
1377   return new Dali::Plugin::TizenWebEngineChromium();
1378 }
1379
1380 extern "C" DALI_EXPORT_API void DestroyWebEnginePlugin(Dali::WebEnginePlugin* plugin)
1381 {
1382   if (plugin)
1383   {
1384     delete plugin;
1385   }
1386 }