#ifndef EWEB_VIEW_H
#define EWEB_VIEW_H
-#if !defined(EWK_BRINGUP) // FIXME: m67 bringup
-// FIXME: appfw/app_service.h is no more in Tizen 2.3, figure out what to
-// include instead.
-#include <appcore-agent/service_app.h>
-#endif
-
#include <map>
#include <string>
#include <Evas.h>
#include <locale.h>
#include <vector>
-#include "base/callback.h"
#include "base/containers/id_map.h"
+#include "base/functional/callback.h"
#include "base/synchronization/waitable_event.h"
-#include "browser/inputpicker/InputPicker.h"
-#include "browser/selectpicker/popup_picker.h"
-#include "content/browser/renderer_host/event_with_latency_info.h"
+#include "browser/input_picker/input_picker.h"
+#include "content/browser/select_picker/select_picker_base.h"
#include "content/browser/selection/selection_controller_efl.h"
+#include "content/browser/web_contents/web_contents_view_aura.h"
+#include "content/browser/web_contents/web_contents_view_aura_helper_efl.h"
+#include "content/common/input/event_with_latency_info.h"
+#include "content/public/browser/context_menu_params.h"
#include "content/public/browser/navigation_controller.h"
-#include "content/public/browser/quota_permission_context.h"
#include "content/public/browser/web_contents_delegate.h"
-#include "content/public/browser/web_contents_efl_delegate.h"
-#include "content/public/common/context_menu_params.h"
+#include "content/public/browser/webview_delegate.h"
#include "content/public/common/input_event_ack_state.h"
-#include "content/public/common/menu_item.h"
+#include "content_browser_client_efl.h"
#include "context_menu_controller_efl.h"
#include "eweb_context.h"
#include "eweb_view_callbacks.h"
#include "public/ewk_touch_internal.h"
#include "public/ewk_view_product.h"
#include "scroll_detector.h"
+#include "third_party/blink/public/common/context_menu_data/menu_item_info.h"
#include "third_party/blink/public/mojom/choosers/file_chooser.mojom.h"
+#include "third_party/blink/public/mojom/choosers/popup_menu.mojom.h"
+#include "ui/aura/window_tree_host.h"
#include "ui/gfx/geometry/point.h"
#include "ui/gfx/geometry/size.h"
#include "web_contents_delegate_efl.h"
+#if defined(TIZEN_PEPPER_EXTENSIONS)
+#include "ewk_extension_system_delegate.h"
+#include "public/ewk_value_product.h"
+#endif
+
+#if BUILDFLAG(IS_TIZEN_TV)
+#include "third_party/blink/public/common/mediastream/media_devices.h"
+#endif
+
+namespace aura {
+namespace client {
+class FocusClient;
+class WindowParentingClient;
+} // namespace client
+} // namespace aura
+
+namespace base {
+class FilePath;
+}
namespace content {
class RenderFrameHost;
class RenderViewHost;
-class RenderWidgetHostViewEfl;
+class RenderWidgetHostViewAura;
class WebContentsDelegateEfl;
+class WebContentsViewAura;
class ContextMenuControllerEfl;
-class WebContentsViewEfl;
class PopupControllerEfl;
+class DateTimeChooserEfl;
+class InputPicker;
+class GinNativeBridgeDispatcherHost;
+class NavigationHandle;
}
class ErrorParams;
+class _Ewk_App_Control;
class _Ewk_Policy_Decision;
class _Ewk_Hit_Test;
class Ewk_Context;
-class WebViewEvasEventHandler;
class _Ewk_Quota_Permission_Request;
+#if BUILDFLAG(IS_TIZEN_TV)
+struct _Ewk_File_Chooser_Request;
+#endif
+
+#if defined(TIZEN_ATK_SUPPORT)
+class EWebAccessibility;
+#endif
+
template <typename CallbackPtr, typename CallbackParameter>
class WebViewCallback {
public:
void* user_data_;
};
+template <typename CallbackReturnValue,
+ typename CallbackPtr,
+ typename CallbackParameter>
+class WebViewCallbackWithReturnValue {
+ public:
+ WebViewCallbackWithReturnValue() { Set(nullptr, nullptr); }
+
+ void Set(CallbackPtr cb, void* data) {
+ callback_ = cb;
+ user_data_ = data;
+ }
+
+ /* LCOV_EXCL_START */
+ bool IsCallbackSet() const { return callback_; }
+
+ CallbackReturnValue Run(Evas_Object* webview, CallbackParameter param) {
+ if (IsCallbackSet())
+ return callback_(webview, param, user_data_);
+
+ return {};
+ }
+ /* LCOV_EXCL_STOP */
+
+ private:
+ CallbackPtr callback_;
+ void* user_data_;
+};
+
+template <typename CallbackPtr, typename... CallbackParameter>
+class WebViewErrorPageLoadCallback {
+ public:
+ WebViewErrorPageLoadCallback() { Set(nullptr, nullptr); }
+
+ void Set(CallbackPtr cb, void* data) {
+ callback_ = cb;
+ user_data_ = data;
+ }
+
+ bool IsCallbackSet() const { return callback_; }
+
+ void Run(Evas_Object* webview, CallbackParameter... param) {
+ if (IsCallbackSet())
+ callback_(webview, param..., user_data_);
+ }
+
+ private:
+ CallbackPtr callback_;
+ void* user_data_;
+};
+
+template <typename CallbackPtr, typename... CallbackParameter>
+class WebViewExceededQuotaCallback {
+ public:
+ WebViewExceededQuotaCallback() { Set(nullptr, nullptr); }
+
+ void Set(CallbackPtr cb, void* data) {
+ callback_ = cb;
+ user_data_ = data;
+ }
+
+ bool IsCallbackSet() const { return callback_; }
+
+ /* LCOV_EXCL_START */
+ void Run(Evas_Object* webview, CallbackParameter... param) {
+ if (IsCallbackSet())
+ callback_(webview, param..., user_data_);
+ }
+ /* LCOV_EXCL_STOP */
+
+ private:
+ CallbackPtr callback_;
+ void* user_data_;
+};
+
+class BackgroundColorGetCallback {
+ public:
+ BackgroundColorGetCallback(Ewk_View_Background_Color_Get_Callback func,
+ void* user_data)
+ : func_(func), user_data_(user_data) {}
+
+ void Run(Evas_Object* webview, int r, int g, int b, int a) {
+ if (func_)
+ func_(webview, r, g, b, a, user_data_);
+ }
+
+ private:
+ Ewk_View_Background_Color_Get_Callback func_;
+ void* user_data_;
+};
+
class WebApplicationIconUrlGetCallback {
public:
WebApplicationIconUrlGetCallback(Ewk_Web_App_Icon_URL_Get_Callback func,
void* user_data_;
};
+class DidChangeThemeColorCallback {
+ public:
+ DidChangeThemeColorCallback() : callback_(nullptr), user_data_(nullptr) {}
+ void Set(Ewk_View_Did_Change_Theme_Color_Callback callback, void* user_data) {
+ callback_ = callback;
+ user_data_ = user_data;
+ }
+ void Run(Evas_Object* o, const SkColor& color) {
+ if (callback_)
+ callback_(o, SkColorGetR(color), SkColorGetG(color), SkColorGetB(color),
+ SkColorGetA(color), user_data_);
+ }
+
+ private:
+ Ewk_View_Did_Change_Theme_Color_Callback callback_;
+ void* user_data_;
+};
+
+#if BUILDFLAG(IS_TIZEN_TV)
+class GetMediaDeviceCallback {
+ public:
+ GetMediaDeviceCallback() : func_(nullptr), user_data_(nullptr) {}
+
+ void Set(Ewk_Media_Device_List_Get_Callback func, void* user_data) {
+ func_ = func;
+ user_data_ = user_data;
+ }
+
+ void Run(EwkMediaDeviceInfo* device_list, int size) {
+ if (func_) {
+ (func_)(device_list, size, user_data_);
+ }
+ }
+
+ private:
+ Ewk_Media_Device_List_Get_Callback func_;
+ void* user_data_;
+};
+#endif
+
+#if BUILDFLAG(IS_TIZEN_TV)
+class IsVideoPlayingCallback {
+ public:
+ IsVideoPlayingCallback(Ewk_Is_Video_Playing_Callback func, void* user_data)
+ : func_(func), user_data_(user_data) {}
+ void Run(Evas_Object* obj, bool isplaying) {
+ if (func_) {
+ (func_)(obj, isplaying ? EINA_TRUE : EINA_FALSE, user_data_);
+ }
+ }
+
+ private:
+ Ewk_Is_Video_Playing_Callback func_;
+ void* user_data_;
+};
+#endif
+
class WebViewAsyncRequestHitTestDataCallback;
class JavaScriptDialogManagerEfl;
class PermissionPopupManager;
class EWebView {
public:
- static EWebView* FromEvasObject(Evas_Object* eo);
- static int GetOrientation();
+ static EWebView* FromEwkView(Evas_Object* ewk_view);
EWebView(Ewk_Context*, Evas_Object* smart_object);
~EWebView();
// call this once after created and before use
void Initialize();
- void CreateNewWindow(
- content::WebContentsEflDelegate::WebContentsCreateCallback);
+ bool CreateNewWindow(content::WebViewDelegate::WebContentsCreateCallback);
static Evas_Object* GetHostWindowDelegate(const content::WebContents*);
+ content::WebContentsViewAura* wcva() const;
+ content::RenderWidgetHostViewAura* rwhva() const;
Ewk_Context* context() const { return context_.get(); }
- Evas_Object* evas_object() const { return evas_object_; }
- Evas_Object* native_view() const { return native_view_; }
- Evas* GetEvas() const { return evas_object_evas_get(evas_object_); }
+ Evas_Object* ewk_view() const { return ewk_view_; }
+ Evas_Object* efl_main_layout() const { return efl_main_layout_; }
+ Evas_Object* GetElmWindow() const;
+ Evas* GetEvas() const { return evas_object_evas_get(ewk_view_); }
PermissionPopupManager* GetPermissionPopupManager() const {
return permission_popup_manager_.get();
}
content::WebContents& web_contents() const { return *web_contents_.get(); }
+ content::WebContentsViewAura* GetWebContentsViewAura() const;
+
+#if defined(TIZEN_ATK_SUPPORT)
+ EWebAccessibility& eweb_accessibility() const {
+ return *eweb_accessibility_.get();
+ }
+#endif
template <EWebViewCallbacks::CallbackType callbackType>
EWebViewCallbacks::CallBack<callbackType> SmartCallback() const {
- return EWebViewCallbacks::CallBack<callbackType>(evas_object_);
+ return EWebViewCallbacks::CallBack<callbackType>(ewk_view_);
}
- void set_magnifier(bool status);
-
// ewk_view api
- void SetURL(const GURL& url);
+ void SetURL(const GURL& url, bool from_api = false);
const GURL& GetURL() const;
+ const GURL& GetOriginalURL() const;
void Reload();
void ReloadBypassingCache();
Eina_Bool CanGoBack();
void Suspend();
void Resume();
void Stop();
+#if BUILDFLAG(IS_TIZEN_TV)
+ void SetFloatVideoWindowState(bool enabled);
+ void NotifyDownloadableFontInfo(const char* scheme_id_uri,
+ const char* value,
+ const char* data,
+ int type);
+ std::vector<std::string> NotifyPlaybackState(int state,
+ int player_id,
+ const char* url,
+ const char* mime_type);
+ void SuspendNetworkLoading();
+ void ResumeNetworkLoading();
+#endif // IS_TIZEN_TV
+ void SetSessionTimeout(uint64_t timeout);
double GetTextZoomFactor() const;
void SetTextZoomFactor(double text_zoom_factor);
double GetPageZoomFactor() const;
void SetPageZoomFactor(double page_zoom_factor);
void ExecuteEditCommand(const char* command, const char* value);
+#if BUILDFLAG(IS_TIZEN)
+ void EnterDragState();
+#endif
void SetOrientation(int orientation);
+ int GetOrientation();
bool TouchEventsEnabled() const;
void SetTouchEventsEnabled(bool enabled);
bool MouseEventsEnabled() const;
void SetMouseEventsEnabled(bool enabled);
+ void SendKeyEvent(Evas_Object* ewk_view, void* key_event, bool is_press);
+ bool SetKeyEventsEnabled(bool enabled);
void HandleTouchEvents(Ewk_Touch_Event_Type type,
const Eina_List* points,
const Evas_Modifier* modifiers);
void* userdata);
bool SetUserAgent(const char* userAgent);
bool SetUserAgentAppName(const char* application_name);
+#if BUILDFLAG(IS_TIZEN)
bool SetPrivateBrowsing(bool incognito);
bool GetPrivateBrowsing() const;
+#endif
const char* GetUserAgent() const;
const char* GetUserAgentAppName() const;
- const char* GetSelectedText() const;
+ const char* CacheSelectedText();
Ewk_Settings* GetSettings() { return settings_.get(); }
_Ewk_Frame* GetMainFrame();
void UpdateWebKitPreferences();
const char* base_uri,
const char* unreachable_uri);
void LoadPlainTextString(const char* plain_text);
+
+ void LoadHTMLStringOverridingCurrentEntry(const char* html,
+ const char* base_uri,
+ const char* unreachable_url);
void LoadData(const char* data,
size_t size,
const char* mime_type,
const char* encoding,
const char* base_uri,
- const char* unreachable_uri = NULL);
+ const char* unreachable_uri = NULL,
+ bool should_replace_current_entry = false);
+ void InvokeLoadError(const GURL& url, int error_code, bool is_cancellation);
- void InvokeLoadError(const GURL& url,
- int error_code,
- const std::string& error_description,
- bool is_main_frame);
+ void SetViewAuthCallback(Ewk_View_Authentication_Callback callback,
+ void* user_data);
void InvokeAuthCallback(LoginDelegateEfl* login_delegate,
const GURL& url,
const std::string& realm);
void Find(const char* text, Ewk_Find_Options);
void InvokeAuthCallbackOnUI(_Ewk_Auth_Challenge* auth_challenge);
void SetContentSecurityPolicy(const char* policy, Ewk_CSP_Header_Type type);
- void ShowPopupMenu(const std::vector<content::MenuItem>& items,
- int selectedIndex,
- bool multiple);
- Eina_Bool HidePopupMenu();
- void UpdateFormNavigation(int formElementCount,
- int currentNodeIndex,
- bool prevState,
- bool nextState);
- void FormNavigate(bool direction);
- bool IsSelectPickerShown() const;
- void CloseSelectPicker();
- bool FormIsNavigating() const { return formIsNavigating_; }
- void SetFormIsNavigating(bool formIsNavigating);
- Eina_Bool PopupMenuUpdate(Eina_List* items, int selectedIndex);
- Eina_Bool DidSelectPopupMenuItem(int selectedIndex);
- Eina_Bool DidMultipleSelectPopupMenuItem(std::vector<int>& selectedIndices);
- Eina_Bool PopupMenuClose();
+ void HandlePopupMenu(std::vector<blink::mojom::MenuItemPtr> items,
+ int selectedIndex,
+ bool multiple,
+ const gfx::Rect& bounds);
+ void HidePopupMenu();
+ void DidSelectPopupMenuItems(std::vector<int>& indices);
+ void DidCancelPopupMenu();
void HandleLongPressGesture(const content::ContextMenuParams&);
void ShowContextMenu(const content::ContextMenuParams&);
void CancelContextMenu(int request_id);
- void SetScale(double scale_factor, int x, int y);
+ void SetScale(double scale_factor);
+ void SetScaleChangedCallback(Ewk_View_Scale_Changed_Callback callback,
+ void* user_data);
+
bool GetScrollPosition(int* x, int* y) const;
void SetScroll(int x, int y);
void UrlRequestSet(const char* url,
Eina_Hash* headers,
const char* body);
+ SelectPickerBase* GetSelectPicker() const { return select_picker_.get(); }
content::SelectionControllerEfl* GetSelectionController() const;
content::PopupControllerEfl* GetPopupController() const {
return popup_controller_.get();
}
ScrollDetector* GetScrollDetector() const { return scroll_detector_.get(); }
void MoveCaret(const gfx::Point& point);
- void QuerySelectionStyle();
- void OnQuerySelectionStyleReply(const SelectionStylePrams& params);
- void SelectLinkText(const gfx::Point& touch_point);
+ void SelectFocusedLink();
bool GetSelectionRange(Eina_Rectangle* left_rect, Eina_Rectangle* right_rect);
Eina_Bool ClearSelection();
// from render
void OnCopyFromBackingStore(bool success, const SkBitmap& bitmap);
- void RenderViewCreated(content::RenderViewHost* render_view_host);
+ void OnFocusIn();
+ void OnFocusOut();
+
+ void UpdateContextMenu(bool is_password_input);
+ void RenderViewReady();
/**
* Creates a snapshot of given rectangle from EWebView
*
* @param rect rectangle of EWebView which will be taken into snapshot
- *
+ * @param scale_factor scale factor
* @return created snapshot or NULL if error occured.
* @note ownership of snapshot is passed to caller
- */
- Evas_Object* GetSnapshot(Eina_Rectangle rect);
+ */
+ Evas_Object* GetSnapshot(Eina_Rectangle rect, float scale_factor);
bool GetSnapshotAsync(Eina_Rectangle rect,
Ewk_Web_App_Screenshot_Captured_Callback callback,
- void* user_data);
- void InvokePolicyResponseCallback(_Ewk_Policy_Decision* policy_decision);
- void InvokePolicyNavigationCallback(content::RenderViewHost* rvh,
- NavigationPolicyParams params,
+ void* user_data,
+ float scale_factor);
+ void InvokePolicyResponseCallback(_Ewk_Policy_Decision* policy_decision,
+ bool* defer);
+ void InvokePolicyNavigationCallback(const NavigationPolicyParams& params,
bool* handled);
void UseSettingsFont();
bool InvokeViewUserMediaPermissionCallback(
_Ewk_User_Media_Permission_Request* user_media_permission_request_context,
Eina_Bool* result);
+ void SetViewUserMediaPermissionQueryCallback(
+ Ewk_View_User_Media_Permission_Query_Callback callback,
+ void* user_data);
+ Ewk_User_Media_Permission_Query_Result
+ InvokeViewUserMediaPermissionQueryCallback(
+ _Ewk_User_Media_Permission_Query* user_media_permission_query_context);
+
+ void SetViewLoadErrorPageCallback(Ewk_View_Error_Page_Load_Callback callback,
+ void* user_data);
+ const char* InvokeViewLoadErrorPageCallback(const GURL& url,
+ int error_code,
+ bool is_cancellation);
+ bool IsLoadErrorPageCallbackSet() const;
void SetViewUnfocusAllowCallback(Ewk_View_Unfocus_Allow_Callback callback,
void* user_data);
bool InvokeViewUnfocusAllowCallback(Ewk_Unfocus_Direction direction,
bool GetMHTMLData(Ewk_View_MHTML_Data_Get_Callback callback, void* user_data);
void OnMHTMLContentGet(const std::string& mhtml_content, int callback_id);
+ bool SavePageAsMHTML(const std::string& path,
+ Ewk_View_Save_Page_Callback callback,
+ void* user_data);
bool IsFullscreen();
void ExitFullscreen();
double GetScale();
void DidChangePageScaleFactor(double scale_factor);
+ void SetScaledContentsSize();
void SetJavaScriptAlertCallback(Ewk_View_JavaScript_Alert_Callback callback,
void* user_data);
void JavaScriptAlertReply();
void JavaScriptPromptReply(const char* result);
void set_renderer_crashed();
void GetPageScaleRange(double* min_scale, double* max_scale);
- void SetDrawsTransparentBackground(bool enabled);
+ bool SetDrawsTransparentBackground(bool enabled);
+ bool GetDrawsTransparentBackground();
+ bool SetBackgroundColor(int red, int green, int blue, int alpha);
+ bool GetBackgroundColor(Ewk_View_Background_Color_Get_Callback callback,
+ void* user_data);
+ void OnGetBackgroundColor(int callback_id, SkColor bg_color);
+
void GetSessionData(const char** data, unsigned* length) const;
bool RestoreFromSessionData(const char* data, unsigned length);
- void ShowFileChooser(content::RenderFrameHost* render_frame_host,
+ void ShowFileChooser(scoped_refptr<content::FileSelectListener> listener,
const blink::mojom::FileChooserParams&);
void SetBrowserFont();
- void SetCertificatePem(const std::string& certificate);
bool IsDragging() const;
void RequestColorPicker(int r, int g, int b, int a);
- void DismissColorPicker();
bool SetColorPickerColor(int r, int g, int b, int a);
- void InputPickerShow(ui::TextInputType input_type, double input_value);
+ void InputPickerShow(ui::TextInputType input_type,
+ double input_value,
+ content::DateTimeChooserEfl* date_time_chooser);
void ShowContentsDetectedPopup(const char*);
bool GetLinkMagnifierEnabled() const;
void SetLinkMagnifierEnabled(bool enabled);
- void SetOverrideEncoding(const std::string& encoding);
+ bool GetHorizontalPanningHold() const;
+ void SetHorizontalPanningHold(bool hold);
+ bool GetVerticalPanningHold() const;
+ void SetVerticalPanningHold(bool hold);
+
void SetQuotaPermissionRequestCallback(
Ewk_Quota_Permission_Request_Callback callback,
void* user_data);
+#if !defined(EWK_BRINGUP) // FIXME: m114 bringup
void InvokeQuotaPermissionRequest(
_Ewk_Quota_Permission_Request* request,
- const content::QuotaPermissionContext::PermissionCallback& cb);
+ content::QuotaPermissionContext::PermissionCallback cb);
void QuotaRequestReply(const _Ewk_Quota_Permission_Request* request,
bool allow);
void QuotaRequestCancel(const _Ewk_Quota_Permission_Request* request);
-#if !defined(EWK_BRINGUP) // FIXME: m67 bringup
void SetViewMode(blink::WebViewMode view_mode);
#endif
gfx::Point GetContextMenuPosition() const;
content::ContextMenuControllerEfl* GetContextMenuController() {
return context_menu_.get();
}
+
+ bool SetMainFrameScrollbarVisible(bool visible);
+ bool GetMainFrameScrollbarVisible(
+ Ewk_View_Main_Frame_Scrollbar_Visible_Get_Callback callback,
+ void* user_data);
+ void InvokeMainFrameScrollbarVisibleCallback(int callback_id, bool visible);
+
void ResetContextMenuController();
+ Eina_Bool AddJavaScriptMessageHandler(Evas_Object* view,
+ Ewk_View_Script_Message_Cb callback,
+ std::string name);
+
+ content::GinNativeBridgeDispatcherHost* GetGinNativeBridgeDispatcherHost()
+ const {
+ return gin_native_bridge_dispatcher_host_.get();
+ }
+ bool SetPageVisibility(Ewk_Page_Visibility_State page_visibility_state);
+
+ void SetExceededIndexedDatabaseQuotaCallback(
+ Ewk_View_Exceeded_Indexed_Database_Quota_Callback callback,
+ void* user_data);
+ void InvokeExceededIndexedDatabaseQuotaCallback(const GURL& origin,
+ int64_t current_quota);
+ void ExceededIndexedDatabaseQuotaReply(bool allow);
+
+#if defined(TIZEN_VIDEO_HOLE)
+ void EnableVideoHoleSupport();
+#endif
+
+#if defined(TIZEN_TBM_SUPPORT)
+ void SetOffscreenRendering(bool enable);
+#endif
/// ---- Event handling
bool HandleShow();
void HandleZoomGesture(blink::WebGestureEvent& event);
void ClosePage();
+ void RequestManifest(Ewk_View_Request_Manifest_Callback callback,
+ void* user_data);
+ void DidRespondRequestManifest(_Ewk_View_Request_Manifest* manifest,
+ Ewk_View_Request_Manifest_Callback callback,
+ void* user_data);
+
+ void SetBeforeUnloadConfirmPanelCallback(
+ Ewk_View_Before_Unload_Confirm_Panel_Callback callback,
+ void* user_data);
+ void ReplyBeforeUnloadConfirmPanel(Eina_Bool result);
+ void SyncAcceptLanguages(const std::string& accept_languages);
+
+#if BUILDFLAG(IS_TIZEN_TV)
+ //Browser edge scroll
+ bool EdgeScrollBy(int delta_x, int delta_y);
+ void GetMousePosition(gfx::Point&);
+ void InvokeEdgeScrollByCallback(const gfx::Point&, bool);
+ // notify web browser video playing status
+ bool IsVideoPlaying(Ewk_Is_Video_Playing_Callback callback, void* user_data);
+ void InvokeIsVideoPlayingCallback(bool is_playing, int callback_id);
+#endif
+
+ void OnOverscrolled(const gfx::Vector2dF& accumulated_overscroll,
+ const gfx::Vector2dF& latest_overscroll_delta);
+
+ bool SetVisibility(bool enable);
+ void SetDoNotTrack(Eina_Bool);
+
+#if defined(TIZEN_ATK_SUPPORT)
+ void UpdateSpatialNavigationStatus(Eina_Bool enable);
+ void UpdateAccessibilityStatus(Eina_Bool enable);
+
+ bool CheckLazyInitializeAtk() {
+ return is_initialized_ && lazy_initialize_atk_;
+ }
+ void InitAtk();
+ bool GetAtkStatus();
+#endif
+#if defined(TIZEN_PEPPER_EXTENSIONS)
+ void InitializePepperExtensionSystem();
+ EwkExtensionSystemDelegate* GetExtensionDelegate();
+ void SetWindowId();
+ void SetPepperExtensionWidgetInfo(Ewk_Value widget_pepper_ext_info);
+ void SetPepperExtensionCallback(Generic_Sync_Call_Callback cb, void* data);
+ void RegisterPepperExtensionDelegate();
+ void UnregisterPepperExtensionDelegate();
+#endif
+
+ bool ShouldIgnoreNavigation(content::NavigationHandle* navigation_handle);
+
+#if BUILDFLAG(IS_TIZEN_TV)
+ void DrawLabel(Evas_Object* image, Eina_Rectangle rect);
+ void DeactivateAtk(bool deactivated);
+ void ClearLabels();
+ void AddDynamicCertificatePath(const std::string& host,
+ const std::string& cert_path);
+
+ bool SetMixedContents(bool allow);
+ void ClearAllTilesResources();
+ bool UseEarlyRWI() { return use_early_rwi_; }
+ bool RWIInfoShowed() { return rwi_info_showed_; }
+ GURL RWIURL() { return rwi_gurl_; }
+ void OnDialogClosed();
+ void NotifyMediaStateChanged(uint32_t type,
+ uint32_t previous,
+ uint32_t current);
+ void SetHighBitRate(Eina_Bool is_high_bitrate);
+ bool IsHighBitRate() const { return is_high_bitrate_; }
+ void NotifyFirstTimeStamp(unsigned long long timestamp,
+ int time_base_num,
+ int time_base_den);
+ void NotifyPESData(const std::string& buf,
+ unsigned int len,
+ int media_position);
+ void SetPreferSubtitleLang(const char* lang_list);
+ void NotifySubtitleState(int state, double time_stamp);
+ void NotifySubtitlePlay(int active_track_id,
+ const char* url,
+ const char* lang);
+ void NotifySubtitleData(int track_id,
+ double time_stamp,
+ const std::string& data,
+ unsigned int size);
+ void UpdateCurrentTime(double current_time);
+ void UpdateEventData(void* data);
+ double GetCurrentTime() { return current_time_; }
+ void GetMediaDeviceList(Ewk_Media_Device_List_Get_Callback callback,
+ void* userData);
+ using MediaDeviceEnumeration =
+ std::array<blink::WebMediaDeviceInfoArray, NUM_MEDIA_DEVICE_TYPES>;
+ void OnDeviceListed(const MediaDeviceEnumeration& devices);
+ void SetTranslatedURL(const char* url);
+ void NotifyParentalRatingInfo(const char* info, const char* url);
+ void SetParentalRatingResult(const char* info, bool is_pass);
+#endif // IS_TIZEN_TV
+
+ void SetDidChangeThemeColorCallback(
+ Ewk_View_Did_Change_Theme_Color_Callback callback,
+ void* user_data);
+ void DidChangeThemeColor(const SkColor& color);
+
+ void OnSelectionRectReceived(const gfx::Rect& selection_rect) const;
+
private:
+ static void NativeViewResize(void* data,
+ Evas* e,
+ Evas_Object* obj,
+ void* event_info);
void InitializeContent();
+ void InitializeWindowTreeHost();
void SendDelayedMessages(content::RenderViewHost* render_view_host);
void EvasToBlinkCords(int x, int y, int* view_x, int* view_y);
Ewk_Hit_Test_Mode mode,
WebViewAsyncRequestHitTestDataCallback* cb);
- content::WebContentsViewEfl* GetWebContentsViewEfl() const;
+#if BUILDFLAG(IS_TIZEN_TV)
+ void InitInspectorServer();
-#if defined(OS_TIZEN) && !defined(EWK_BRINGUP)
- static void cameraResultCb(service_h request,
- service_h reply,
- service_result_e result,
- void* data);
+ void RunPendingSetFocus(Eina_Bool focus);
+ void SetFocusInternal(Eina_Bool focus);
#endif
-#if defined(OS_TIZEN) && !defined(EWK_BRINGUP)
- bool LaunchCamera(base::string16 mimetype);
-#endif
- content::RenderWidgetHostViewEfl* rwhv() const;
JavaScriptDialogManagerEfl* GetJavaScriptDialogManagerEfl();
- void ReleasePopupMenuList();
+ // Changes viewport without resizing Evas_Object representing webview
+ // and its corresponding RWHV to let Blink renders custom viewport
+ // while showing picker.
+ void AdjustViewPortHeightToPopupMenu(bool is_popup_menu_visible);
void ShowContextMenuInternal(const content::ContextMenuParams&);
void UpdateWebkitPreferencesEfl(content::RenderViewHost*);
- scoped_refptr<WebViewEvasEventHandler> evas_event_handler_;
+ void ChangeScroll(int& x, int& y);
+ void ScrollFocusedNodeIntoView();
+
+ void GenerateMHTML(Ewk_View_Save_Page_Callback callback,
+ void* user_data,
+ const base::FilePath& file_path);
+ void MHTMLGenerated(Ewk_View_Save_Page_Callback callback,
+ void* user_data,
+ const base::FilePath& file_path,
+ int64_t file_size);
+
+ static void VisibleContentChangedCallback(void* user_data,
+ Evas_Object* object,
+ void* event_info);
+
+ static void OnCustomScrollBeginCallback(void* user_data,
+ Evas_Object* object,
+ void* event_info);
+
+ static void OnCustomScrollEndCallback(void* user_data,
+ Evas_Object* object,
+ void* event_info);
+ void UpdateContextMenuWithParams(const content::ContextMenuParams& params);
+
+ static Eina_Bool DelayedPopulateAndShowContextMenu(void* data);
+
scoped_refptr<Ewk_Context> context_;
- scoped_refptr<Ewk_Context> old_context_;
std::unique_ptr<content::WebContents> web_contents_;
std::unique_ptr<content::WebContentsDelegateEfl> web_contents_delegate_;
+ std::unique_ptr<content::WebViewDelegate> webview_delegate_;
std::string pending_url_request_;
std::unique_ptr<Ewk_Settings> settings_;
std::unique_ptr<_Ewk_Frame> frame_;
std::unique_ptr<_Ewk_Policy_Decision> window_policy_;
- Evas_Object* evas_object_;
- Evas_Object* native_view_;
- bool touch_events_enabled_;
+ Evas_Object* ewk_view_;
+ Evas_Object* efl_main_layout_;
+ bool key_events_enabled_ = true;
bool mouse_events_enabled_;
double text_zoom_factor_;
mutable std::string user_agent_;
mutable std::string user_agent_app_name_;
std::unique_ptr<_Ewk_Auth_Challenge> auth_challenge_;
+ std::string selected_text_cached_;
- Eina_List* popupMenuItems_;
- Popup_Picker* popupPicker_;
- bool formIsNavigating_;
- typedef struct {
- int count;
- int position;
- bool prevState;
- bool nextState;
- } formNavigation;
- formNavigation formNavigation_;
std::unique_ptr<content::ContextMenuControllerEfl> context_menu_;
-#if !defined(EWK_BRINGUP) // FIXME: m71 bringup
+#if BUILDFLAG(IS_TIZEN_TV)
+ std::unique_ptr<_Ewk_File_Chooser_Request> file_chooser_request_;
+#else
std::unique_ptr<content::FileChooserControllerEfl> file_chooser_;
#endif
std::unique_ptr<content::PopupControllerEfl> popup_controller_;
- base::string16 previous_text_;
+ std::u16string previous_text_;
int current_find_request_id_;
static int find_request_id_counter_;
MHTMLCallbackDetails;
base::IDMap<MHTMLCallbackDetails*> mhtml_callback_map_;
+#if BUILDFLAG(IS_TIZEN_TV)
+ base::IDMap<IsVideoPlayingCallback*> is_video_playing_callback_map_;
+#endif
+
+ typedef WebViewCallback<Ewk_View_Main_Frame_Scrollbar_Visible_Get_Callback,
+ bool>
+ MainFrameScrollbarVisibleGetCallback;
+ base::IDMap<MainFrameScrollbarVisibleGetCallback*>
+ main_frame_scrollbar_visible_callback_map_;
+
+ base::IDMap<BackgroundColorGetCallback*> background_color_get_callback_map_;
+
+#if BUILDFLAG(IS_TIZEN_TV)
+ GetMediaDeviceCallback device_cb_;
+#endif
+
gfx::Size contents_size_;
double progress_;
mutable std::string title_;
- mutable std::string pem_certificate_;
Hit_Test_Params hit_test_params_;
base::WaitableEvent hit_test_completion_;
double page_scale_factor_;
- double min_page_scale_factor_;
- double max_page_scale_factor_;
+ double x_delta_;
+ double y_delta_;
WebViewCallback<Ewk_View_Geolocation_Permission_Callback,
_Ewk_Geolocation_Permission_Request*>
WebViewCallback<Ewk_View_User_Media_Permission_Callback,
_Ewk_User_Media_Permission_Request*>
user_media_permission_cb_;
+ WebViewCallbackWithReturnValue<Ewk_User_Media_Permission_Query_Result,
+ Ewk_View_User_Media_Permission_Query_Callback,
+ _Ewk_User_Media_Permission_Query*>
+ user_media_permission_query_cb_;
+ WebViewErrorPageLoadCallback<Ewk_View_Error_Page_Load_Callback,
+ Ewk_Error*,
+ Ewk_Error_Page*>
+ load_error_page_cb_;
WebViewCallback<Ewk_View_Unfocus_Allow_Callback, Ewk_Unfocus_Direction>
unfocus_allow_cb_;
WebViewCallback<Ewk_View_Notification_Permission_Callback,
WebViewCallback<Ewk_Quota_Permission_Request_Callback,
const _Ewk_Quota_Permission_Request*>
quota_request_callback_;
+ WebViewCallback<Ewk_View_Authentication_Callback, _Ewk_Auth_Challenge*>
+ authentication_cb_;
+ WebViewCallback<Ewk_View_Scale_Changed_Callback, double> scale_changed_cb_;
+
+ std::unique_ptr<content::InputPicker> input_picker_;
+
+ DidChangeThemeColorCallback did_change_theme_color_callback_;
- std::unique_ptr<content::InputPicker> inputPicker_;
base::IDMap<WebApplicationIconUrlGetCallback*>
web_app_icon_url_get_callback_map_;
base::IDMap<WebApplicationIconUrlsGetCallback*>
std::unique_ptr<PermissionPopupManager> permission_popup_manager_;
std::unique_ptr<ScrollDetector> scroll_detector_;
-#if defined(OS_TIZEN)
- blink::mojom::FileChooserParams::Mode filechooser_mode_;
-#endif
+ // Manages injecting native objects.
+ std::unique_ptr<content::GinNativeBridgeDispatcherHost>
+ gin_native_bridge_dispatcher_host_;
+
+ WebViewExceededQuotaCallback<
+ Ewk_View_Exceeded_Indexed_Database_Quota_Callback,
+ Ewk_Security_Origin*,
+ long long>
+ exceeded_indexed_db_quota_callback_;
+ std::unique_ptr<Ewk_Security_Origin> exceeded_indexed_db_quota_origin_;
+#if !defined(EWK_BRINGUP) // FIXME: m114 bringup
std::map<const _Ewk_Quota_Permission_Request*,
content::QuotaPermissionContext::PermissionCallback>
quota_permission_request_map_;
+#endif
+#if BUILDFLAG(IS_TIZEN)
+ blink::mojom::FileChooserParams::Mode filechooser_mode_ =
+ blink::mojom::FileChooserParams::Mode::kOpen;
+ Ecore_Event_Handler* window_rotate_handler_ = nullptr;
+#endif
bool is_initialized_;
+#if BUILDFLAG(IS_TIZEN_TV)
+ bool is_processing_edge_scroll_;
+ bool use_early_rwi_;
+ bool rwi_info_showed_;
+ GURL rwi_gurl_;
+ bool is_high_bitrate_ = false;
+
+ base::OnceClosure pending_setfocus_closure_;
+
+ enum PlaybackState {
+ kPlaybackLoad = 0,
+ // kPlaybackReady: player with both audio and video starts prepare and will
+ // acquire audio and video resources (if they are not already taken)
+ kPlaybackReady,
+ kPlaybackStart,
+ kPlaybackFinish,
+ kPlaybackStop,
+ };
+ double current_time_ = 0.0;
+#endif
+
std::unique_ptr<_Ewk_Back_Forward_List> back_forward_list_;
- static content::WebContentsEflDelegate::WebContentsCreateCallback
+ static content::WebViewDelegate::WebContentsCreateCallback
create_new_window_web_contents_cb_;
- private:
+#if defined(TIZEN_VIDEO_HOLE)
+ void EnableVideoHoleSupportInternal();
+#endif
gfx::Vector2d previous_scroll_position_;
gfx::Point context_menu_position_;
+ content::ContextMenuParams saved_context_menu_params_;
+
std::vector<IPC::Message*> delayed_messages_;
std::map<int64_t, WebViewAsyncRequestHitTestDataCallback*> hit_test_callback_;
+
+ content::AcceptLanguagesHelper::AcceptLangsChangedCallback
+ accept_langs_changed_callback_;
+
+ std::unique_ptr<SelectPickerBase> select_picker_;
+ std::unique_ptr<aura::WindowTreeHost> host_;
+ std::unique_ptr<aura::client::FocusClient> focus_client_;
+ std::unique_ptr<aura::client::WindowParentingClient> window_parenting_client_;
+ std::unique_ptr<ui::CompositorObserver> compositor_observer_;
+
+#if defined(TIZEN_ATK_SUPPORT)
+ std::unique_ptr<EWebAccessibility> eweb_accessibility_;
+ bool lazy_initialize_atk_ = false;
+#endif
+#if defined(TIZEN_PEPPER_EXTENSIONS)
+ content::ExtensionSystemDelegateManager::RenderFrameID render_frame_id_;
+#endif
+#if defined(TIZEN_VIDEO_HOLE)
+ bool pending_video_hole_setting_ = false;
+#endif
+
+ Ecore_Timer* delayed_show_context_menu_timer_ = nullptr;
+ base::WeakPtrFactory<EWebView> weak_factory_{this};
};
const unsigned int g_default_tilt_motion_sensitivity = 3;
projects / platform / framework / web / chromium-efl.git / blobdiff