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 = GetWebViewFromEvasObject(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
 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   return ewk_view_add_with_context(e, context);
 129 }
 130
 131 Evas_Object* ewk_view_add_in_incognito_mode(Evas* e)
 132 {
 133   EINA_SAFETY_ON_NULL_RETURN_VAL(e, nullptr);
 134   Ewk_Context* context = Ewk_Context::IncognitoContext();
 135   EINA_SAFETY_ON_NULL_RETURN_VAL(context, nullptr);
 136   return ewk_view_add_with_context(e, context);
 137 }
 138
 139 Ewk_Context *ewk_view_context_get(const Evas_Object *view)
 140 {
 141   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, 0);
 142   return static_cast<Ewk_Context*>(impl->context());
 143 }
 144
 145 Eina_Bool ewk_view_url_set(Evas_Object* view, const char* url_string)
 146 {
 147   TTRACE_WEB("ewk_view_url_set url: %s", url_string);
 148   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 149   EINA_SAFETY_ON_NULL_RETURN_VAL(url_string, false);
 150   GURL url(url_string);
 151   impl->SetURL(url, true);
 152   return true;
 153 }
 154
 155 const char* ewk_view_url_get(const Evas_Object* view)
 156 {
 157   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, 0);
 158   return impl->GetURL().possibly_invalid_spec().c_str();
 159 }
 160
 161 const char* ewk_view_original_url_get(const Evas_Object* view)
 162 {
 163   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, 0);
 164   return impl->GetOriginalURL().possibly_invalid_spec().c_str();
 165 }
 166
 167 Eina_Bool ewk_view_reload(Evas_Object *view)
 168 {
 169   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 170   impl->Reload();
 171   return true;
 172 }
 173
 174
 175 Eina_Bool ewk_view_reload_bypass_cache(Evas_Object *view)
 176 {
 177   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 178   impl->ReloadBypassingCache();
 179   return true;
 180 }
 181
 182 Eina_Bool ewk_view_stop(Evas_Object* view)
 183 {
 184   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 185   impl->Stop();
 186   return true;
 187 }
 188
 189
 190 Ewk_Settings *ewk_view_settings_get(const Evas_Object *ewkView)
 191 {
 192   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl,0);
 193   return impl->GetSettings();
 194 }
 195
 196 const char* ewk_view_title_get(const Evas_Object* view)
 197 {
 198   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, 0);
 199   return impl->GetTitle();
 200 }
 201
 202 double ewk_view_load_progress_get(const Evas_Object* view)
 203 {
 204   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, -1);
 205   return impl->GetProgressValue();
 206 }
 207
 208 Eina_Bool ewk_view_scale_set(Evas_Object* view, double scale_factor, int x, int y)
 209 {
 210   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 211   impl->SetScale(scale_factor);
 212   impl->SetScroll(x, y);
 213   return EINA_TRUE;
 214 }
 215
 216 void ewk_view_scale_changed_callback_set(
 217     Evas_Object* view,
 218     Ewk_View_Scale_Changed_Callback callback,
 219     void* user_data) {
 220   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 221   impl->SetScaleChangedCallback(callback, user_data);
 222 }
 223
 224 double ewk_view_scale_get(const Evas_Object *view)
 225 {
 226   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, -1);
 227   return impl->GetScale();
 228 }
 229
 230 Eina_Bool ewk_view_back(Evas_Object *view)
 231 {
 232   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 233   return impl->GoBack();
 234 }
 235
 236 Eina_Bool ewk_view_forward(Evas_Object *view)
 237 {
 238   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 239   return impl->GoForward();
 240 }
 241
 242 Eina_Bool ewk_view_back_possible(Evas_Object *view)
 243 {
 244   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 245   return impl->CanGoBack();
 246 }
 247
 248 Eina_Bool ewk_view_forward_possible(Evas_Object *view)
 249 {
 250   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 251   return impl->CanGoForward();
 252 }
 253
 254 Eina_Bool ewk_view_web_login_request(Evas_Object* ewkView)
 255 {
 256   LOG_EWK_API_MOCKUP();
 257   return false;
 258 }
 259
 260 Eina_Bool ewk_view_html_string_load(Evas_Object* view, const char* html, const char* base_uri, const char* unreachable_uri)
 261 {
 262   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 263   EINA_SAFETY_ON_NULL_RETURN_VAL(html, EINA_FALSE);
 264   impl->LoadHTMLString(html, base_uri, unreachable_uri);
 265   return EINA_TRUE;
 266 }
 267
 268 Eina_Bool ewk_view_mouse_events_enabled_set(Evas_Object *view, Eina_Bool enabled)
 269 {
 270   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 271
 272   impl->SetMouseEventsEnabled(!!enabled);
 273
 274   return true;
 275 }
 276
 277 Eina_Bool ewk_view_mouse_events_enabled_get(const Evas_Object *view)
 278 {
 279   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 280
 281   return impl->MouseEventsEnabled();
 282 }
 283
 284 Eina_Bool ewk_view_color_picker_color_set(Evas_Object* ewkView, int r, int g, int b, int a)
 285 {
 286   LOG_EWK_API_MOCKUP();
 287   return false;
 288 }
 289
 290 double ewk_view_text_zoom_get(const Evas_Object* view)
 291 {
 292   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, -1.0);
 293   return impl->GetTextZoomFactor();
 294 }
 295
 296 Eina_Bool ewk_view_text_zoom_set(Evas_Object* view, double text_zoom_level)
 297 {
 298   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 299   if (ewk_settings_text_zoom_enabled_get(ewk_view_settings_get(view))) {
 300    impl->SetTextZoomFactor(text_zoom_level);
 301    return true;
 302   }
 303   return false;
 304 }
 305
 306 void ewk_view_not_found_error_page_load(Evas_Object* ewkView, const char* errorUrl)
 307 {
 308   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 309   impl->LoadNotFoundErrorPage(std::string(errorUrl));
 310 }
 311
 312 void ewk_view_scale_range_get(Evas_Object* view, double* min_scale, double* max_scale)
 313 {
 314   if (!min_scale && !max_scale)
 315     return;
 316
 317   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 318   impl->GetPageScaleRange(min_scale, max_scale);
 319 }
 320
 321 void ewk_view_suspend(Evas_Object* ewkView)
 322 {
 323   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 324   impl->Suspend();
 325 }
 326
 327 void ewk_view_resume(Evas_Object* ewkView)
 328 {
 329   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 330   impl->Resume();
 331 }
 332
 333 Eina_Bool ewk_view_url_request_set(Evas_Object* ewkView, const char* url, Ewk_Http_Method method, Eina_Hash* headers, const char* body)
 334 {
 335   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 336   EINA_SAFETY_ON_NULL_RETURN_VAL(url, EINA_FALSE);
 337   content::NavigationController::LoadURLType loadtype;
 338   switch (method) {
 339   case EWK_HTTP_METHOD_GET:
 340     loadtype = content::NavigationController::LOAD_TYPE_DEFAULT;
 341     break;
 342   case EWK_HTTP_METHOD_POST:
 343     loadtype = content::NavigationController::LOAD_TYPE_HTTP_POST;
 344     break;
 345   default:
 346     LOG(ERROR) << "Not supported HTTP Method.";
 347     return EINA_FALSE;
 348   }
 349
 350   impl->UrlRequestSet(url, loadtype, headers, body);
 351   return EINA_TRUE;
 352 }
 353
 354 Eina_Bool ewk_view_plain_text_set(Evas_Object* view, const char* plain_text)
 355 {
 356   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 357   EINA_SAFETY_ON_NULL_RETURN_VAL(plain_text, EINA_FALSE);
 358   impl->LoadPlainTextString(plain_text);
 359   return EINA_TRUE;
 360 }
 361
 362 Eina_Bool ewk_view_contents_set(Evas_Object* view, const char* contents, size_t contents_size, char* mime_type, char* encoding, char* base_uri)
 363 {
 364   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 365   EINA_SAFETY_ON_NULL_RETURN_VAL(contents, EINA_FALSE);
 366   impl->LoadData(contents, contents_size, mime_type, encoding, base_uri);
 367   return EINA_TRUE;
 368 }
 369
 370 Eina_Bool ewk_view_html_contents_set(Evas_Object* view, const char* html, const char* base_uri)
 371 {
 372   return ewk_view_html_string_load(view, html, base_uri, NULL);
 373 }
 374
 375 Eina_Bool ewk_view_page_visibility_state_set(Evas_Object* ewkView, Ewk_Page_Visibility_State page_visibility_state, Eina_Bool initial_state)
 376 {
 377   // TODO: Should we send initial_state to |Page::setVisibilityState()|?.
 378   // isInitialState parameter seems be true only in the constructor of WebViewImpl.
 379   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 380
 381   return impl->SetPageVisibility(page_visibility_state);
 382 }
 383
 384 Eina_Bool ewk_view_user_agent_set(Evas_Object* ewkView, const char* user_agent)
 385 {
 386   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 387
 388   return impl->SetUserAgent(user_agent);
 389 }
 390
 391 const char* ewk_view_user_agent_get(const Evas_Object* ewkView)
 392 {
 393   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, 0);
 394   return impl->GetUserAgent();
 395 }
 396
 397 Eina_Bool ewk_view_application_name_for_user_agent_set(Evas_Object* ewkView, const char* application_name)
 398 {
 399   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 400   return impl->SetUserAgentAppName(application_name);
 401 }
 402
 403 const char* ewk_view_application_name_for_user_agent_get(const Evas_Object* ewkView)
 404 {
 405   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, 0);
 406   return eina_stringshare_add(impl->GetUserAgentAppName());
 407 }
 408
 409 Eina_Bool ewk_view_custom_header_add(const Evas_Object* ewkView, const char* name, const char* value)
 410 {
 411   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 412   EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
 413   EINA_SAFETY_ON_NULL_RETURN_VAL(value, EINA_FALSE);
 414   EINA_SAFETY_ON_NULL_RETURN_VAL(impl->context(),EINA_FALSE);
 415   return impl->context()->HTTPCustomHeaderAdd(name, value);
 416 }
 417
 418 Eina_Bool ewk_view_custom_header_remove(const Evas_Object* ewkView, const char* name)
 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(impl->context(),EINA_FALSE);
 423   return impl->context()->HTTPCustomHeaderRemove(name);
 424
 425 }
 426
 427 Eina_Bool ewk_view_custom_header_clear(const Evas_Object* ewkView)
 428 {
 429   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 430   EINA_SAFETY_ON_NULL_RETURN_VAL(impl->context(),EINA_FALSE);
 431   impl->context()->HTTPCustomHeaderClear();
 432   return EINA_TRUE;
 433 }
 434
 435
 436 Eina_Bool ewk_view_visibility_set(Evas_Object* view, Eina_Bool enable)
 437 {
 438   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 439   return impl->SetVisibility(enable);
 440 }
 441
 442 Evas_Object* ewk_view_screenshot_contents_get(const Evas_Object* view, Eina_Rectangle view_area, float scale_factor, Evas* canvas)
 443 {
 444   EINA_SAFETY_ON_NULL_RETURN_VAL(canvas, NULL);
 445   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, NULL);
 446   return impl->GetSnapshot(view_area, scale_factor);
 447 }
 448
 449 Eina_Bool ewk_view_screenshot_contents_get_async(const Evas_Object* view, Eina_Rectangle view_area,
 450         float scale_factor, Evas* canvas, Ewk_Web_App_Screenshot_Captured_Callback callback, void* user_data)
 451 {
 452   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
 453   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 454   return impl->GetSnapshotAsync(view_area, callback, user_data, scale_factor)
 455              ? EINA_TRUE
 456              : EINA_FALSE;
 457 }
 458
 459 unsigned int ewk_view_inspector_server_start(Evas_Object* ewkView, unsigned int port)
 460 {
 461   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 462   return impl->StartInspectorServer(port);
 463 }
 464
 465 Eina_Bool ewk_view_inspector_server_stop(Evas_Object* ewkView)
 466 {
 467   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 468   return impl->StopInspectorServer();
 469 }
 470
 471 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)
 472 {
 473   LOG_EWK_API_MOCKUP();
 474   return false;
 475 }
 476
 477 void ewk_view_scroll_by(Evas_Object* ewkView, int deltaX, int deltaY)
 478 {
 479   int x, y;
 480
 481   if (EINA_TRUE == ewk_view_scroll_pos_get(ewkView, &x, &y)) {
 482     ewk_view_scroll_set(ewkView, x + deltaX, y + deltaY);
 483   }
 484 }
 485
 486 Eina_Bool ewk_view_scroll_pos_get(Evas_Object* ewkView, int* x, int* y)
 487 {
 488   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 489   return impl->GetScrollPosition(x, y);
 490 }
 491
 492 Eina_Bool ewk_view_scroll_set(Evas_Object* view, int x, int y)
 493 {
 494   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 495   impl->SetScroll(x, y);
 496
 497   return EINA_TRUE;
 498 }
 499
 500 Eina_Bool ewk_view_scroll_size_get(const Evas_Object* view, int* width, int* height)
 501 {
 502   if (width)
 503     *width = 0;
 504   if (height)
 505     *height = 0;
 506   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 507   impl->GetScrollSize(width,height);
 508   return EINA_TRUE;
 509 }
 510
 511 void ewk_view_clear_tiles_on_hide_enabled_set(Evas_Object* ewkView, Eina_Bool enable)
 512 {
 513   LOG_EWK_API_MOCKUP();
 514 }
 515
 516 void ewk_view_password_confirm_popup_callback_set(Evas_Object* view, Ewk_View_Password_Confirm_Popup_Callback callback, void* user_data)
 517 {
 518   LOG_EWK_API_MOCKUP();
 519 }
 520
 521 void ewk_view_password_confirm_popup_reply(Evas_Object* ewkView, Ewk_Password_Popup_Option result)
 522 {
 523   LOG_EWK_API_MOCKUP();
 524 }
 525
 526 void ewk_view_javascript_alert_callback_set(Evas_Object* view, Ewk_View_JavaScript_Alert_Callback callback, void* user_data)
 527 {
 528   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 529   if (callback)
 530     impl->SetJavaScriptAlertCallback(callback, user_data);
 531 }
 532
 533 void ewk_view_javascript_alert_reply(Evas_Object* view)
 534 {
 535   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 536   impl->JavaScriptAlertReply();
 537 }
 538
 539 void ewk_view_javascript_confirm_callback_set(Evas_Object* view, Ewk_View_JavaScript_Confirm_Callback callback, void* user_data)
 540 {
 541   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 542   if (callback)
 543     impl->SetJavaScriptConfirmCallback(callback, user_data);
 544 }
 545
 546 void ewk_view_javascript_confirm_reply(Evas_Object* view, Eina_Bool result)
 547 {
 548   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 549   impl->JavaScriptConfirmReply(result);
 550 }
 551
 552 void ewk_view_javascript_prompt_callback_set(Evas_Object* view, Ewk_View_JavaScript_Prompt_Callback callback, void* user_data)
 553 {
 554   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 555   if (callback)
 556     impl->SetJavaScriptPromptCallback(callback, user_data);
 557 }
 558
 559 void ewk_view_javascript_prompt_reply(Evas_Object* view, const char* result)
 560 {
 561   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 562   impl->JavaScriptPromptReply(result);
 563 }
 564
 565 void ewk_view_before_unload_confirm_panel_callback_set(Evas_Object* ewkView, Ewk_View_Before_Unload_Confirm_Panel_Callback callback, void* userData)
 566 {
 567   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 568   EINA_SAFETY_ON_NULL_RETURN(callback);
 569   impl->SetBeforeUnloadConfirmPanelCallback(callback, userData);
 570 }
 571
 572 void ewk_view_before_unload_confirm_panel_reply(Evas_Object* ewkView, Eina_Bool result)
 573 {
 574   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 575   impl->ReplyBeforeUnloadConfirmPanel(result);
 576 }
 577
 578 Eina_Bool ewk_view_web_application_capable_get(Evas_Object* ewkView, Ewk_Web_App_Capable_Get_Callback callback, void* userData)
 579 {
 580   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 581   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
 582   return impl->WebAppCapableGet(callback, userData) ? EINA_TRUE : EINA_FALSE;
 583 }
 584
 585 Eina_Bool ewk_view_web_application_icon_url_get(Evas_Object* ewkView, Ewk_Web_App_Icon_URL_Get_Callback callback, void* userData)
 586 {
 587   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 588   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
 589   return impl->WebAppIconUrlGet(callback, userData) ? EINA_TRUE : EINA_FALSE;
 590 }
 591
 592 Eina_Bool ewk_view_web_application_icon_urls_get(Evas_Object* ewkView, Ewk_Web_App_Icon_URLs_Get_Callback callback, void* userData)
 593 {
 594   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 595   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
 596   return impl->WebAppIconUrlsGet(callback, userData) ? EINA_TRUE : EINA_FALSE;
 597 }
 598
 599 Eina_Bool ewk_view_command_execute(Evas_Object* view, const char* command, const char* value)
 600 {
 601   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 602   EINA_SAFETY_ON_NULL_RETURN_VAL(command, false);
 603   impl->ExecuteEditCommand(command, value);
 604   return true;
 605 }
 606
 607 Eina_Bool ewk_view_contents_size_get(const Evas_Object* view, Evas_Coord* width, Evas_Coord* height)
 608 {
 609   if (width)
 610     *width = 0;
 611   if (height)
 612     *height = 0;
 613
 614   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 615   Eina_Rectangle contents_size = impl->GetContentsSize();
 616
 617   if (width)
 618     *width = contents_size.w;
 619   if (height)
 620     *height = contents_size.h;
 621
 622   return EINA_TRUE;
 623 }
 624
 625 Eina_Bool ewk_view_contents_pdf_get(Evas_Object* view, int width, int height, const char* fileName)
 626 {
 627   EINA_SAFETY_ON_NULL_RETURN_VAL(fileName, EINA_FALSE);
 628   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 629   return impl->SaveAsPdf(width, height, fileName);
 630 }
 631
 632 Eina_Bool ewk_view_script_execute(Evas_Object* ewkView, const char* script, Ewk_View_Script_Execute_Callback callback, void* user_data)
 633 {
 634   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, false);
 635   EINA_SAFETY_ON_NULL_RETURN_VAL(script, false);
 636   // callback can be null, so do not test it for null
 637   if (0 != strcmp(script, "")) //check for empty string
 638     return impl->ExecuteJavaScript(script, callback, user_data);
 639   return false;
 640 }
 641
 642
 643 Eina_Bool ewk_view_plain_text_get(Evas_Object* view, Ewk_View_Plain_Text_Get_Callback callback, void* user_data)
 644 {
 645   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 646   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
 647   return (impl->PlainTextGet(callback, user_data));
 648 }
 649
 650 Eina_Bool ewk_view_mhtml_data_get(Evas_Object *view, Ewk_View_MHTML_Data_Get_Callback callback, void *user_data)
 651 {
 652   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
 653   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 654   return impl->GetMHTMLData(callback, user_data);
 655 }
 656
 657 Ewk_Hit_Test* ewk_view_hit_test_new(Evas_Object* ewkView, int x, int y, int hit_test_mode)
 658 {
 659   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, 0);
 660   return impl->RequestHitTestDataAt(x, y,
 661       static_cast<Ewk_Hit_Test_Mode>(hit_test_mode));
 662 }
 663
 664 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)
 665 {
 666   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, EINA_FALSE);
 667   return impl->AsyncRequestHitTestDataAt(x, y, static_cast<Ewk_Hit_Test_Mode>(hit_test_mode), callback, user_data);
 668 }
 669
 670 Ewk_History* ewk_view_history_get(Evas_Object* ewkView)
 671 {
 672   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, NULL);
 673   return impl->GetBackForwardHistory();
 674 }
 675
 676 Eina_Bool ewk_view_notification_closed(Evas_Object* ewkView, Eina_List* notification_list)
 677 {
 678   return EINA_FALSE;
 679 }
 680
 681 Eina_Bool ewk_view_popup_menu_select(Evas_Object* ewkView, unsigned int selectedIndex)
 682 {
 683   LOG_EWK_API_MOCKUP();
 684   return false;
 685 }
 686
 687 Eina_Bool ewk_view_popup_menu_multiple_select(Evas_Object* ewkView, Eina_Inarray* changeList)
 688 {
 689   LOG_EWK_API_MOCKUP();
 690   return false;
 691 }
 692
 693 void ewk_view_orientation_send(Evas_Object* ewkView, int orientation)
 694 {
 695   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 696   impl->SetOrientation(orientation);
 697 }
 698
 699 void ewk_view_encoding_custom_set(Evas_Object* ewkView, const char* encoding)
 700 {
 701   // Chromium does not support this feature hence the comment
 702   LOG_EWK_API_MOCKUP("Not Supported by chromium");
 703 }
 704
 705 Eina_Bool ewk_view_text_selection_range_get(const Evas_Object* view, Eina_Rectangle* left_rect, Eina_Rectangle* right_rect)
 706 {
 707   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 708   if (left_rect && right_rect && impl->GetSelectionRange(left_rect, right_rect)) {
 709     Evas_Coord x, y;
 710     evas_object_geometry_get(view, &x, &y, 0, 0);
 711     left_rect->x += x;
 712     left_rect->y += y;
 713     right_rect->x += x;
 714     right_rect->y += y;
 715     return true;
 716   }
 717   return false;
 718 }
 719
 720 Eina_Bool ewk_view_text_selection_clear(Evas_Object *view)
 721 {
 722   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 723   return impl->ClearSelection();
 724 }
 725
 726 const char* ewk_view_text_selection_text_get(Evas_Object* view)
 727 {
 728   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, NULL);
 729   return impl->CacheSelectedText();
 730 }
 731
 732 void ewk_view_focused_input_element_value_set(Evas_Object* ewkView, const char* value)
 733 {
 734   LOG_EWK_API_MOCKUP();
 735 }
 736
 737 const char* ewk_view_focused_input_element_value_get(Evas_Object* ewkView)
 738 {
 739   LOG_EWK_API_MOCKUP();
 740   return NULL;
 741 }
 742
 743 Eina_Bool ewk_view_horizontal_panning_hold_get(Evas_Object* ewkView) {
 744   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 745   return impl->GetHorizontalPanningHold();
 746 }
 747
 748 void ewk_view_horizontal_panning_hold_set(Evas_Object* ewkView,
 749                                           Eina_Bool hold) {
 750   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 751   impl->SetHorizontalPanningHold(hold);
 752 }
 753
 754 Eina_Bool ewk_view_vertical_panning_hold_get(Evas_Object* ewkView)
 755 {
 756   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
 757   return impl->GetVerticalPanningHold();
 758 }
 759
 760 void ewk_view_vertical_panning_hold_set(Evas_Object* view, Eina_Bool hold) {
 761   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 762   impl->SetVerticalPanningHold(hold);
 763 }
 764
 765 void ewk_view_orientation_lock_callback_set(Evas_Object* ewkView, Ewk_Orientation_Lock_Cb func, void* data)
 766 {
 767   LOG_EWK_API_MOCKUP("This API is deprecated, to use orientation lock/unlock "
 768       "API please use functions lock_orientation/unlock_orientation provided "
 769       "by Ewk_View_Smart_Class.");
 770 }
 771
 772
 773 void ewk_view_back_forward_list_clear(const Evas_Object *view)
 774 {
 775   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 776   impl->BackForwardListClear();
 777 }
 778
 779 Eina_Bool ewk_view_feed_touch_event(Evas_Object *view, Ewk_Touch_Event_Type type, const Eina_List *points, const Evas_Modifier *modifiers)
 780 {
 781   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 782
 783   impl->HandleTouchEvents(type, points, modifiers);
 784
 785   return true;
 786 }
 787
 788 Eina_Bool ewk_view_touch_events_enabled_set(Evas_Object *view, Eina_Bool enabled)
 789 {
 790   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 791
 792   impl->SetTouchEventsEnabled(!!enabled);
 793
 794   return true;
 795 }
 796
 797 Eina_Bool ewk_view_touch_events_enabled_get(const Evas_Object *view)
 798 {
 799   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, false);
 800
 801   return impl->TouchEventsEnabled();
 802 }
 803
 804 Ewk_Frame_Ref ewk_view_main_frame_get(Evas_Object* o)
 805 {
 806   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, NULL);
 807   return static_cast<Ewk_Frame_Ref>(impl->GetMainFrame());
 808 }
 809
 810 void ewk_view_content_security_policy_set(Evas_Object* ewkView, const char* policy, Ewk_CSP_Header_Type type)
 811 {
 812   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 813   EINA_SAFETY_ON_NULL_RETURN(policy);
 814   impl->SetContentSecurityPolicy(policy, type);
 815 }
 816
 817 void ewk_view_application_cache_permission_callback_set(Evas_Object* ewkView, Ewk_View_Applicacion_Cache_Permission_Callback callback, void* userData)
 818 {
 819   // Chromium does not support this feature hence the comment
 820   LOG_EWK_API_MOCKUP("Not Supported by chromium");
 821 }
 822
 823 void ewk_view_application_cache_permission_reply(Evas_Object* ewkView, Eina_Bool allow)
 824 {
 825   // Chromium does not support this feature hence the comment
 826   LOG_EWK_API_MOCKUP("Not Supported by chromium");
 827 }
 828
 829 void ewk_view_exceeded_indexed_database_quota_callback_set(Evas_Object* view, Ewk_View_Exceeded_Indexed_Database_Quota_Callback callback, void* user_data)
 830 {
 831   // Chromium does not support quota for Indexed DB only.
 832   // IndexedDB uses temporary storage that is shared
 833   // between other features.
 834   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 835   impl->SetExceededIndexedDatabaseQuotaCallback(callback, user_data);
 836 }
 837
 838 void ewk_view_exceeded_indexed_database_quota_reply(Evas_Object* view, Eina_Bool allow)
 839 {
 840   // Chromium does not support quota for Indexed DB only.
 841   // IndexedDB uses temporary storage that is shared
 842   // between other features.
 843   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
 844   impl->ExceededIndexedDatabaseQuotaReply(allow);
 845 }
 846
 847 Eina_Bool ewk_view_text_find(Evas_Object *view, const char *text, Ewk_Find_Options options, unsigned int max_match_count)
 848 {
 849   // FIXME: We need to implement next options in Ewk_Find_Options struct. (refer to ewk_view.h)
 850   //         - EWK_FIND_OPTIONS_AT_WORD_STARTS
 851   //         - EWK_FIND_OPTIONS_TREAT_MEDIAL_CAPITAL_AS_WORD_START
 852   //         - EWK_FIND_OPTIONS_WRAP_AROUND
 853   //         - EWK_FIND_OPTIONS_SHOW_OVERLAY
 854   //         - EWK_FIND_OPTIONS_SHOW_FIND_INDICATOR
 855   //         - EWK_FIND_OPTIONS_SHOW_HIGHLIGHT (Currently there is no way to control this option. so it is always set)
 856
 857   // FIXME: Updating of max_match_count is not implemented.
 858
 859   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 860   EINA_SAFETY_ON_NULL_RETURN_VAL(text, EINA_FALSE);
 861   impl->Find(text, options);
 862   return EINA_TRUE;
 863 }
 864
 865 Eina_Bool ewk_view_text_find_highlight_clear(Evas_Object *view)
 866 {
 867   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
 868   impl->StopFinding();
 869   return EINA_TRUE;
 870 }
 871
 872 void ewk_view_exceeded_database_quota_callback_set(Evas_Object* ewkView, Ewk_View_Exceeded_Database_Quota_Callback callback, void* userData)
 873 {
 874   // According to chromium source code:
 875   // src/third_party/WebKit/Source/modules/webdatabase/SQLTransactionClient.cpp line 67
 876   // Chromium does not allow users to manually change the quota for an origin (for now, at least).
 877   // This API is impossible to implement right now
 878   LOG_EWK_API_MOCKUP("Not Supported by chromium");
 879 }
 880
 881 void ewk_view_exceeded_database_quota_reply(Evas_Object* ewkView, Eina_Bool allow)
 882 {
 883   // According to chromium source code:
 884   // src/third_party/WebKit/Source/modules/webdatabase/SQLTransactionClient.cpp line 67
 885   // Chromium does not allow users to manually change the quota for an origin (for now, at least).
 886   // This API is impossible to implement right now
 887   LOG_EWK_API_MOCKUP("Not Supported by chromium");
 888 }
 889
 890 void ewk_view_exceeded_local_file_system_quota_callback_set(Evas_Object* ewkView, Ewk_View_Exceeded_Indexed_Database_Quota_Callback callback, void* userData)
 891 {
 892   LOG_EWK_API_MOCKUP();
 893 }
 894
 895 void ewk_view_exceeded_local_file_system_quota_reply(Evas_Object* ewkView, Eina_Bool allow)
 896 {
 897   LOG_EWK_API_MOCKUP();
 898 }
 899
 900 void ewk_view_unfocus_allow_callback_set(Evas_Object* ewkView, Ewk_View_Unfocus_Allow_Callback callback, void* user_data)
 901 {
 902   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 903   impl->SetViewUnfocusAllowCallback(callback, user_data);
 904 }
 905
 906 void ewk_view_geolocation_permission_callback_set(Evas_Object* ewk_view, Ewk_View_Geolocation_Permission_Callback callback, void* user_data)
 907 {
 908   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
 909   impl->SetViewGeolocationPermissionCallback(callback, user_data);
 910 }
 911
 912 static Eina_Bool _ewk_view_default_geolocation_permission(
 913     Evas_Object* ewk_view,
 914     Ewk_Geolocation_Permission_Request* request,
 915     void* user_data)
 916 {
 917   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl, EINA_FALSE);
 918
 919   std::string value = std::string(ewk_security_origin_host_get(
 920       ewk_geolocation_permission_request_origin_get(request)));
 921   std::string message = std::string(
 922       "Web Page (%s) is requesting permission to access your location.");
 923   std::string replace_str = std::string("(%s)");
 924
 925   size_t pos = message.find(replace_str.c_str());
 926   if (pos != std::string::npos)
 927     message.replace(pos, replace_str.length(), value.c_str());
 928
 929   // add for suspending
 930   ewk_geolocation_permission_request_suspend(request);
 931
 932   GeolocationPermissionPopup* popup = new GeolocationPermissionPopup(request,
 933       ewk_geolocation_permission_request_origin_get(request), message);
 934
 935   impl->GetPermissionPopupManager()->AddPermissionRequest(popup);
 936
 937   return EINA_TRUE;
 938 }
 939
 940 void ewk_view_user_media_permission_callback_set(Evas_Object* ewk_view,
 941     Ewk_View_User_Media_Permission_Callback callback,
 942     void* user_data)
 943 {
 944   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
 945   impl->SetViewUserMediaPermissionCallback(callback, user_data);
 946 }
 947
 948 void ewk_view_user_media_permission_query_callback_set(
 949     Evas_Object* ewk_view,
 950     Ewk_View_User_Media_Permission_Query_Callback callback,
 951     void* user_data) {
 952   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
 953   impl->SetViewUserMediaPermissionQueryCallback(callback, user_data);
 954 }
 955
 956 static Eina_Bool _ewk_view_default_user_media_permission(
 957     Evas_Object* ewk_view,
 958     Ewk_User_Media_Permission_Request* user_media_permission_request,
 959     void* user_data)
 960 {
 961   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl, EINA_FALSE);
 962
 963   std::string message =
 964     CreatePermissionMessageRequest(user_media_permission_request);
 965
 966   // add for suspending
 967   ewk_user_media_permission_request_suspend(user_media_permission_request);
 968
 969   UserMediaPermissionPopup* popup = new UserMediaPermissionPopup(
 970       user_media_permission_request,
 971       ewk_user_media_permission_request_origin_get(
 972           user_media_permission_request), message);
 973
 974   impl->GetPermissionPopupManager()->AddPermissionRequest(popup);
 975
 976   return EINA_TRUE;
 977 }
 978
 979 void ewk_view_use_settings_font(Evas_Object* ewkView)
 980 {
 981   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
 982   impl->UseSettingsFont();
 983 }
 984
 985 char* ewk_view_get_cookies_for_url(Evas_Object* view, const char* url)
 986 {
 987   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, 0);
 988   EINA_SAFETY_ON_NULL_RETURN_VAL(url, 0);
 989   EINA_SAFETY_ON_NULL_RETURN_VAL(impl->context(), 0);
 990   std::string cookiesForURL =
 991       impl->context()->cookieManager()->GetCookiesForURL(std::string(url));
 992   if (cookiesForURL.empty())
 993     return NULL;
 994   return strndup(cookiesForURL.c_str(), cookiesForURL.length());
 995 }
 996
 997 Eina_Bool ewk_view_fullscreen_exit(Evas_Object* view)
 998 {
 999   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1000   impl->ExitFullscreen();
1001   return EINA_TRUE;
1002 }
1003
1004 Eina_Bool ewk_view_draws_transparent_background_set(Evas_Object *view, Eina_Bool enabled)
1005 {
1006   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1007   impl->SetDrawsTransparentBackground(enabled);
1008   return EINA_TRUE;
1009 }
1010
1011 void ewk_view_browser_font_set(Evas_Object* ewkView)
1012 {
1013   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1014   impl->SetBrowserFont();
1015 }
1016
1017 void ewk_view_session_data_get(Evas_Object* ewkView, const char** data, unsigned* length)
1018 {
1019   EINA_SAFETY_ON_NULL_RETURN(data);
1020   EINA_SAFETY_ON_NULL_RETURN(length);
1021
1022   EWebView* impl = GetWebViewFromEvasObject(ewkView);
1023   if (!impl) {
1024     *data = NULL;
1025     *length = 0;
1026     return;
1027   }
1028
1029   impl->GetSessionData(data, length);
1030 }
1031
1032 Eina_Bool ewk_view_mode_set(Evas_Object* ewkView, Ewk_View_Mode view_mode)
1033 {
1034   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
1035
1036   if (view_mode == EWK_VIEW_MODE_WINDOWED) {
1037 #if !defined(EWK_BRINGUP)  // FIXME: m67 bringup
1038     impl->SetViewMode(blink::WebViewModeWindowed);
1039 #endif
1040     return EINA_TRUE;
1041   } else if (view_mode == EWK_VIEW_MODE_FULLSCREEN) {
1042 #if !defined(EWK_BRINGUP)  // FIXME: m67 bringup
1043     impl->SetViewMode(blink::WebViewModeFullscreen);
1044 #endif
1045     return EINA_TRUE;
1046   } else {
1047     return EINA_FALSE;
1048   }
1049 }
1050
1051 Eina_Bool ewk_view_split_scroll_overflow_enabled_set(Evas_Object* ewkView, const Eina_Bool enabled)
1052 {
1053   LOG_EWK_API_MOCKUP("for browser");
1054   return false;
1055 }
1056
1057 Ewk_Back_Forward_List* ewk_view_back_forward_list_get(const Evas_Object* ewkView)
1058 {
1059   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, NULL);
1060   return impl->GetBackForwardList();
1061 }
1062
1063 void ewk_view_notification_permission_callback_set(Evas_Object *o, Ewk_View_Notification_Permission_Callback callback, void *user_data)
1064 {
1065   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl);
1066   impl->SetNotificationPermissionCallback(callback, user_data);
1067 }
1068
1069 static Eina_Bool _ewk_view_default_notification_permission(
1070     Evas_Object* ewk_view,
1071     Ewk_Notification_Permission_Request* request,
1072     void* user_data)
1073 {
1074   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl, EINA_FALSE);
1075
1076   std::string value = std::string(ewk_security_origin_host_get(
1077       ewk_notification_permission_request_origin_get(request)));
1078   std::string message = std::string(
1079       "Web Page (%s) is requesting permission to show notifications.");
1080   std::string replace_str = std::string("(%s)");
1081
1082   size_t pos = message.find(replace_str.c_str());
1083   if (pos != std::string::npos)
1084     message.replace(pos, replace_str.length(), value.c_str());
1085
1086   // add for suspending
1087   ewk_notification_permission_request_suspend(request);
1088
1089   NotificationPermissionPopup* popup = new NotificationPermissionPopup(request,
1090       ewk_notification_permission_request_origin_get(request), message);
1091
1092   impl->GetPermissionPopupManager()->AddPermissionRequest(popup);
1093
1094   return EINA_TRUE;
1095 }
1096
1097 void ewk_view_draw_focus_ring_enable_set(Evas_Object* ewkView, Eina_Bool enable)
1098 {
1099   LOG_EWK_API_MOCKUP("This API is deprecated");
1100 }
1101
1102 double ewk_view_page_zoom_get(const Evas_Object* ewkView)
1103 {
1104   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, -1.0);
1105   return impl->GetPageZoomFactor();
1106 }
1107
1108 Eina_Bool ewk_view_page_zoom_set(Evas_Object* ewkView, double zoomFactor)
1109 {
1110   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
1111   impl->SetPageZoomFactor(zoomFactor);
1112   return EINA_TRUE;
1113 }
1114
1115 Evas_Object* ewk_view_smart_add(Evas* canvas, Evas_Smart* smart, Ewk_Context* context, Ewk_Page_Group* pageGroup)
1116 {
1117   EINA_SAFETY_ON_NULL_RETURN_VAL(context, 0);
1118   return CreateWebViewAsEvasObject(context, canvas, smart);
1119 }
1120
1121 void ewk_view_quota_permission_request_callback_set(Evas_Object* ewkView, Ewk_Quota_Permission_Request_Callback callback, void* user_data)
1122 {
1123   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1124   impl->SetQuotaPermissionRequestCallback(callback, user_data);
1125 }
1126
1127 void ewk_view_quota_permission_request_reply(const Ewk_Quota_Permission_Request* request, const Eina_Bool allow)
1128 {
1129   EINA_SAFETY_ON_NULL_RETURN(request);
1130   Evas_Object* ewkView = request->getView();
1131   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1132   impl->QuotaRequestReply(request, allow == EINA_TRUE);
1133 }
1134
1135 void ewk_view_quota_permission_request_cancel(const Ewk_Quota_Permission_Request* request)
1136 {
1137   EINA_SAFETY_ON_NULL_RETURN(request);
1138   Evas_Object* ewkView = request->getView();
1139   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl);
1140   impl->QuotaRequestCancel(request);
1141 }
1142
1143 Eina_Bool ewk_view_focus_set(const Evas_Object* view, Eina_Bool focused)
1144 {
1145   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1146   impl->SetFocus(focused);
1147   return EINA_TRUE;
1148 }
1149
1150 Eina_Bool ewk_view_focus_get(const Evas_Object* view)
1151 {
1152   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1153   return impl->HasFocus();
1154 }
1155
1156 Eina_Bool ewk_view_page_close(Evas_Object* o)
1157 {
1158   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, EINA_FALSE);
1159
1160   impl->ClosePage();
1161   return EINA_TRUE;
1162 }
1163
1164 void ewk_view_session_timeout_set(Evas_Object* o, unsigned long timeout)
1165 {
1166   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl);
1167   impl->SetSessionTimeout(timeout);
1168 }
1169
1170 Evas_Object* ewk_view_widget_get(Evas_Object* view)
1171 {
1172   LOG_EWK_API_MOCKUP();
1173   return NULL;
1174 }
1175
1176 Eina_Bool ewk_view_draws_transparent_background_get(Evas_Object* o)
1177 {
1178   LOG_EWK_API_MOCKUP();
1179   return false;
1180 }
1181
1182 Eina_Bool ewk_view_did_change_theme_color_callback_set(
1183     Evas_Object* o,
1184     Ewk_View_Did_Change_Theme_Color_Callback callback,
1185     void* user_data) {
1186   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, EINA_FALSE);
1187   impl->SetDidChangeThemeColorCallback(callback, user_data);
1188   return EINA_TRUE;
1189 }
1190
1191 Eina_Bool ewk_view_split_scroll_overflow_enabled_get(const Evas_Object* o) {
1192   LOG_EWK_API_MOCKUP();
1193   return false;
1194 }
1195
1196 Eina_Bool ewk_view_save_page_as_mhtml(Evas_Object* o, const char* path, Ewk_View_Save_Page_Callback callback, void* user_data)
1197 {
1198   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl, EINA_FALSE);
1199   EINA_SAFETY_ON_NULL_RETURN_VAL(path, EINA_FALSE);
1200   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
1201   return impl->SavePageAsMHTML(path, callback, user_data);
1202 }
1203
1204 void ewk_view_reader_mode_set(Evas_Object* ewk_view, Eina_Bool enable)
1205 {
1206   LOG_EWK_API_MOCKUP();
1207 }
1208
1209 Eina_Bool ewk_view_top_controls_height_set(Evas_Object* ewk_view, size_t top_height, size_t bottom_height)
1210 {
1211   LOG_EWK_API_MOCKUP();
1212   return false;
1213 }
1214
1215 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)
1216 {
1217   LOG_EWK_API_MOCKUP();
1218   return false;
1219 }
1220
1221 Eina_Bool ewk_view_main_frame_scrollbar_visible_set(Evas_Object* ewk_view,
1222                                                     Eina_Bool visible) {
1223   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl, EINA_FALSE);
1224   return impl->SetMainFrameScrollbarVisible(!!visible);
1225 }
1226
1227 Eina_Bool ewk_view_main_frame_scrollbar_visible_get(
1228     Evas_Object* ewk_view,
1229     Ewk_View_Main_Frame_Scrollbar_Visible_Get_Callback callback,
1230     void* user_data) {
1231   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
1232   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl, EINA_FALSE);
1233
1234   return impl->GetMainFrameScrollbarVisible(callback, user_data);
1235 }
1236
1237 Eina_Bool ewk_view_set_custom_device_pixel_ratio(Evas_Object* ewkView, Eina_Bool enabled)
1238 {
1239   LOG_EWK_API_MOCKUP();
1240   return false;
1241 }
1242
1243 #if BUILDFLAG(IS_TIZEN_TV)
1244 Eina_Bool ewk_media_translated_url_set(Evas_Object* ewkView, const char* url)
1245 {
1246   LOG_EWK_API_MOCKUP();
1247   return false;
1248 }
1249
1250 Eina_Bool ewk_view_app_preload_set(Evas_Object* ewkView, Eina_Bool is_preload)
1251 {
1252   LOG_EWK_API_MOCKUP();
1253   return false;
1254 }
1255 #endif
1256
1257 Evas_Object* ewk_view_favicon_get(const Evas_Object* ewkView)
1258 {
1259   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, nullptr);
1260   EINA_SAFETY_ON_NULL_RETURN_VAL(impl->context(), nullptr);
1261   const char* url = ewk_view_url_get(ewkView);
1262   return impl->context()->AddFaviconObject(url, impl->GetEvas());
1263 }
1264
1265 Eina_Bool ewk_view_html_string_override_current_entry_load(Evas_Object* view, const char* html, const char* base_uri, const char* unreachable_url)
1266 {
1267   LOG_EWK_API_MOCKUP();
1268   return false;
1269 }
1270
1271 Eina_Bool ewk_view_text_matches_count(Evas_Object* o, const char* text, Ewk_Find_Options options, unsigned max_match_count)
1272 {
1273   LOG_EWK_API_MOCKUP();
1274   return false;
1275 }
1276
1277 void ewk_view_mirrored_blur_set(Evas_Object* o, Eina_Bool state)
1278 {
1279   LOG_EWK_API_MOCKUP();
1280 }
1281
1282 void ewk_view_add_dynamic_certificate_path(const Evas_Object *ewkView, const char* host, const char* cert_path)
1283 {
1284   LOG_EWK_API_MOCKUP();
1285 }
1286
1287 void ewk_view_atk_deactivation_by_app(Evas_Object* view, Eina_Bool enable)
1288 {
1289   LOG_EWK_API_MOCKUP();
1290 }
1291
1292 char* ewk_view_cookies_get(Evas_Object* o, const char* url)
1293 {
1294   LOG_EWK_API_MOCKUP();
1295   return NULL;
1296 }
1297
1298 void ewk_view_notification_show_callback_set(Evas_Object *o, Ewk_View_Notification_Show_Callback show_callback, void *user_data)
1299 {
1300   LOG_EWK_API_MOCKUP();
1301 }
1302
1303 void ewk_view_notification_cancel_callback_set(Evas_Object *o, Ewk_View_Notification_Cancel_Callback cancel_callback, void *user_data)
1304 {
1305   LOG_EWK_API_MOCKUP();
1306 }
1307
1308 const char* ewk_view_custom_encoding_get(const Evas_Object* o)
1309 {
1310   LOG_EWK_API_MOCKUP();
1311   return NULL;
1312 }
1313
1314 Eina_Bool ewk_view_custom_encoding_set(Evas_Object* o, const char* encoding)
1315 {
1316   LOG_EWK_API_MOCKUP();
1317   return false;
1318 }
1319
1320 void ewk_view_force_layout(const Evas_Object* o)
1321 {
1322   LOG_EWK_API_MOCKUP();
1323 }
1324
1325 Eina_Bool ewk_view_send_key_event(Evas_Object* ewk_view, void* key_event, Eina_Bool is_press) {
1326   LOG_EWK_API_MOCKUP();
1327   return false;
1328 }
1329
1330 Eina_Bool ewk_view_tts_mode_set(Evas_Object* view, ewk_tts_mode tts_mode) {
1331 #if defined(TIZEN_WEB_SPEECH_RECOGNITION)
1332   switch (tts_mode) {
1333     case EWK_TTS_MODE_DEFAULT:
1334       content::TtsPlatformImplTizen::SetTtsMode(TTS_MODE_DEFAULT);
1335       break;
1336     case EWK_TTS_MODE_NOTIFICATION:
1337       content::TtsPlatformImplTizen::SetTtsMode(TTS_MODE_NOTIFICATION);
1338       break;
1339     case EWK_TTS_MODE_SCREEN_READER:
1340       content::TtsPlatformImplTizen::SetTtsMode(TTS_MODE_SCREEN_READER);
1341       break;
1342     default:
1343       LOG(ERROR) << "Not supported TTS mode: " << static_cast<int>(tts_mode);
1344       return EINA_FALSE;
1345   }
1346   return EINA_TRUE;
1347 #else
1348   LOG_EWK_API_MOCKUP("API unavailable.");
1349   return EINA_FALSE;
1350 #endif
1351 }
1352
1353 Eina_Bool ewk_view_javascript_message_handler_add(
1354     Evas_Object* view,
1355     Ewk_View_Script_Message_Cb callback,
1356     const char* name) {
1357   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1358   EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
1359   return impl->AddJavaScriptMessageHandler(view, callback, std::string(name));
1360 }
1361
1362 Eina_Bool ewk_view_evaluate_javascript(Evas_Object* view,
1363                                        const char* name,
1364                                        const char* result) {
1365   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1366   EINA_SAFETY_ON_NULL_RETURN_VAL(result, EINA_FALSE);
1367   EINA_SAFETY_ON_NULL_RETURN_VAL(name, EINA_FALSE);
1368
1369   std::string function(name);
1370   std::string data(result);
1371   std::string pattern("\n");
1372   std::string replace("</br>");
1373   std::string::size_type pos = 0;
1374   std::string::size_type offset = 0;
1375   while ((pos = data.find(pattern, offset)) != std::string::npos) {
1376     data.replace(data.begin() + pos, data.begin() + pos + pattern.size(),
1377                  replace);
1378     offset = pos + replace.size();
1379   }
1380
1381   // For JSON Object or Array.
1382   if (result[0] == '{' || result[0] == '[') {
1383     data = "javascript:" + function + "(JSON.parse('" + data + "'))";
1384   } else {
1385     data = "javascript:" + function + "('" + data + "')";
1386   }
1387
1388   return impl->ExecuteJavaScript(data.c_str(), NULL, 0);
1389 }
1390
1391 void ewk_view_authentication_callback_set(
1392     Evas_Object* ewk_view,
1393     Ewk_View_Authentication_Callback callback,
1394     void* user_data)
1395 {
1396   EWK_VIEW_IMPL_GET_OR_RETURN(ewk_view, impl);
1397   impl->SetViewAuthCallback(callback, user_data);
1398
1399 }
1400
1401 static void _ewk_view_default_authentication(Evas_Object* ewk_view,
1402                                              Ewk_Auth_Challenge* auth_challenge,
1403                                              void* user_data)
1404 {
1405   AuthenticationChallengePopup::CreateAndShow(auth_challenge, ewk_view);
1406 }
1407
1408 void ewk_view_app_installation_request_callback_set(Evas_Object* o, Ewk_App_Installation_Request_Callback callback, void* user_data)
1409 {
1410   LOG_EWK_API_MOCKUP();
1411 }
1412
1413 Eina_Bool ewk_view_bg_color_set(Evas_Object* o, int r, int g, int b, int a) {
1414   LOG_EWK_API_MOCKUP("This will be implemented soon");
1415   return false;
1416 }
1417
1418 Eina_Bool ewk_view_key_events_enabled_set(Evas_Object* o, Eina_Bool enabled) {
1419   LOG_EWK_API_MOCKUP();
1420   return false;
1421 }
1422
1423 Eina_Bool ewk_view_bg_color_get(Evas_Object* view,
1424                                 Ewk_View_Background_Color_Get_Callback callback,
1425                                 void* user_data) {
1426   EINA_SAFETY_ON_NULL_RETURN_VAL(callback, EINA_FALSE);
1427   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl, EINA_FALSE);
1428
1429   return impl->GetBackgroundColor(callback, user_data);
1430 }
1431
1432 void ewk_view_clear_all_tiles_resources(Evas_Object* ewkView) {
1433   LOG_EWK_API_MOCKUP();
1434 }
1435
1436 Eina_Bool ewk_view_edge_scroll_by(Evas_Object *ewkView, int dx, int dy)
1437 {
1438   LOG_EWK_API_MOCKUP();
1439   return EINA_FALSE;
1440 }
1441
1442 Eina_Bool ewk_view_set_support_video_hole(Evas_Object* ewkView,
1443                                           void* window,
1444                                           Eina_Bool enable,
1445                                           Eina_Bool isVideoWindow) {
1446   LOG_EWK_API_MOCKUP();
1447 #if defined(TIZEN_VIDEO_HOLE)
1448   EWK_VIEW_IMPL_GET_OR_RETURN(ewkView, impl, EINA_FALSE);
1449   impl->SetVideoHoleSupport(enable);
1450   media::VideoPlaneController::SetSharedVideoWindowHandle(
1451       window,
1452       static_cast<media::VideoPlaneController::RenderingMode>(isVideoWindow));
1453   return EINA_TRUE;
1454 #else
1455   LOG_EWK_API_MOCKUP("Video Hole feature is not enabled");
1456   return EINA_FALSE;
1457 #endif
1458 }
1459
1460 void ewk_view_widget_pepper_extension_callback_set(Evas_Object* ewk_view, Generic_Sync_Call_Callback cb, void* user_data) {
1461   LOG_EWK_API_MOCKUP();
1462 }
1463
1464 void ewk_view_widget_pepper_extension_info_set(Evas_Object* ewk_view, Ewk_Value widget_pepper_ext_info) {
1465   LOG_EWK_API_MOCKUP();
1466 }
1467
1468 void ewk_view_offscreen_rendering_enabled_set(Evas_Object* o, Eina_Bool enabled)
1469 {
1470   LOG_EWK_API_MOCKUP();
1471 }
1472
1473 void ewk_view_ime_window_set(Evas_Object* o, void* window)
1474 {
1475   LOG_EWK_API_MOCKUP();
1476 }
1477
1478 void ewk_view_smartrc_show_mic_notification_callback_set(Evas_Object* o, Ewk_View_SmartRC_Mic_Notification_Callback callback, void* user_data)
1479 {
1480   LOG_EWK_API_MOCKUP();
1481 }
1482
1483 Eina_Bool ewk_view_set_support_canvas_hole(Evas_Object* ewkView, const char* url)
1484 {
1485   LOG_EWK_API_MOCKUP();
1486   return EINA_FALSE;
1487 }
1488
1489 void ewk_view_tile_cover_area_multiplier_set(Evas_Object* ewkView,
1490                                              float cover_area_multiplier) {
1491   LOG_EWK_API_MOCKUP();
1492 }
1493
1494 Eina_Bool ewk_view_marlin_enable_set(Evas_Object* ewkView, Eina_Bool is_enable)
1495 {
1496   LOG_EWK_API_MOCKUP();
1497   return EINA_FALSE;
1498 }
1499
1500 Eina_Bool ewk_view_key_system_whitelist_set(Evas_Object* ewkView, const char** list, unsigned list_size)
1501 {
1502   LOG_EWK_API_MOCKUP();
1503   return EINA_FALSE;
1504 }
1505
1506 Eina_Bool ewk_view_active_drm_set(Evas_Object* view, const char* drm_system_id)
1507 {
1508   LOG_EWK_API_MOCKUP();
1509   return EINA_FALSE;
1510 }
1511
1512 void ewk_media_set_subtitle_lang(Evas_Object* ewkView, const char* lang_list)
1513 {
1514   LOG_EWK_API_MOCKUP();
1515 }
1516
1517 void ewk_media_set_parental_rating_result(Evas_Object* ewkView, const char* url, Eina_Bool is_pass)
1518 {
1519   LOG_EWK_API_MOCKUP();
1520 }
1521
1522 void ewk_media_start_with_high_bit_rate(Evas_Object* ewkView, Eina_Bool is_high_bitrate)
1523 {
1524   LOG_EWK_API_MOCKUP();
1525 }
1526
1527 double ewk_view_media_current_time_get(const Evas_Object *o)
1528 {
1529   LOG_EWK_API_MOCKUP();
1530   return 0;
1531 }
1532
1533 void ewk_view_request_canvas_fullscreen(Evas_Object* ewkView)
1534 {
1535   LOG_EWK_API_MOCKUP();
1536 }
1537
1538 void ewk_view_360video_play(Evas_Object* ewkView)
1539 {
1540   LOG_EWK_API_MOCKUP();
1541 }
1542
1543 void ewk_view_360video_pause(Evas_Object* ewkView)
1544 {
1545   LOG_EWK_API_MOCKUP();
1546 }
1547
1548 void ewk_view_360video_duration(Evas_Object* ewkView, Ewk_360_Video_Duration_Callback callback, void* user_data)
1549 {
1550   LOG_EWK_API_MOCKUP();
1551 }
1552
1553 void ewk_view_360video_current_time(Evas_Object* ewkView, Ewk_360_Video_CurrentTime_Callback callback, void* user_data)
1554 {
1555   LOG_EWK_API_MOCKUP();
1556 }
1557
1558 void ewk_view_360video_set_current_time(Evas_Object* ewkView, double current_time)
1559 {
1560   LOG_EWK_API_MOCKUP();
1561 }
1562
1563 Eina_Bool ewk_view_script_execute_all_frames(Evas_Object *o, const char *script, Ewk_View_Script_Execute_Cb callback, void *user_data)
1564 {
1565   LOG_EWK_API_MOCKUP();
1566   return EINA_FALSE;
1567 }
1568
1569 void ewk_view_voicemanager_label_draw(Evas_Object* view,
1570                                       Evas_Object* image,
1571                                       Eina_Rectangle rect) {
1572 #if BUILDFLAG(IS_TIZEN_TV)
1573   EINA_SAFETY_ON_NULL_RETURN(image);
1574   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
1575   impl->DrawLabel(image, rect);
1576 #else
1577   LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1578 #endif
1579 }
1580
1581 void ewk_view_voicemanager_labels_clear(Evas_Object* view) {
1582 #if BUILDFLAG(IS_TIZEN_TV)
1583   EWK_VIEW_IMPL_GET_OR_RETURN(view, impl);
1584   impl->ClearLabels();
1585 #else
1586   LOG_EWK_API_MOCKUP("Only for Tizen TV.");
1587 #endif
1588 }
1589
1590 void ewk_view_floating_window_state_changed(const Evas_Object *o, Eina_Bool status)
1591 {
1592   LOG_EWK_API_MOCKUP();
1593 }
1594
1595 void ewk_view_feed_mouse_down(Evas_Object* view,
1596                               Ewk_Mouse_Button_Type button,
1597                               int x,
1598                               int y) {
1599   LOG_EWK_API_MOCKUP("NUI feature is not enabled");
1600 }
1601
1602 void ewk_view_feed_mouse_up(Evas_Object* view,
1603                             Ewk_Mouse_Button_Type button,
1604                             int x,
1605                             int y) {
1606   LOG_EWK_API_MOCKUP("NUI feature is not enabled");
1607 }
1608
1609 void ewk_view_feed_mouse_move(Evas_Object* view, int x, int y) {
1610   LOG_EWK_API_MOCKUP("NUI feature is not enabled");
1611 }
1612
1613 void ewk_view_feed_mouse_wheel(Evas_Object* view,
1614                                Eina_Bool y_direction,
1615                                int step,
1616                                int x,
1617                                int y) {
1618   LOG_EWK_API_MOCKUP("NUI feature is not enabled");
1619 }
1620
1621 void ewk_view_auto_login(Evas_Object *view, const char* user_name, const char* password)
1622 {
1623   LOG_EWK_API_MOCKUP();
1624 }
1625
1626 void ewk_view_request_manifest(Evas_Object* o,
1627                                Ewk_View_Request_Manifest_Callback callback,
1628                                void* user_data) {
1629   EWK_VIEW_IMPL_GET_OR_RETURN(o, impl);
1630   impl->RequestManifest(callback, user_data);
1631 }