tizen_src/ewk/efl_integration/public/ewk_view.cc

   1 /*
   2  * Copyright (C) 2009-2010 ProFUSION embedded systems
   3  * Copyright (C) 2009-2016 Samsung Electronics. All rights reserved.
   4  * Copyright (C) 2012 Intel Corporation
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public License
  17  * along with this library; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  */
  20
  21 #include "ewk_view_product.h"
  22
  23 #include <Evas.h>
  24 #include <algorithm>
  25
  26 #include "authentication_challenge_popup.h"
  27 #include "base/trace_event/ttrace.h"
  28 #include "content/public/browser/navigation_controller.h"
  29 #include "cookie_manager.h"
  30 #include "eweb_view.h"
  31 #include "geolocation_permission_popup.h"
  32 #include "notification_permission_popup.h"
  33 #include "private/ewk_back_forward_list_private.h"
  34 #include "private/ewk_context_private.h"
  35 #include "private/ewk_frame_private.h"
  36 #include "private/ewk_history_private.h"
  37 #include "private/ewk_hit_test_private.h"
  38 #include "private/ewk_notification_private.h"
  39 #include "private/ewk_private.h"
  40 #include "private/ewk_quota_permission_request_private.h"
  41 #include "private/ewk_view_private.h"
  42 #include "public/ewk_back_forward_list.h"
  43 #include "public/ewk_context.h"
  44 #include "public/ewk_enums_internal.h"
  45 #include "public/ewk_settings.h"
  46 #include "third_party/blink/public/common/page/page_zoom.h"
  47 #include "third_party/blink/public/common/web_preferences/web_preferences.h"
  48 #include "ui/events/gesture_detection/gesture_configuration.h"
  49 #include "url/gurl.h"
  50 #include "usermedia_permission_popup.h"
  51 #include "web_contents_delegate_efl.h"
  52
  53 #if defined(TIZEN_WEB_SPEECH_RECOGNITION)
  54 #include "content/browser/speech/tts_platform_impl_tizen.h"
  55 #endif
  56 #if defined(TIZEN_VIDEO_HOLE)
  57 #include "tizen_src/chromium_impl/media/base/tizen/video_plane_controller.h"
  58 #endif
  59
  60 static Eina_Bool _ewk_view_default_user_media_permission(
  61     Evas_Object*, Ewk_User_Media_Permission_Request*, void*);
  62
  63 static Eina_Bool _ewk_view_default_geolocation_permission(
  64     Evas_Object*, Ewk_Geolocation_Permission_Request*, void*);
  65
  66 static Eina_Bool _ewk_view_default_notification_permission(
  67     Evas_Object*, Ewk_Notification_Permission_Request*, void*);
  68
  69 static void _ewk_view_default_authentication(
  70     Evas_Object*, Ewk_Auth_Challenge*, void*);
  71
  72 Eina_Bool ewk_view_smart_class_set(Ewk_View_Smart_Class* api)
  73 {
  74   EINA_SAFETY_ON_NULL_RETURN_VAL(api, false);
  75   return InitSmartClassInterface(*api);
  76 }
  77
  78 // TODO: Evas_Object *ewk_view_smart_add(Evas *e, Evas_Smart *smart, Ewk_Context *context, Ewk_Page_Group *pageGroup)
  79
  80 Evas_Object* ewk_view_add_with_session_data(Evas* canvas, const char* data, unsigned length)
  81 {
  82   EINA_SAFETY_ON_NULL_RETURN_VAL(canvas, NULL);
  83
  84   Evas_Object* ret = ewk_view_add(canvas);
  85
  86   EWebView* webView = GetEWebViewFromEwkView(ret);
  87
  88   if (!webView || !data || !length)
  89     return ret;
  90
  91   if (webView->RestoreFromSessionData(data, length))
  92     return ret;
  93
  94   evas_object_del(ret);
  95
  96   return NULL;
  97 }
  98
  99 Evas_Object* ewk_view_add_with_context(Evas* e, Ewk_Context* context)
 100 {
 101   EINA_SAFETY_ON_NULL_RETURN_VAL(context, 0);
 102   Evas_Object* ewk_view = CreateWebViewAsEvasObject(context, e);
 103   LOG(INFO) << "evas: " << e << ", context: " << context << ", ewk_view:" << ewk_view;
 104   if (ewk_view) {
 105 #if !BUILDFLAG(IS_TIZEN_TV)
 106     ewk_view_user_media_permission_callback_set(ewk_view,
 107         _ewk_view_default_user_media_permission, 0);
 108 #endif
 109     ewk_view_geolocation_permission_callback_set(ewk_view,
 110         _ewk_view_default_geolocation_permission, 0);
 111     ewk_view_notification_permission_callback_set(ewk_view,
 112         _ewk_view_default_notification_permission, 0);
 113     ewk_view_authentication_callback_set(ewk_view,
 114         _ewk_view_default_authentication, nullptr);
 115   }
 116
 117   return ewk_view;
 118 }
 119
 120 Evas_Object* ewk_view_add(Evas* e)
 121 {
 122   EINA_SAFETY_ON_NULL_RETURN_VAL(e, NULL);
 123   // TODO: shouldn't this function create new EWebContext for each new EWebView?
 124   // when using default context like that it makes unclear who should release
 125   // default web context. It won't be released by destroyed eweb_view because
 126   // ewk_context_default_get does AddRef
 127   Ewk_Context* context = ewk_context_default_get();
 128   LOG(INFO) << "evas: " << e << ", context: " << context;
 129   return ewk_view_add_with_context(e, context);
 130 }
 131
 132 Evas_Object* ewk_view_add_in_incognito_mode(Evas* e)
 133 {
 134   EINA_SAFETY_ON_NULL_RETURN_VAL(e, nullptr);
 135   Ewk_Context* context = Ewk_Context::IncognitoContext();
 136   LOG(INFO) << "evas: " << e << ", context: " << context;
 137   EINA_SAFETY_ON_NULL_RETURN_VAL(context, nullptr);
 138   return ewk_view_add_with_context(e, context);
 139 }
 140
 141 Ewk_Context *ewk_view_context_get(const Evas_Object *view)
 142 {
 143   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, 0);
 144   return static_cast<Ewk_Context*>(impl->context());
 145 }
 146
 147 Eina_Bool ewk_view_url_set(Evas_Object* view, const char* url_string)
 148 {
 149   TTRACE_WEB("ewk_view_url_set url: %s", url_string);
 150   LOG(INFO) << "view: " << view << ", url: " << url_string;
 151   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 152   EINA_SAFETY_ON_NULL_RETURN_VAL(url_string, false);
 153   GURL url(url_string);
 154   impl->SetURL(url, true);
 155   return true;
 156 }
 157
 158 const char* ewk_view_url_get(const Evas_Object* view)
 159 {
 160   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, 0);
 161   return impl->GetURL().possibly_invalid_spec().c_str();
 162 }
 163
 164 const char* ewk_view_original_url_get(const Evas_Object* view)
 165 {
 166   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, 0);
 167   return impl->GetOriginalURL().possibly_invalid_spec().c_str();
 168 }
 169
 170 Eina_Bool ewk_view_reload(Evas_Object *view)
 171 {
 172   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 173   LOG(INFO) << "view: " << view;
 174   impl->Reload();
 175   return true;
 176 }
 177
 178
 179 Eina_Bool ewk_view_reload_bypass_cache(Evas_Object *view)
 180 {
 181   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 182   impl->ReloadBypassingCache();
 183   return true;
 184 }
 185
 186 Eina_Bool ewk_view_stop(Evas_Object* view)
 187 {
 188   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 189   impl->Stop();
 190   return true;
 191 }
 192
 193
 194 Ewk_Settings *ewk_view_settings_get(const Evas_Object *ewkView)
 195 {
 196   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl,0);
 197   return impl->GetSettings();
 198 }
 199
 200 const char* ewk_view_title_get(const Evas_Object* view)
 201 {
 202   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, 0);
 203   return impl->GetTitle();
 204 }
 205
 206 double ewk_view_load_progress_get(const Evas_Object* view)
 207 {
 208   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, -1);
 209   return impl->GetProgressValue();
 210 }
 211
 212 Eina_Bool ewk_view_scale_set(Evas_Object* view, double scale_factor, int x, int y)
 213 {
 214   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 215   impl->SetScale(scale_factor);
 216   impl->SetScroll(x, y);
 217   LOG(INFO) << "view: " << view << ", scale_factor: " << scale_factor << ", x:" << x << ", y:" << y;
 218   return EINA_TRUE;
 219 }
 220
 221 void ewk_view_scale_changed_callback_set(
 222     Evas_Object* view,
 223     Ewk_View_Scale_Changed_Callback callback,
 224     void* user_data) {
 225   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 226   impl->SetScaleChangedCallback(callback, user_data);
 227 }
 228
 229 double ewk_view_scale_get(const Evas_Object *view)
 230 {
 231   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, -1);
 232   return impl->GetScale();
 233 }
 234
 235 Eina_Bool ewk_view_back(Evas_Object *view)
 236 {
 237   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 238   LOG(INFO) << "view: " << view;
 239   return impl->GoBack();
 240 }
 241
 242 Eina_Bool ewk_view_forward(Evas_Object *view)
 243 {
 244   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 245   LOG(INFO) << "view: " << view;
 246   return impl->GoForward();
 247 }
 248
 249 Eina_Bool ewk_view_back_possible(Evas_Object *view)
 250 {
 251   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 252   return impl->CanGoBack();
 253 }
 254
 255 Eina_Bool ewk_view_forward_possible(Evas_Object *view)
 256 {
 257   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 258   return impl->CanGoForward();
 259 }
 260
 261 Eina_Bool ewk_view_web_login_request(Evas_Object* ewkView)
 262 {
 263   LOG_EWK_API_MOCKUP();
 264   return false;
 265 }
 266
 267 Eina_Bool ewk_view_html_string_load(Evas_Object* view, const char* html, const char* base_uri, const char* unreachable_uri)
 268 {
 269   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 270   EINA_SAFETY_ON_NULL_RETURN_VAL(html, EINA_FALSE);
 271   LOG(INFO) << "view: " << view;
 272   impl->LoadHTMLString(html, base_uri, unreachable_uri);
 273   return EINA_TRUE;
 274 }
 275
 276 Eina_Bool ewk_view_mouse_events_enabled_set(Evas_Object *view, Eina_Bool enabled)
 277 {
 278   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 279
 280   impl->SetMouseEventsEnabled(!!enabled);
 281
 282   return true;
 283 }
 284
 285 Eina_Bool ewk_view_mouse_events_enabled_get(const Evas_Object *view)
 286 {
 287   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 288
 289   return impl->MouseEventsEnabled();
 290 }
 291
 292 Eina_Bool ewk_view_color_picker_color_set(Evas_Object* ewkView, int r, int g, int b, int a)
 293 {
 294   LOG_EWK_API_MOCKUP();
 295   return false;
 296 }
 297
 298 double ewk_view_text_zoom_get(const Evas_Object* view)
 299 {
 300   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, -1.0);
 301   return impl->GetTextZoomFactor();
 302 }
 303
 304 Eina_Bool ewk_view_text_zoom_set(Evas_Object* view, double text_zoom_level)
 305 {
 306   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 307   if (ewk_settings_text_zoom_enabled_get(ewk_view_settings_get(view))) {
 308    impl->SetTextZoomFactor(text_zoom_level);
 309    return true;
 310   }
 311   return false;
 312 }
 313
 314 void ewk_view_not_found_error_page_load(Evas_Object* ewkView, const char* errorUrl)
 315 {
 316   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 317   impl->LoadNotFoundErrorPage(std::string(errorUrl));
 318 }
 319
 320 void ewk_view_scale_range_get(Evas_Object* view, double* min_scale, double* max_scale)
 321 {
 322   if (!min_scale && !max_scale)
 323     return;
 324
 325   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 326   impl->GetPageScaleRange(min_scale, max_scale);
 327 }
 328
 329 void ewk_view_suspend(Evas_Object* ewkView)
 330 {
 331   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 332   LOG(INFO) << "view: " << ewkView;
 333   impl->Suspend();
 334 }
 335
 336 void ewk_view_resume(Evas_Object* ewkView)
 337 {
 338   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 339   impl->Resume();
 340 }
 341
 342 Eina_Bool ewk_view_url_request_set(Evas_Object* ewkView, const char* url, Ewk_Http_Method method, Eina_Hash* headers, const char* body)
 343 {
 344   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 345   EINA_SAFETY_ON_NULL_RETURN_VAL(url, EINA_FALSE);
 346   content::NavigationController::LoadURLType loadtype;
 347   switch (method) {
 348   case EWK_HTTP_METHOD_GET:
 349     loadtype = content::NavigationController::LOAD_TYPE_DEFAULT;
 350     break;
 351   case EWK_HTTP_METHOD_POST:
 352     loadtype = content::NavigationController::LOAD_TYPE_HTTP_POST;
 353     break;
 354   default:
 355     LOG(ERROR) << "Not supported HTTP Method.";
 356     return EINA_FALSE;
 357   }
 358
 359   impl->UrlRequestSet(url, loadtype, headers, body);
 360   return EINA_TRUE;
 361 }
 362
 363 Eina_Bool ewk_view_plain_text_set(Evas_Object* view, const char* plain_text)
 364 {
 365   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 366   EINA_SAFETY_ON_NULL_RETURN_VAL(plain_text, EINA_FALSE);
 367   impl->LoadPlainTextString(plain_text);
 368   return EINA_TRUE;
 369 }
 370
 371 Eina_Bool ewk_view_contents_set(Evas_Object* view, const char* contents, size_t contents_size, char* mime_type, char* encoding, char* base_uri)
 372 {
 373   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 374   EINA_SAFETY_ON_NULL_RETURN_VAL(contents, EINA_FALSE);
 375   impl->LoadData(contents, contents_size, mime_type, encoding, base_uri);
 376   return EINA_TRUE;
 377 }
 378
 379 Eina_Bool ewk_view_html_contents_set(Evas_Object* view, const char* html, const char* base_uri)
 380 {
 381   return ewk_view_html_string_load(view, html, base_uri, NULL);
 382 }
 383
 384 Eina_Bool ewk_view_page_visibility_state_set(Evas_Object* ewkView, Ewk_Page_Visibility_State page_visibility_state, Eina_Bool initial_state)
 385 {
 386   // TODO: Should we send initial_state to |Page::setVisibilityState()|?.
 387   // isInitialState parameter seems be true only in the constructor of WebViewImpl.
 388   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 389
 390   return impl->SetPageVisibility(page_visibility_state);
 391 }
 392
 393 Eina_Bool ewk_view_user_agent_set(Evas_Object* ewkView, const char* user_agent)
 394 {
 395   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 396   LOG(INFO) << "view: " << ewkView << ", user_agent: " << user_agent;
 397   return impl->SetUserAgent(user_agent);
 398 }
 399
 400 const char* ewk_view_user_agent_get(const Evas_Object* ewkView)
 401 {
 402   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, 0);
 403   return impl->GetUserAgent();
 404 }
 405
 406 Eina_Bool ewk_view_application_name_for_user_agent_set(Evas_Object* ewkView, const char* application_name)
 407 {
 408   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 409   return impl->SetUserAgentAppName(application_name);
 410 }
 411
 412 const char* ewk_view_application_name_for_user_agent_get(const Evas_Object* ewkView)
 413 {
 414   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, 0);
 415   return eina_stringshare_add(impl->GetUserAgentAppName());
 416 }
 417
 418 Eina_Bool ewk_view_custom_header_add(const Evas_Object* ewkView, const char* name, const char* value)
 419 {
 420   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 421   EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
 422   EINA_SAFETY_ON_NULL_RETURN_VAL(value, EINA_FALSE);
 423   EINA_SAFETY_ON_NULL_RETURN_VAL(impl->context(),EINA_FALSE);
 424   return impl->context()->HTTPCustomHeaderAdd(name, value);
 425 }
 426
 427 Eina_Bool ewk_view_custom_header_remove(const Evas_Object* ewkView, const char* name)
 428 {
 429   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 430   EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
 431   EINA_SAFETY_ON_NULL_RETURN_VAL(impl->context(),EINA_FALSE);
 432   return impl->context()->HTTPCustomHeaderRemove(name);
 433
 434 }
 435
 436 Eina_Bool ewk_view_custom_header_clear(const Evas_Object* ewkView)
 437 {
 438   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 439   EINA_SAFETY_ON_NULL_RETURN_VAL(impl->context(),EINA_FALSE);
 440   impl->context()->HTTPCustomHeaderClear();
 441   return EINA_TRUE;
 442 }
 443
 444
 445 Eina_Bool ewk_view_visibility_set(Evas_Object* view, Eina_Bool enable)
 446 {
 447   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 448   LOG(INFO) << "view: " << view << ", enable:" << (bool)enable;
 449   return impl->SetVisibility(enable);
 450 }
 451
 452 Evas_Object* ewk_view_screenshot_contents_get(const Evas_Object* view, Eina_Rectangle view_area, float scale_factor, Evas* canvas)
 453 {
 454   EINA_SAFETY_ON_NULL_RETURN_VAL(canvas, NULL);
 455   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, NULL);
 456   LOG(INFO) << "view: " << view;
 457   return impl->GetSnapshot(view_area, scale_factor);
 458 }
 459
 460 Eina_Bool ewk_view_screenshot_contents_get_async(const Evas_Object* view, Eina_Rectangle view_area,
 461         float scale_factor, Evas* canvas, Ewk_Web_App_Screenshot_Captured_Callback callback, void* user_data)
 462 {
 463   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
 464   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 465   LOG(INFO) << "view: " << view;
 466   return impl->GetSnapshotAsync(view_area, callback, user_data, scale_factor)
 467              ? EINA_TRUE
 468              : EINA_FALSE;
 469 }
 470
 471 unsigned int ewk_view_inspector_server_start(Evas_Object* ewkView, unsigned int port)
 472 {
 473   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 474   LOG(INFO) << "view: " << ewkView << ", port:" << port;
 475   return impl->StartInspectorServer(port);
 476 }
 477
 478 Eina_Bool ewk_view_inspector_server_stop(Evas_Object* ewkView)
 479 {
 480   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 481   LOG(INFO) << "view: " << ewkView;
 482   return impl->StopInspectorServer();
 483 }
 484
 485 Eina_Bool ewk_view_cache_image_get(const Evas_Object* o, const char* image_url, Evas* canvas, Ewk_View_Cache_Image_Get_Callback callback, void* user_data)
 486 {
 487   LOG_EWK_API_MOCKUP();
 488   return false;
 489 }
 490
 491 void ewk_view_scroll_by(Evas_Object* ewkView, int deltaX, int deltaY)
 492 {
 493   int x, y;
 494   LOG(INFO) << "view: " << ewkView << ", deltaX:" << deltaX << ", deltaY:" << deltaY;
 495   if (EINA_TRUE == ewk_view_scroll_pos_get(ewkView, &x, &y)) {
 496     ewk_view_scroll_set(ewkView, x + deltaX, y + deltaY);
 497   }
 498 }
 499
 500 Eina_Bool ewk_view_scroll_pos_get(Evas_Object* ewkView, int* x, int* y)
 501 {
 502   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 503   return impl->GetScrollPosition(x, y);
 504 }
 505
 506 Eina_Bool ewk_view_scroll_set(Evas_Object* view, int x, int y)
 507 {
 508   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 509   LOG(INFO) << "view: " << view << ", x:" << x << ", y:" << y;
 510   impl->SetScroll(x, y);
 511
 512   return EINA_TRUE;
 513 }
 514
 515 Eina_Bool ewk_view_scroll_size_get(const Evas_Object* view, int* width, int* height)
 516 {
 517   if (width)
 518     *width = 0;
 519   if (height)
 520     *height = 0;
 521   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 522   impl->GetScrollSize(width,height);
 523   return EINA_TRUE;
 524 }
 525
 526 void ewk_view_clear_tiles_on_hide_enabled_set(Evas_Object* ewkView, Eina_Bool enable)
 527 {
 528   LOG_EWK_API_MOCKUP();
 529 }
 530
 531 void ewk_view_password_confirm_popup_callback_set(Evas_Object* view, Ewk_View_Password_Confirm_Popup_Callback callback, void* user_data)
 532 {
 533   LOG_EWK_API_MOCKUP();
 534 }
 535
 536 void ewk_view_password_confirm_popup_reply(Evas_Object* ewkView, Ewk_Password_Popup_Option result)
 537 {
 538   LOG_EWK_API_MOCKUP();
 539 }
 540
 541 void ewk_view_javascript_alert_callback_set(Evas_Object* view, Ewk_View_JavaScript_Alert_Callback callback, void* user_data)
 542 {
 543   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 544   LOG(INFO) << "view: " << view;
 545   if (callback)
 546     impl->SetJavaScriptAlertCallback(callback, user_data);
 547 }
 548
 549 void ewk_view_javascript_alert_reply(Evas_Object* view)
 550 {
 551   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 552   LOG(INFO) << "view: " << view;
 553   impl->JavaScriptAlertReply();
 554 }
 555
 556 void ewk_view_javascript_confirm_callback_set(Evas_Object* view, Ewk_View_JavaScript_Confirm_Callback callback, void* user_data)
 557 {
 558   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 559   LOG(INFO) << "view: " << view;
 560   if (callback)
 561     impl->SetJavaScriptConfirmCallback(callback, user_data);
 562 }
 563
 564 void ewk_view_javascript_confirm_reply(Evas_Object* view, Eina_Bool result)
 565 {
 566   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 567   LOG(INFO) << "view: " << view;
 568   impl->JavaScriptConfirmReply(result);
 569 }
 570
 571 void ewk_view_javascript_prompt_callback_set(Evas_Object* view, Ewk_View_JavaScript_Prompt_Callback callback, void* user_data)
 572 {
 573   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 574   LOG(INFO) << "view: " << view;
 575   if (callback)
 576     impl->SetJavaScriptPromptCallback(callback, user_data);
 577 }
 578
 579 void ewk_view_javascript_prompt_reply(Evas_Object* view, const char* result)
 580 {
 581   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 582   LOG(INFO) << "view: " << view;
 583   impl->JavaScriptPromptReply(result);
 584 }
 585
 586 void ewk_view_before_unload_confirm_panel_callback_set(Evas_Object* ewkView, Ewk_View_Before_Unload_Confirm_Panel_Callback callback, void* userData)
 587 {
 588   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 589   EINA_SAFETY_ON_NULL_RETURN(callback);
 590   impl->SetBeforeUnloadConfirmPanelCallback(callback, userData);
 591 }
 592
 593 void ewk_view_before_unload_confirm_panel_reply(Evas_Object* ewkView, Eina_Bool result)
 594 {
 595   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 596   impl->ReplyBeforeUnloadConfirmPanel(result);
 597 }
 598
 599 Eina_Bool ewk_view_web_application_capable_get(Evas_Object* ewkView, Ewk_Web_App_Capable_Get_Callback callback, void* userData)
 600 {
 601   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 602   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
 603 #if !defined(EWK_BRINGUP)  // FIXME::M94 Bringup IPC to MOJO conversion in
 604                            // WebAppCapableGet
 605   return impl->WebAppCapableGet(callback, userData) ? EINA_TRUE : EINA_FALSE;
 606 #else
 607   return EINA_FALSE;
 608 #endif
 609 }
 610
 611 Eina_Bool ewk_view_web_application_icon_url_get(Evas_Object* ewkView, Ewk_Web_App_Icon_URL_Get_Callback callback, void* userData)
 612 {
 613   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 614   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
 615 #if !defined(EWK_BRINGUP)  // FIXME::M94 Bringup IPC to MOJO conversion in
 616                            // WebAppIconUrlGet
 617   return impl->WebAppIconUrlGet(callback, userData) ? EINA_TRUE : EINA_FALSE;
 618 #else
 619   return EINA_FALSE;
 620 #endif
 621 }
 622
 623 Eina_Bool ewk_view_web_application_icon_urls_get(Evas_Object* ewkView, Ewk_Web_App_Icon_URLs_Get_Callback callback, void* userData)
 624 {
 625   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 626   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
 627 #if !defined(EWK_BRINGUP)  // FIXME::M94 Bringup IPC to MOJO conversion in
 628                            // WebAppIconUrlsGet
 629   return impl->WebAppIconUrlsGet(callback, userData) ? EINA_TRUE : EINA_FALSE;
 630 #else
 631   return EINA_FALSE;
 632 #endif
 633 }
 634
 635 Eina_Bool ewk_view_command_execute(Evas_Object* view, const char* command, const char* value)
 636 {
 637   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 638   EINA_SAFETY_ON_NULL_RETURN_VAL(command, false);
 639   impl->ExecuteEditCommand(command, value);
 640   return true;
 641 }
 642
 643 Eina_Bool ewk_view_contents_size_get(const Evas_Object* view, Evas_Coord* width, Evas_Coord* height)
 644 {
 645   if (width)
 646     *width = 0;
 647   if (height)
 648     *height = 0;
 649
 650   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 651   Eina_Rectangle contents_size = impl->GetContentsSize();
 652
 653   if (width)
 654     *width = contents_size.w;
 655   if (height)
 656     *height = contents_size.h;
 657
 658   return EINA_TRUE;
 659 }
 660
 661 Eina_Bool ewk_view_contents_pdf_get(Evas_Object* view, int width, int height, const char* fileName)
 662 {
 663   EINA_SAFETY_ON_NULL_RETURN_VAL(fileName, EINA_FALSE);
 664   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 665   return impl->SaveAsPdf(width, height, fileName);
 666 }
 667
 668 Eina_Bool ewk_view_script_execute(Evas_Object* ewkView, const char* script, Ewk_View_Script_Execute_Callback callback, void* user_data)
 669 {
 670   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 671   EINA_SAFETY_ON_NULL_RETURN_VAL(script, false);
 672   LOG(INFO) << "view: " << ewkView;
 673   // callback can be null, so do not test it for null
 674   if (0 != strcmp(script, "")) //check for empty string
 675     return impl->ExecuteJavaScript(script, callback, user_data);
 676   return false;
 677 }
 678
 679 Eina_Bool ewk_view_plain_text_get(Evas_Object* view, Ewk_View_Plain_Text_Get_Callback callback, void* user_data)
 680 {
 681   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 682   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
 683   return (impl->PlainTextGet(callback, user_data));
 684 }
 685
 686 Eina_Bool ewk_view_mhtml_data_get(Evas_Object *view, Ewk_View_MHTML_Data_Get_Callback callback, void *user_data)
 687 {
 688   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
 689   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 690   return impl->GetMHTMLData(callback, user_data);
 691 }
 692
 693 Ewk_Hit_Test* ewk_view_hit_test_new(Evas_Object* ewkView, int x, int y, int hit_test_mode)
 694 {
 695   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, 0);
 696   return impl->RequestHitTestDataAt(x, y,
 697       static_cast<Ewk_Hit_Test_Mode>(hit_test_mode));
 698 }
 699
 700 Eina_Bool ewk_view_hit_test_request(Evas_Object* o, int x, int y, int hit_test_mode, Ewk_View_Hit_Test_Request_Callback callback, void* user_data)
 701 {
 702   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, EINA_FALSE);
 703   return impl->AsyncRequestHitTestDataAt(x, y, static_cast<Ewk_Hit_Test_Mode>(hit_test_mode), callback, user_data);
 704 }
 705
 706 Ewk_History* ewk_view_history_get(Evas_Object* ewkView)
 707 {
 708   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, NULL);
 709   return impl->GetBackForwardHistory();
 710 }
 711
 712 Eina_Bool ewk_view_notification_closed(Evas_Object* ewkView, Eina_List* notification_list)
 713 {
 714   return EINA_FALSE;
 715 }
 716
 717 Eina_Bool ewk_view_popup_menu_select(Evas_Object* ewkView, unsigned int selectedIndex)
 718 {
 719   LOG_EWK_API_MOCKUP();
 720   return false;
 721 }
 722
 723 Eina_Bool ewk_view_popup_menu_multiple_select(Evas_Object* ewkView, Eina_Inarray* changeList)
 724 {
 725   LOG_EWK_API_MOCKUP();
 726   return false;
 727 }
 728
 729 void ewk_view_orientation_send(Evas_Object* ewkView, int orientation)
 730 {
 731   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 732   LOG(INFO) << "view: " << ewkView << ", orientation:" << orientation;
 733   impl->SetOrientation(orientation);
 734 }
 735
 736 void ewk_view_encoding_custom_set(Evas_Object* ewkView, const char* encoding)
 737 {
 738   // Chromium does not support this feature hence the comment
 739   LOG_EWK_API_MOCKUP("Not Supported by chromium");
 740 }
 741
 742 Eina_Bool ewk_view_text_selection_range_get(const Evas_Object* view, Eina_Rectangle* left_rect, Eina_Rectangle* right_rect)
 743 {
 744   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 745   if (left_rect && right_rect && impl->GetSelectionRange(left_rect, right_rect)) {
 746     Evas_Coord x, y;
 747     evas_object_geometry_get(view, &x, &y, 0, 0);
 748     left_rect->x += x;
 749     left_rect->y += y;
 750     right_rect->x += x;
 751     right_rect->y += y;
 752     return true;
 753   }
 754   return false;
 755 }
 756
 757 Eina_Bool ewk_view_text_selection_clear(Evas_Object *view)
 758 {
 759   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 760   return impl->ClearSelection();
 761 }
 762
 763 const char* ewk_view_text_selection_text_get(Evas_Object* view)
 764 {
 765   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, NULL);
 766   return impl->CacheSelectedText();
 767 }
 768
 769 void ewk_view_focused_input_element_value_set(Evas_Object* ewkView, const char* value)
 770 {
 771   LOG_EWK_API_MOCKUP();
 772 }
 773
 774 const char* ewk_view_focused_input_element_value_get(Evas_Object* ewkView)
 775 {
 776   LOG_EWK_API_MOCKUP();
 777   return NULL;
 778 }
 779
 780 Eina_Bool ewk_view_horizontal_panning_hold_get(Evas_Object* ewkView) {
 781   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 782   return impl->GetHorizontalPanningHold();
 783 }
 784
 785 void ewk_view_horizontal_panning_hold_set(Evas_Object* ewkView,
 786                                           Eina_Bool hold) {
 787   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 788   impl->SetHorizontalPanningHold(hold);
 789 }
 790
 791 Eina_Bool ewk_view_vertical_panning_hold_get(Evas_Object* ewkView)
 792 {
 793   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 794   return impl->GetVerticalPanningHold();
 795 }
 796
 797 void ewk_view_vertical_panning_hold_set(Evas_Object* view, Eina_Bool hold) {
 798   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 799   impl->SetVerticalPanningHold(hold);
 800 }
 801
 802 void ewk_view_orientation_lock_callback_set(Evas_Object* ewkView, Ewk_Orientation_Lock_Cb func, void* data)
 803 {
 804   LOG_EWK_API_MOCKUP("This API is deprecated, to use orientation lock/unlock "
 805       "API please use functions lock_orientation/unlock_orientation provided "
 806       "by Ewk_View_Smart_Class.");
 807 }
 808
 809
 810 void ewk_view_back_forward_list_clear(const Evas_Object *view)
 811 {
 812   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 813   impl->BackForwardListClear();
 814 }
 815
 816 Eina_Bool ewk_view_feed_touch_event(Evas_Object *view, Ewk_Touch_Event_Type type, const Eina_List *points, const Evas_Modifier *modifiers)
 817 {
 818   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 819
 820   impl->HandleTouchEvents(type, points, modifiers);
 821
 822   return true;
 823 }
 824
 825 Eina_Bool ewk_view_touch_events_enabled_set(Evas_Object *view, Eina_Bool enabled)
 826 {
 827   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 828
 829   impl->SetTouchEventsEnabled(!!enabled);
 830
 831   return true;
 832 }
 833
 834 Eina_Bool ewk_view_touch_events_enabled_get(const Evas_Object *view)
 835 {
 836   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 837
 838   return impl->TouchEventsEnabled();
 839 }
 840
 841 Ewk_Frame_Ref ewk_view_main_frame_get(Evas_Object* o)
 842 {
 843   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, NULL);
 844   return static_cast<Ewk_Frame_Ref>(impl->GetMainFrame());
 845 }
 846
 847 void ewk_view_content_security_policy_set(Evas_Object* ewkView, const char* policy, Ewk_CSP_Header_Type type)
 848 {
 849   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 850   EINA_SAFETY_ON_NULL_RETURN(policy);
 851   impl->SetContentSecurityPolicy(policy, type);
 852 }
 853
 854 void ewk_view_application_cache_permission_callback_set(Evas_Object* ewkView, Ewk_View_Applicacion_Cache_Permission_Callback callback, void* userData)
 855 {
 856   // Chromium does not support this feature hence the comment
 857   LOG_EWK_API_MOCKUP("Not Supported by chromium");
 858 }
 859
 860 void ewk_view_application_cache_permission_reply(Evas_Object* ewkView, Eina_Bool allow)
 861 {
 862   // Chromium does not support this feature hence the comment
 863   LOG_EWK_API_MOCKUP("Not Supported by chromium");
 864 }
 865
 866 void ewk_view_exceeded_indexed_database_quota_callback_set(Evas_Object* view, Ewk_View_Exceeded_Indexed_Database_Quota_Callback callback, void* user_data)
 867 {
 868   // Chromium does not support quota for Indexed DB only.
 869   // IndexedDB uses temporary storage that is shared
 870   // between other features.
 871   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 872   impl->SetExceededIndexedDatabaseQuotaCallback(callback, user_data);
 873 }
 874
 875 void ewk_view_exceeded_indexed_database_quota_reply(Evas_Object* view, Eina_Bool allow)
 876 {
 877   // Chromium does not support quota for Indexed DB only.
 878   // IndexedDB uses temporary storage that is shared
 879   // between other features.
 880   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 881   impl->ExceededIndexedDatabaseQuotaReply(allow);
 882 }
 883
 884 Eina_Bool ewk_view_text_find(Evas_Object *view, const char *text, Ewk_Find_Options options, unsigned int max_match_count)
 885 {
 886   // FIXME: We need to implement next options in Ewk_Find_Options struct. (refer to ewk_view.h)
 887   //         - EWK_FIND_OPTIONS_AT_WORD_STARTS
 888   //         - EWK_FIND_OPTIONS_TREAT_MEDIAL_CAPITAL_AS_WORD_START
 889   //         - EWK_FIND_OPTIONS_WRAP_AROUND
 890   //         - EWK_FIND_OPTIONS_SHOW_OVERLAY
 891   //         - EWK_FIND_OPTIONS_SHOW_FIND_INDICATOR
 892   //         - EWK_FIND_OPTIONS_SHOW_HIGHLIGHT (Currently there is no way to control this option. so it is always set)
 893
 894   // FIXME: Updating of max_match_count is not implemented.
 895
 896   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 897   EINA_SAFETY_ON_NULL_RETURN_VAL(text, EINA_FALSE);
 898   impl->Find(text, options);
 899   return EINA_TRUE;
 900 }
 901
 902 Eina_Bool ewk_view_text_find_highlight_clear(Evas_Object *view)
 903 {
 904   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 905   impl->StopFinding();
 906   return EINA_TRUE;
 907 }
 908
 909 void ewk_view_exceeded_database_quota_callback_set(Evas_Object* ewkView, Ewk_View_Exceeded_Database_Quota_Callback callback, void* userData)
 910 {
 911   // According to chromium source code:
 912   // src/third_party/WebKit/Source/modules/webdatabase/SQLTransactionClient.cpp line 67
 913   // Chromium does not allow users to manually change the quota for an origin (for now, at least).
 914   // This API is impossible to implement right now
 915   LOG_EWK_API_MOCKUP("Not Supported by chromium");
 916 }
 917
 918 void ewk_view_exceeded_database_quota_reply(Evas_Object* ewkView, Eina_Bool allow)
 919 {
 920   // According to chromium source code:
 921   // src/third_party/WebKit/Source/modules/webdatabase/SQLTransactionClient.cpp line 67
 922   // Chromium does not allow users to manually change the quota for an origin (for now, at least).
 923   // This API is impossible to implement right now
 924   LOG_EWK_API_MOCKUP("Not Supported by chromium");
 925 }
 926
 927 void ewk_view_exceeded_local_file_system_quota_callback_set(Evas_Object* ewkView, Ewk_View_Exceeded_Indexed_Database_Quota_Callback callback, void* userData)
 928 {
 929   LOG_EWK_API_MOCKUP();
 930 }
 931
 932 void ewk_view_exceeded_local_file_system_quota_reply(Evas_Object* ewkView, Eina_Bool allow)
 933 {
 934   LOG_EWK_API_MOCKUP();
 935 }
 936
 937 void ewk_view_unfocus_allow_callback_set(Evas_Object* ewkView, Ewk_View_Unfocus_Allow_Callback callback, void* user_data)
 938 {
 939   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 940   impl->SetViewUnfocusAllowCallback(callback, user_data);
 941 }
 942
 943 void ewk_view_smartrc_show_mic_notification_callback_set(Evas_Object* ewkView, Ewk_View_SmartRC_Mic_Notification_Callback callback, void* user_data)
 944 {
 945 #if BUILDFLAG(IS_TIZEN_TV)
 946   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 947   impl->SetViewSmartrcMicNotificationCallback(callback, user_data);
 948 #else
 949   LOG_EWK_API_MOCKUP("This API is only available in Tizen TV product.");
 950 #endif
 951 }
 952
 953 void ewk_view_geolocation_permission_callback_set(Evas_Object* ewk_view, Ewk_View_Geolocation_Permission_Callback callback, void* user_data)
 954 {
 955   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
 956   impl->SetViewGeolocationPermissionCallback(callback, user_data);
 957 }
 958
 959 static Eina_Bool _ewk_view_default_geolocation_permission(
 960     Evas_Object* ewk_view,
 961     Ewk_Geolocation_Permission_Request* request,
 962     void* user_data)
 963 {
 964   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl, EINA_FALSE);
 965
 966   std::string value = std::string(ewk_security_origin_host_get(
 967       ewk_geolocation_permission_request_origin_get(request)));
 968   std::string message = std::string(
 969       "Web Page (%s) is requesting permission to access your location.");
 970   std::string replace_str = std::string("(%s)");
 971
 972   size_t pos = message.find(replace_str.c_str());
 973   if (pos != std::string::npos)
 974     message.replace(pos, replace_str.length(), value.c_str());
 975
 976   // add for suspending
 977   ewk_geolocation_permission_request_suspend(request);
 978
 979   GeolocationPermissionPopup* popup = new GeolocationPermissionPopup(request,
 980       ewk_geolocation_permission_request_origin_get(request), message);
 981
 982   impl->GetPermissionPopupManager()->AddPermissionRequest(popup);
 983
 984   return EINA_TRUE;
 985 }
 986
 987 void ewk_view_user_media_permission_callback_set(Evas_Object* ewk_view,
 988     Ewk_View_User_Media_Permission_Callback callback,
 989     void* user_data)
 990 {
 991   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
 992   impl->SetViewUserMediaPermissionCallback(callback, user_data);
 993 }
 994
 995 void ewk_view_user_media_permission_query_callback_set(
 996     Evas_Object* ewk_view,
 997     Ewk_View_User_Media_Permission_Query_Callback callback,
 998     void* user_data) {
 999   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
1000   impl->SetViewUserMediaPermissionQueryCallback(callback, user_data);
1001 }
1002
1003 static Eina_Bool _ewk_view_default_user_media_permission(
1004     Evas_Object* ewk_view,
1005     Ewk_User_Media_Permission_Request* user_media_permission_request,
1006     void* user_data)
1007 {
1008   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl, EINA_FALSE);
1009
1010   std::string message =
1011     CreatePermissionMessageRequest(user_media_permission_request);
1012
1013   // add for suspending
1014   ewk_user_media_permission_request_suspend(user_media_permission_request);
1015
1016   UserMediaPermissionPopup* popup = new UserMediaPermissionPopup(
1017       user_media_permission_request,
1018       ewk_user_media_permission_request_origin_get(
1019           user_media_permission_request), message);
1020
1021   impl->GetPermissionPopupManager()->AddPermissionRequest(popup);
1022
1023   return EINA_TRUE;
1024 }
1025
1026 void ewk_view_use_settings_font(Evas_Object* ewkView)
1027 {
1028   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1029   impl->UseSettingsFont();
1030 }
1031
1032 char* ewk_view_get_cookies_for_url(Evas_Object* view, const char* url)
1033 {
1034   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, 0);
1035   EINA_SAFETY_ON_NULL_RETURN_VAL(url, 0);
1036   EINA_SAFETY_ON_NULL_RETURN_VAL(impl->context(), 0);
1037   EINA_SAFETY_ON_NULL_RETURN_VAL(impl->context()->cookieManager(), 0);
1038   std::string cookiesForURL =
1039       impl->context()->cookieManager()->GetCookiesForURL(std::string(url));
1040   if (cookiesForURL.empty())
1041     return NULL;
1042   return strndup(cookiesForURL.c_str(), cookiesForURL.length());
1043 }
1044
1045 Eina_Bool ewk_view_fullscreen_exit(Evas_Object* view)
1046 {
1047   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1048   LOG(INFO) << "view: " << view;
1049   impl->ExitFullscreen();
1050   return EINA_TRUE;
1051 }
1052
1053 Eina_Bool ewk_view_draws_transparent_background_set(Evas_Object *view, Eina_Bool enabled)
1054 {
1055   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1056   return impl->SetDrawsTransparentBackground(!!enabled);
1057 }
1058
1059 void ewk_view_browser_font_set(Evas_Object* ewkView)
1060 {
1061   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1062   impl->SetBrowserFont();
1063 }
1064
1065 void ewk_view_session_data_get(Evas_Object* ewkView, const char** data, unsigned* length)
1066 {
1067   EINA_SAFETY_ON_NULL_RETURN(data);
1068   EINA_SAFETY_ON_NULL_RETURN(length);
1069
1070   EWebView* impl = GetEWebViewFromEwkView(ewkView);
1071   if (!impl) {
1072     *data = NULL;
1073     *length = 0;
1074     return;
1075   }
1076
1077   impl->GetSessionData(data, length);
1078 }
1079
1080 Eina_Bool ewk_view_mode_set(Evas_Object* ewkView, Ewk_View_Mode view_mode)
1081 {
1082   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
1083
1084   if (view_mode == EWK_VIEW_MODE_WINDOWED) {
1085 #if !defined(EWK_BRINGUP)  // FIXME: m67 bringup
1086     impl->SetViewMode(blink::WebViewModeWindowed);
1087 #endif
1088     return EINA_TRUE;
1089   } else if (view_mode == EWK_VIEW_MODE_FULLSCREEN) {
1090 #if !defined(EWK_BRINGUP)  // FIXME: m67 bringup
1091     impl->SetViewMode(blink::WebViewModeFullscreen);
1092 #endif
1093     return EINA_TRUE;
1094   } else {
1095     return EINA_FALSE;
1096   }
1097 }
1098
1099 Eina_Bool ewk_view_split_scroll_overflow_enabled_set(Evas_Object* ewkView, const Eina_Bool enabled)
1100 {
1101   LOG_EWK_API_MOCKUP("for browser");
1102   return false;
1103 }
1104
1105 Ewk_Back_Forward_List* ewk_view_back_forward_list_get(const Evas_Object* ewkView)
1106 {
1107   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, NULL);
1108   return impl->GetBackForwardList();
1109 }
1110
1111 void ewk_view_notification_permission_callback_set(Evas_Object *o, Ewk_View_Notification_Permission_Callback callback, void *user_data)
1112 {
1113   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl);
1114   impl->SetNotificationPermissionCallback(callback, user_data);
1115 }
1116
1117 static Eina_Bool _ewk_view_default_notification_permission(
1118     Evas_Object* ewk_view,
1119     Ewk_Notification_Permission_Request* request,
1120     void* user_data)
1121 {
1122   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl, EINA_FALSE);
1123
1124   std::string value = std::string(ewk_security_origin_host_get(
1125       ewk_notification_permission_request_origin_get(request)));
1126   std::string message = std::string(
1127       "Web Page (%s) is requesting permission to show notifications.");
1128   std::string replace_str = std::string("(%s)");
1129
1130   size_t pos = message.find(replace_str.c_str());
1131   if (pos != std::string::npos)
1132     message.replace(pos, replace_str.length(), value.c_str());
1133
1134   // add for suspending
1135   ewk_notification_permission_request_suspend(request);
1136
1137   NotificationPermissionPopup* popup = new NotificationPermissionPopup(request,
1138       ewk_notification_permission_request_origin_get(request), message);
1139
1140   impl->GetPermissionPopupManager()->AddPermissionRequest(popup);
1141
1142   return EINA_TRUE;
1143 }
1144
1145 void ewk_view_draw_focus_ring_enable_set(Evas_Object* ewkView, Eina_Bool enable)
1146 {
1147   LOG_EWK_API_MOCKUP("This API is deprecated");
1148 }
1149
1150 double ewk_view_page_zoom_get(const Evas_Object* ewkView)
1151 {
1152   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, -1.0);
1153   return impl->GetPageZoomFactor();
1154 }
1155
1156 Eina_Bool ewk_view_page_zoom_set(Evas_Object* ewkView, double zoomFactor)
1157 {
1158   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
1159   impl->SetPageZoomFactor(zoomFactor);
1160   return EINA_TRUE;
1161 }
1162
1163 Evas_Object* ewk_view_smart_add(Evas* canvas, Evas_Smart* smart, Ewk_Context* context, Ewk_Page_Group* pageGroup)
1164 {
1165   EINA_SAFETY_ON_NULL_RETURN_VAL(context, 0);
1166   LOG(INFO) << "evas: " << canvas << ", context:" << context;
1167   return CreateWebViewAsEvasObject(context, canvas, smart);
1168 }
1169
1170 void ewk_view_quota_permission_request_callback_set(Evas_Object* ewkView, Ewk_Quota_Permission_Request_Callback callback, void* user_data)
1171 {
1172   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1173   impl->SetQuotaPermissionRequestCallback(callback, user_data);
1174 }
1175
1176 void ewk_view_quota_permission_request_reply(const Ewk_Quota_Permission_Request* request, const Eina_Bool allow)
1177 {
1178   EINA_SAFETY_ON_NULL_RETURN(request);
1179   Evas_Object* ewkView = request->getView();
1180   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1181 #if !defined(EWK_BRINGUP)  // FIXME: m114 bringup
1182   impl->QuotaRequestReply(request, allow == EINA_TRUE);
1183 #endif
1184 }
1185
1186 void ewk_view_quota_permission_request_cancel(const Ewk_Quota_Permission_Request* request)
1187 {
1188   EINA_SAFETY_ON_NULL_RETURN(request);
1189   Evas_Object* ewkView = request->getView();
1190   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1191 #if !defined(EWK_BRINGUP)  // FIXME: m114 bringup
1192   impl->QuotaRequestCancel(request);
1193 #endif
1194 }
1195
1196 Eina_Bool ewk_view_focus_set(const Evas_Object* view, Eina_Bool focused)
1197 {
1198   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1199   LOG(INFO) << "view: " << view << ", focused:" << (bool)focused;
1200   impl->SetFocus(focused);
1201   return EINA_TRUE;
1202 }
1203
1204 Eina_Bool ewk_view_focus_get(const Evas_Object* view)
1205 {
1206   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1207   return impl->HasFocus();
1208 }
1209
1210 Eina_Bool ewk_view_page_close(Evas_Object* o)
1211 {
1212   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, EINA_FALSE);
1213
1214   impl->ClosePage();
1215   return EINA_TRUE;
1216 }
1217
1218 void ewk_view_session_timeout_set(Evas_Object* o, unsigned long timeout)
1219 {
1220   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl);
1221   impl->SetSessionTimeout(timeout);
1222 }
1223
1224 Evas_Object* ewk_view_widget_get(Evas_Object* view)
1225 {
1226   LOG_EWK_API_MOCKUP();
1227   return NULL;
1228 }
1229
1230 Eina_Bool ewk_view_draws_transparent_background_get(Evas_Object* o)
1231 {
1232   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, EINA_FALSE);
1233   return impl->GetDrawsTransparentBackground();
1234 }
1235
1236 Eina_Bool ewk_view_did_change_theme_color_callback_set(
1237     Evas_Object* o,
1238     Ewk_View_Did_Change_Theme_Color_Callback callback,
1239     void* user_data) {
1240   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, EINA_FALSE);
1241   impl->SetDidChangeThemeColorCallback(callback, user_data);
1242   return EINA_TRUE;
1243 }
1244
1245 Eina_Bool ewk_view_split_scroll_overflow_enabled_get(const Evas_Object* o) {
1246   LOG_EWK_API_MOCKUP();
1247   return false;
1248 }
1249
1250 Eina_Bool ewk_view_save_page_as_mhtml(Evas_Object* o, const char* path, Ewk_View_Save_Page_Callback callback, void* user_data)
1251 {
1252   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, EINA_FALSE);
1253   EINA_SAFETY_ON_NULL_RETURN_VAL(path, EINA_FALSE);
1254   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
1255   return impl->SavePageAsMHTML(path, callback, user_data);
1256 }
1257
1258 void ewk_view_reader_mode_set(Evas_Object* ewk_view, Eina_Bool enable)
1259 {
1260   LOG_EWK_API_MOCKUP();
1261 }
1262
1263 Eina_Bool ewk_view_top_controls_height_set(Evas_Object* ewk_view, size_t top_height, size_t bottom_height)
1264 {
1265   LOG_EWK_API_MOCKUP();
1266   return false;
1267 }
1268
1269 Eina_Bool ewk_view_top_controls_state_set(Evas_Object* ewk_view, Ewk_Top_Control_State constraint,  Ewk_Top_Control_State current, Eina_Bool animation)
1270 {
1271   LOG_EWK_API_MOCKUP();
1272   return false;
1273 }
1274
1275 Eina_Bool ewk_view_main_frame_scrollbar_visible_set(Evas_Object* ewk_view,
1276                                                     Eina_Bool visible) {
1277   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl, EINA_FALSE);
1278   return impl->SetMainFrameScrollbarVisible(!!visible);
1279 }
1280
1281 Eina_Bool ewk_view_main_frame_scrollbar_visible_get(
1282     Evas_Object* ewk_view,
1283     Ewk_View_Main_Frame_Scrollbar_Visible_Get_Callback callback,
1284     void* user_data) {
1285   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
1286   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl, EINA_FALSE);
1287
1288   return impl->GetMainFrameScrollbarVisible(callback, user_data);
1289 }
1290
1291 Eina_Bool ewk_view_set_custom_device_pixel_ratio(Evas_Object* ewkView, Eina_Bool enabled)
1292 {
1293   LOG_EWK_API_MOCKUP();
1294   return false;
1295 }
1296
1297 Ewk_Board_Decoding_Capabilities ewk_view_board_decoding_capabilities_get(
1298   const Evas_Object* view)
1299 {
1300   LOG_EWK_API_MOCKUP();
1301   return EWK_BOARD_DECODING_CAPABILITIES_UNKNOWN;
1302 }
1303
1304 void ewk_view_next_player_for_media_switch_set(
1305   Evas_Object* view,
1306   int player_id)
1307 {
1308   LOG_EWK_API_MOCKUP();
1309 }
1310
1311 void ewk_view_sw_audio_decoding_set(
1312   Evas_Object* view,
1313   Eina_Bool use_sw_audio_decoder)
1314 {
1315   LOG_EWK_API_MOCKUP();
1316 }
1317
1318 void ewk_view_set_video_geometry(
1319   Evas_Object* view,
1320   Eina_Rectangle v_area)
1321 {
1322   LOG_EWK_API_MOCKUP();
1323 }
1324
1325 void ewk_view_release_players(
1326   Evas_Object* view)
1327 {
1328   LOG_EWK_API_MOCKUP();
1329 }
1330
1331 void ewk_view_player_set_visibility(
1332   Evas_Object* view,
1333   int video_id,
1334   bool visibility)
1335 {
1336   LOG_EWK_API_MOCKUP();
1337 }
1338
1339 void ewk_view_broadcast_set_visibility(
1340   Evas_Object* view,
1341   bool visibility)
1342 {
1343   LOG_EWK_API_MOCKUP();
1344 }
1345
1346 void ewk_view_player_play(
1347   Evas_Object* view,
1348   int video_id)
1349 {
1350   LOG_EWK_API_MOCKUP();
1351 }
1352
1353 void ewk_view_player_pause(
1354   Evas_Object* view,
1355   int video_id)
1356 {
1357   LOG_EWK_API_MOCKUP();
1358 }
1359
1360 Eina_Bool ewk_media_translated_url_set(Evas_Object* ewkView, const char* url)
1361 {
1362 #if BUILDFLAG(IS_TIZEN_TV)
1363   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
1364   EINA_SAFETY_ON_NULL_RETURN_VAL(url, EINA_FALSE);
1365   impl->SetTranslatedURL(url);
1366   return EINA_TRUE;
1367 #else
1368   LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1369   return false;
1370 #endif
1371 }
1372
1373 #if BUILDFLAG(IS_TIZEN_TV)
1374 Eina_Bool ewk_view_app_preload_set(Evas_Object* ewkView, Eina_Bool is_preload)
1375 {
1376   LOG_EWK_API_MOCKUP();
1377   return false;
1378 }
1379 #endif
1380
1381 Evas_Object* ewk_view_favicon_get(const Evas_Object* ewkView)
1382 {
1383   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, nullptr);
1384   EINA_SAFETY_ON_NULL_RETURN_VAL(impl->context(), nullptr);
1385   const char* url = ewk_view_url_get(ewkView);
1386   return impl->context()->AddFaviconObject(url, impl->GetEvas());
1387 }
1388
1389 Eina_Bool ewk_view_html_string_override_current_entry_load(Evas_Object* view, const char* html, const char* base_uri, const char* unreachable_url)
1390 {
1391 #if BUILDFLAG(IS_TIZEN_TV)
1392   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1393   EINA_SAFETY_ON_NULL_RETURN_VAL(html, EINA_FALSE);
1394   impl->LoadHTMLStringOverridingCurrentEntry(html, base_uri, unreachable_url);
1395   return EINA_TRUE;
1396 #else
1397   LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1398   return EINA_FALSE;
1399 #endif
1400 }
1401
1402 Eina_Bool ewk_view_text_matches_count(Evas_Object* o, const char* text, Ewk_Find_Options options, unsigned max_match_count)
1403 {
1404   LOG_EWK_API_MOCKUP();
1405   return false;
1406 }
1407
1408 void ewk_view_mirrored_blur_set(Evas_Object* o, Eina_Bool state)
1409 {
1410   LOG_EWK_API_MOCKUP();
1411 }
1412
1413 void ewk_view_add_dynamic_certificate_path(const Evas_Object *ewkView, const char* host, const char* cert_path)
1414 {
1415 #if BUILDFLAG(IS_TIZEN_TV)
1416   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1417   impl->AddDynamicCertificatePath(std::string(host), std::string(cert_path));
1418 #else
1419   LOG_EWK_API_MOCKUP();
1420 #endif
1421 }
1422
1423 void ewk_view_atk_deactivation_by_app(Evas_Object* view, Eina_Bool enable)
1424 {
1425 #if BUILDFLAG(IS_TIZEN_TV)
1426   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
1427   LOG(INFO)<< "ewk_view_atk_deactivation_by_app, enable: " << (bool)enable;
1428   impl->DeactivateAtk(enable == EINA_FALSE);
1429 #else
1430   LOG_EWK_API_MOCKUP();
1431 #endif
1432 }
1433
1434 char* ewk_view_cookies_get(Evas_Object* o, const char* url)
1435 {
1436   LOG_EWK_API_MOCKUP();
1437   return NULL;
1438 }
1439
1440 void ewk_view_notification_show_callback_set(Evas_Object *o, Ewk_View_Notification_Show_Callback show_callback, void *user_data)
1441 {
1442   LOG_EWK_API_MOCKUP();
1443 }
1444
1445 void ewk_view_notification_cancel_callback_set(Evas_Object *o, Ewk_View_Notification_Cancel_Callback cancel_callback, void *user_data)
1446 {
1447   LOG_EWK_API_MOCKUP();
1448 }
1449
1450 const char* ewk_view_custom_encoding_get(const Evas_Object* o)
1451 {
1452   LOG_EWK_API_MOCKUP();
1453   return NULL;
1454 }
1455
1456 Eina_Bool ewk_view_custom_encoding_set(Evas_Object* o, const char* encoding)
1457 {
1458   LOG_EWK_API_MOCKUP();
1459   return false;
1460 }
1461
1462 void ewk_view_force_layout(const Evas_Object* o)
1463 {
1464   LOG_EWK_API_MOCKUP();
1465 }
1466
1467 Eina_Bool ewk_view_send_key_event(Evas_Object* ewk_view, void* key_event, Eina_Bool is_press) {
1468   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl, EINA_FALSE);
1469   EINA_SAFETY_ON_NULL_RETURN_VAL(key_event, EINA_FALSE);
1470 #if BUILDFLAG(IS_TIZEN_TV)
1471   LOG(INFO) << "view: " << ewk_view << ", is_press :" << (bool)is_press;
1472 #endif
1473   impl->SendKeyEvent(ewk_view, key_event, !!is_press);
1474   return EINA_TRUE;
1475 }
1476
1477 Eina_Bool ewk_view_tts_mode_set(Evas_Object* view, ewk_tts_mode tts_mode) {
1478 #if defined(TIZEN_WEB_SPEECH_RECOGNITION)
1479   switch (tts_mode) {
1480     case EWK_TTS_MODE_DEFAULT:
1481       content::TtsPlatformImplTizen::SetTtsMode(TTS_MODE_DEFAULT);
1482       break;
1483     case EWK_TTS_MODE_NOTIFICATION:
1484       content::TtsPlatformImplTizen::SetTtsMode(TTS_MODE_NOTIFICATION);
1485       break;
1486     case EWK_TTS_MODE_SCREEN_READER:
1487       content::TtsPlatformImplTizen::SetTtsMode(TTS_MODE_SCREEN_READER);
1488       break;
1489     default:
1490       LOG(ERROR) << "Not supported TTS mode: " << static_cast<int>(tts_mode);
1491       return EINA_FALSE;
1492   }
1493   return EINA_TRUE;
1494 #else
1495   LOG_EWK_API_MOCKUP("API unavailable.");
1496   return EINA_FALSE;
1497 #endif
1498 }
1499
1500 Eina_Bool ewk_view_javascript_message_handler_add(
1501     Evas_Object* view,
1502     Ewk_View_Script_Message_Cb callback,
1503     const char* name) {
1504   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1505   EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
1506   return impl->AddJavaScriptMessageHandler(view, callback, std::string(name));
1507 }
1508
1509 Eina_Bool ewk_view_evaluate_javascript(Evas_Object* view,
1510                                        const char* name,
1511                                        const char* result) {
1512   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1513   EINA_SAFETY_ON_NULL_RETURN_VAL(result, EINA_FALSE);
1514   EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
1515
1516   std::string function(name);
1517   std::string data(result);
1518   std::string pattern("\n");
1519   std::string replace("</br>");
1520   std::string::size_type pos = 0;
1521   std::string::size_type offset = 0;
1522   while ((pos = data.find(pattern, offset)) != std::string::npos) {
1523     data.replace(data.begin() + pos, data.begin() + pos + pattern.size(),
1524                  replace);
1525     offset = pos + replace.size();
1526   }
1527
1528   // For JSON Object or Array.
1529   if (result[0] == '{' || result[0] == '[') {
1530     data = "javascript:" + function + "(JSON.parse('" + data + "'))";
1531   } else {
1532     data = "javascript:" + function + "('" + data + "')";
1533   }
1534
1535   return impl->ExecuteJavaScript(data.c_str(), NULL, 0);
1536 }
1537
1538 void ewk_view_authentication_callback_set(
1539     Evas_Object* ewk_view,
1540     Ewk_View_Authentication_Callback callback,
1541     void* user_data)
1542 {
1543   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
1544   impl->SetViewAuthCallback(callback, user_data);
1545
1546 }
1547
1548 static void _ewk_view_default_authentication(Evas_Object* ewk_view,
1549                                              Ewk_Auth_Challenge* auth_challenge,
1550                                              void* user_data)
1551 {
1552   AuthenticationChallengePopup::CreateAndShow(auth_challenge, ewk_view);
1553 }
1554
1555 void ewk_view_app_installation_request_callback_set(Evas_Object* o, Ewk_App_Installation_Request_Callback callback, void* user_data)
1556 {
1557   LOG_EWK_API_MOCKUP();
1558 }
1559
1560 Eina_Bool ewk_view_bg_color_set(Evas_Object* o, int r, int g, int b, int a) {
1561   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, EINA_FALSE);
1562   if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255 || a < 0 ||
1563     a > 255) {
1564     LOG(ERROR) << "Invalid background color";
1565     return EINA_FALSE;
1566   }
1567   return impl->SetBackgroundColor(r, g, b, a);
1568 }
1569
1570 Eina_Bool ewk_view_key_events_enabled_set(Evas_Object* o, Eina_Bool enabled) {
1571 #if BUILDFLAG(IS_TIZEN_TV)
1572   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, EINA_FALSE);
1573   LOG(INFO)<< "ewk_view_key_events_enabled_set, enabled: " << (bool)enabled;
1574   return impl->SetKeyEventsEnabled(!!enabled);
1575 #else
1576   LOG_EWK_API_MOCKUP("This API is only available in Tizen TV product.");
1577   return EINA_FALSE;
1578 #endif
1579
1580 }
1581
1582 Eina_Bool ewk_view_bg_color_get(Evas_Object* view,
1583                                 Ewk_View_Background_Color_Get_Callback callback,
1584                                 void* user_data) {
1585   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
1586   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1587
1588   return impl->GetBackgroundColor(callback, user_data);
1589 }
1590
1591 void ewk_view_clear_all_tiles_resources(Evas_Object* ewkView) {
1592 #if BUILDFLAG(IS_TIZEN_TV)
1593   LOG(INFO) << "view: " << ewkView;
1594 #else
1595   LOG_EWK_API_MOCKUP();
1596 #endif
1597 }
1598
1599 Eina_Bool ewk_view_edge_scroll_by(Evas_Object *ewkView, int dx, int dy)
1600 {
1601   LOG_EWK_API_MOCKUP();
1602 #if BUILDFLAG(IS_TIZEN_TV)
1603   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
1604   LOG(INFO) << "view: " << ewkView << ", dx:" << dx << ", dy:" << dy;
1605   return impl->EdgeScrollBy(dx, dy);
1606 #else
1607   LOG_EWK_API_MOCKUP("edge_scroll_by feature is not enabled");
1608   return EINA_FALSE;
1609 #endif
1610 }
1611
1612 Eina_Bool ewk_view_set_support_video_hole(Evas_Object* ewkView,
1613                                           void* window,
1614                                           Eina_Bool enable,
1615                                           Eina_Bool isVideoWindow) {
1616   LOG_EWK_API_MOCKUP();
1617 #if defined(TIZEN_VIDEO_HOLE)
1618   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
1619   LOG(INFO) << "view: " << ewkView << ", enable:" << (bool)enable;
1620   // Video hole is set false by default. So further calls are not needed
1621   // if |enable| is false.
1622   if (enable == EINA_FALSE)
1623     return EINA_FALSE;
1624
1625   impl->EnableVideoHoleSupport();
1626   media::VideoPlaneController::SetSharedVideoWindowHandle(
1627       window,
1628       static_cast<media::VideoPlaneController::RenderingMode>(isVideoWindow));
1629   return EINA_TRUE;
1630 #else
1631   LOG_EWK_API_MOCKUP("Video Hole feature is not enabled");
1632   return EINA_FALSE;
1633 #endif
1634 }
1635
1636 void ewk_view_set_cursor_by_client(Evas_Object* ewkView, Eina_Bool enable) {}
1637
1638 void ewk_view_widget_pepper_extension_callback_set(Evas_Object* ewk_view, Generic_Sync_Call_Callback cb, void* user_data) {
1639 #if defined(TIZEN_PEPPER_EXTENSIONS) && BUILDFLAG(IS_TIZEN_TV)
1640   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
1641   impl->SetPepperExtensionCallback(cb, user_data);
1642 #else
1643   NOTIMPLEMENTED() << "This API is only available with TIZEN_PEPPER_EXTENSIONS"
1644                    << " macro on TIZEN_TV products.";
1645 #endif
1646 }
1647
1648 void ewk_view_widget_pepper_extension_info_set(Evas_Object* ewk_view, Ewk_Value widget_pepper_ext_info) {
1649 #if defined(TIZEN_PEPPER_EXTENSIONS) && BUILDFLAG(IS_TIZEN_TV)
1650   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
1651   impl->SetPepperExtensionWidgetInfo(widget_pepper_ext_info);
1652 #else
1653   NOTIMPLEMENTED() << "This API is only available with TIZEN_PEPPER_EXTENSIONS"
1654                    << " macro on TIZEN_TV products.";
1655 #endif
1656 }
1657
1658 void ewk_view_resume_network_loading(Evas_Object* ewk_view)
1659 {
1660 #if BUILDFLAG(IS_TIZEN_TV)
1661   LOG(INFO) << "view : " << ewk_view;
1662   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
1663   impl->ResumeNetworkLoading();
1664 #else
1665   LOG_EWK_API_MOCKUP("Only for Tizen TV Browser");
1666 #endif
1667 }
1668
1669 void ewk_view_suspend_network_loading(Evas_Object* ewk_view)
1670 {
1671 #if BUILDFLAG(IS_TIZEN_TV)
1672   LOG(INFO) << "view : " << ewk_view;
1673   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
1674   impl->SuspendNetworkLoading();
1675 #else
1676   LOG_EWK_API_MOCKUP("Only for Tizen TV Browser");
1677 #endif
1678 }
1679
1680 void ewk_view_offscreen_rendering_enabled_set(Evas_Object* o, Eina_Bool enabled)
1681 {
1682 #if defined(TIZEN_TBM_SUPPORT)
1683   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl);
1684   impl->SetOffscreenRendering(enabled);
1685 #if defined(TIZEN_VIDEO_HOLE)
1686   media::VideoPlaneController::set_use_wayland_window(true);
1687 #endif
1688 #else
1689   LOG_EWK_API_MOCKUP();
1690 #endif
1691 }
1692
1693 void ewk_view_ime_window_set(Evas_Object* o, void* window)
1694 {
1695   LOG_EWK_API_MOCKUP();
1696 }
1697
1698 Eina_Bool ewk_view_set_support_canvas_hole(Evas_Object* ewkView, const char* url)
1699 {
1700   LOG_EWK_API_MOCKUP();
1701   return EINA_FALSE;
1702 }
1703
1704 void ewk_view_tile_cover_area_multiplier_set(Evas_Object* ewkView,
1705                                              float cover_area_multiplier) {
1706   LOG_EWK_API_MOCKUP();
1707 }
1708
1709 Eina_Bool ewk_view_marlin_enable_set(Evas_Object* ewkView, Eina_Bool is_enable)
1710 {
1711   LOG_EWK_API_MOCKUP();
1712   return EINA_FALSE;
1713 }
1714
1715 Eina_Bool ewk_view_key_system_whitelist_set(Evas_Object* ewkView, const char** list, unsigned list_size)
1716 {
1717   LOG_EWK_API_MOCKUP();
1718   return EINA_FALSE;
1719 }
1720
1721 Eina_Bool ewk_view_is_video_playing(Evas_Object* o, Ewk_Is_Video_Playing_Callback callback, void* user_data)
1722 {
1723 #if BUILDFLAG(IS_TIZEN_TV)
1724   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, EINA_FALSE);
1725   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
1726   LOG(INFO) << __func__;
1727   return impl->IsVideoPlaying(callback, user_data) ? EINA_TRUE : EINA_FALSE;
1728 #else
1729   LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1730   return EINA_FALSE;
1731 #endif
1732 }
1733
1734 Eina_Bool ewk_view_stop_video(Evas_Object* o, Ewk_Stop_Video_Callback callback, void* user_data)
1735 {
1736   LOG_EWK_API_MOCKUP();
1737   return EINA_FALSE;
1738 }
1739
1740 Eina_Bool ewk_view_active_drm_set(Evas_Object* view, const char* drm_system_id)
1741 {
1742   LOG_EWK_API_MOCKUP();
1743   return EINA_FALSE;
1744 }
1745
1746 void ewk_view_broadcast_decoder_set(
1747   Evas_Object* view,
1748   Ewk_Hardware_Decoders decoder)
1749 {
1750 #if BUILDFLAG(IS_TIZEN_TV)
1751   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
1752   /* waiting for implement*/
1753   //impl->SetBroadcastDecoder(decoder);
1754 #else
1755   LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1756 #endif
1757 }
1758
1759 void ewk_media_set_subtitle_lang(Evas_Object* ewkView, const char* lang_list)
1760 {
1761 #if BUILDFLAG(IS_TIZEN_TV)
1762     EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1763     impl->SetPreferSubtitleLang(lang_list);
1764 #else
1765     LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1766 #endif
1767 }
1768
1769 void ewk_media_set_parental_rating_result(Evas_Object* ewkView, const char* url, Eina_Bool is_pass)
1770 {
1771 #if BUILDFLAG(IS_TIZEN_TV)
1772   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1773   impl->SetParentalRatingResult(url, is_pass);
1774 #else
1775   LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1776 #endif
1777 }
1778
1779 void ewk_media_start_with_high_bit_rate(Evas_Object* ewkView, Eina_Bool high_bitrate)
1780 {
1781 #if BUILDFLAG(IS_TIZEN_TV)
1782   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1783   impl->SetHighBitRate(high_bitrate);
1784 #else
1785   LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1786 #endif
1787 }
1788
1789 double ewk_view_media_current_time_get(const Evas_Object *o)
1790 {
1791 #if BUILDFLAG(IS_TIZEN_TV)
1792   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, 0);
1793   return impl->GetCurrentTime();
1794 #else
1795   LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1796   return 0;
1797 #endif
1798 }
1799
1800 void ewk_view_request_canvas_fullscreen(Evas_Object* ewkView)
1801 {
1802   LOG_EWK_API_MOCKUP();
1803 }
1804
1805 void ewk_view_360video_play(Evas_Object* ewkView)
1806 {
1807   LOG_EWK_API_MOCKUP();
1808 }
1809
1810 void ewk_view_360video_pause(Evas_Object* ewkView)
1811 {
1812   LOG_EWK_API_MOCKUP();
1813 }
1814
1815 void ewk_view_360video_duration(Evas_Object* ewkView, Ewk_360_Video_Duration_Callback callback, void* user_data)
1816 {
1817   LOG_EWK_API_MOCKUP();
1818 }
1819
1820 void ewk_view_360video_current_time(Evas_Object* ewkView, Ewk_360_Video_CurrentTime_Callback callback, void* user_data)
1821 {
1822   LOG_EWK_API_MOCKUP();
1823 }
1824
1825 void ewk_view_360video_set_current_time(Evas_Object* ewkView, double current_time)
1826 {
1827   LOG_EWK_API_MOCKUP();
1828 }
1829
1830 Eina_Bool ewk_view_script_execute_all_frames(Evas_Object *o, const char *script, Ewk_View_Script_Execute_Cb callback, void *user_data)
1831 {
1832 #if BUILDFLAG(IS_TIZEN_TV)
1833   LOG(INFO)  << ", view: " << o;
1834 #else
1835   LOG_EWK_API_MOCKUP();
1836 #endif
1837   return EINA_FALSE;
1838 }
1839
1840 void ewk_view_voicemanager_label_draw(Evas_Object* view,
1841                                       Evas_Object* image,
1842                                       Eina_Rectangle rect) {
1843 #if BUILDFLAG(IS_TIZEN_TV)
1844   EINA_SAFETY_ON_NULL_RETURN(image);
1845   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
1846   impl->DrawLabel(image, rect);
1847 #else
1848   LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1849 #endif
1850 }
1851
1852 void ewk_view_voicemanager_labels_clear(Evas_Object* view) {
1853 #if BUILDFLAG(IS_TIZEN_TV)
1854   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
1855   impl->ClearLabels();
1856 #else
1857   LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1858 #endif
1859 }
1860
1861 void ewk_view_floating_window_state_changed(const Evas_Object *view, Eina_Bool status)
1862 {
1863 #if BUILDFLAG(IS_TIZEN_TV)
1864   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
1865   LOG(INFO) << __FUNCTION__ << ", view: "<< view << ", status: " << status;
1866   impl->SetFloatVideoWindowState(status);
1867 #else
1868   LOG_EWK_API_MOCKUP();
1869 #endif
1870 }
1871
1872 void ewk_view_feed_mouse_down(Evas_Object* view,
1873                               Ewk_Mouse_Button_Type button,
1874                               int x,
1875                               int y) {
1876   LOG_EWK_API_MOCKUP("NUI feature is not enabled");
1877 }
1878
1879 void ewk_view_feed_mouse_up(Evas_Object* view,
1880                             Ewk_Mouse_Button_Type button,
1881                             int x,
1882                             int y) {
1883   LOG_EWK_API_MOCKUP("NUI feature is not enabled");
1884 }
1885
1886 void ewk_view_feed_mouse_move(Evas_Object* view, int x, int y) {
1887   LOG_EWK_API_MOCKUP("NUI feature is not enabled");
1888 }
1889
1890 void ewk_view_feed_mouse_wheel(Evas_Object* view,
1891                                Eina_Bool y_direction,
1892                                int step,
1893                                int x,
1894                                int y) {
1895   LOG_EWK_API_MOCKUP("NUI feature is not enabled");
1896 }
1897
1898 void ewk_view_auto_login(Evas_Object *view, const char* user_name, const char* password)
1899 {
1900   LOG_EWK_API_MOCKUP("This API is not supported.");
1901 }
1902
1903 void ewk_view_request_manifest(Evas_Object* o,
1904                                Ewk_View_Request_Manifest_Callback callback,
1905                                void* user_data) {
1906   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl);
1907   impl->RequestManifest(callback, user_data);
1908 }
1909
1910 void ewk_view_media_device_list_get(Evas_Object* o, Ewk_Media_Device_List_Get_Callback callback, void* user_data) {
1911 #if BUILDFLAG(IS_TIZEN_TV)
1912   LOG(INFO) << "ewk_view_media_device_list_get called";
1913   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl);
1914   EINA_SAFETY_ON_NULL_RETURN(callback);
1915   impl->GetMediaDeviceList(callback, user_data);
1916 #else
1917   LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1918 #endif
1919 }
1920
1921 void ewk_view_run_mixed_content_confirm_callback_set(
1922     Evas_Object* /* ewkView */,
1923     Ewk_View_Run_Mixed_Content_Confirm_Callback /* callback */,
1924     void* /* user_data */) {}
1925
1926 void ewk_view_error_page_load_callback_set(Evas_Object* ewk_view, Ewk_View_Error_Page_Load_Callback callback, void* user_data)
1927 {
1928   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
1929   EINA_SAFETY_ON_NULL_RETURN(callback);
1930   impl->SetViewLoadErrorPageCallback(callback, user_data);
1931 }
1932
1933 Eina_Bool ewk_view_add_item_to_back_forward_list(Evas_Object* o, const Ewk_Back_Forward_List_Item* item)
1934 {
1935   return EINA_FALSE;
1936 }
1937
1938 void ewk_view_poweroff_suspend(Evas_Object *item) {}