#include "private/ewk_notification_private.h"
#include "private/ewk_private.h"
-
const char *ewk_notification_body_get(const Ewk_Notification *ewk_notification)
{
EINA_SAFETY_ON_NULL_RETURN_VAL(ewk_notification, 0);
return ewk_notification->GetID();
}
+void ewk_notification_cached_permissions_set(Ewk_Context *context, Eina_List *ewk_notification_permissions)
+{
+#if defined(ENABLE_NOTIFICATIONS)
+ EINA_SAFETY_ON_NULL_RETURN(context);
+ scoped_refptr<content::NotificationControllerEfl> notification_controller(context->browser_context()->GetNotificationController());
+ notification_controller->ClearPermissions();
+ Eina_List* list;
+ void* data;
+ EINA_LIST_FOREACH(ewk_notification_permissions, list, data) {
+ Ewk_Notification_Permission* perm = static_cast<Ewk_Notification_Permission*>(data);
+ notification_controller->AddPermission(GURL(perm->origin), (perm->allowed == EINA_TRUE));
+ }
+#else
+ NOTIMPLEMENTED();
+#endif
+}
+
const Ewk_Security_Origin *ewk_notification_permission_request_origin_get(
const Ewk_Notification_Permission_Request *request)
{
return static_cast<const Ewk_Security_Origin*>(request->GetSecurityOrigin());
}
+void ewk_notification_permission_reply(Ewk_Notification_Permission_Request *request, Eina_Bool allow)
+{
+#if defined(ENABLE_NOTIFICATIONS)
+ EINA_SAFETY_ON_NULL_RETURN(request);
+ request->Reply(allow == EINA_TRUE);
+#endif
+}
+
void ewk_notification_permission_request_set(Ewk_Notification_Permission_Request *request, Eina_Bool allowed)
{
-#if !defined(EWK_BRINGUP)
-#warning "[M38] TODO: Fix and re-enable notifications (edit efl_integration/public/ewk_notifications.cc)"
+#if defined(ENABLE_NOTIFICATIONS)
EINA_SAFETY_ON_NULL_RETURN(request);
- EWebView* view = EWebView::FromEvasObject(request->GetWebviewEvasObject());
- if (view)
- view->context()->browser_context()->GetNotificationController()->SetPermissionForNotification(request, allowed);
- delete request;
+ request->Reply(allowed == EINA_TRUE);
#endif
}
void ewk_notification_policies_removed(Ewk_Context* ewkContext, Eina_List* origins)
{
- LOG_EWK_API_MOCKUP();
+#if defined(ENABLE_NOTIFICATIONS)
+ EINA_SAFETY_ON_NULL_RETURN(ewkContext);
+ EINA_SAFETY_ON_NULL_RETURN(origins);
+ ewkContext->browser_context()->GetNotificationController()->RemovePermissions(origins);
+#else
+ NOTIMPLEMENTED();
+#endif
}
const Ewk_Security_Origin *ewk_notification_security_origin_get(const Ewk_Notification *ewk_notification)
EAPI uint64_t ewk_notification_id_get(const Ewk_Notification *ewk_notification);
/**
+ * Requests for setting cached notification permissions.
+ *
+ * By calling this notification permission is replaced as passed ewk_notification_permissions.
+ *
+ * @param context context object
+ * @param ewk_notification_permissions list of cached permissions(Ewk_Notification_Permission)
+ */
+EAPI void ewk_notification_cached_permissions_set(Ewk_Context *context, Eina_List *ewk_notification_permissions);
+
+/**
* Requests for getting origin of notification permission request.
*
* @param request Ewk_Notification_Permission_Request object to get origin for notification permission request
EAPI const Ewk_Security_Origin *ewk_notification_permission_request_origin_get(const Ewk_Notification_Permission_Request *request);
/**
+ * Reply the result about notification permission.
+ *
+ * @param request Ewk_Notification_Permission_Request object to get the infomation about notification permission request.
+ * @param allow result about notification permission
+ */
+EAPI void ewk_notification_permission_reply(Ewk_Notification_Permission_Request *request, Eina_Bool allow);
+
+/**
+ * Deprecated, use ewk_notification_permission_reply instead.
* Sets permission of notification.
*
* @param request Ewk_Notification_Permission_Request object to allow/deny notification permission
* request is freed in this function.
* @param allowed @c EINA_TRUE if permission is allowed, @c EINA_FALSE if permission is denied
*/
-EAPI void ewk_notification_permission_request_set(Ewk_Notification_Permission_Request *request, Eina_Bool allowed);
+EINA_DEPRECATED EAPI void ewk_notification_permission_request_set(Ewk_Notification_Permission_Request *request, Eina_Bool allowed);
/**
* Suspend the operation for permission request.
return static_cast<uint16_t>(origin->GetPort());
}
+void ewk_security_origin_free(Ewk_Security_Origin *o)
+{
+ delete o;
+}
+
+Ewk_Security_Origin *ewk_security_origin_new_from_string(const char *url)
+{
+ return static_cast<Ewk_Security_Origin *>(tizen_webview::Security_Origin::CreateFromString(url));
+}
+
*/
EAPI uint16_t ewk_security_origin_port_get(const Ewk_Security_Origin* origin);
+/**
+ * Release all resources allocated by a security origin object.
+ *
+ * @param o security origin object
+ */
+EAPI void ewk_security_origin_free(Ewk_Security_Origin *o);
+
+/**
+ * Creates a security origin for a url.
+ *
+ * @param url the url for the security origin.
+ *
+ * @return the security origin object
+ */
+EAPI Ewk_Security_Origin *ewk_security_origin_new_from_string(const char *url);
+
+
#ifdef __cplusplus
}
#endif
assert(impl->GetWebContext());
assert(impl->GetWebContext()->browser_context());
assert(impl->GetWebContext()->browser_context()->GetNotificationController());
- content::NotificationControllerEfl* controller =
+ scoped_refptr<content::NotificationControllerEfl> controller =
impl->GetWebContext()->browser_context()->GetNotificationController();
Eina_List* notification_iterator = NULL;
return chromium_glue::from(impl->GetBackForwardList());
}
+void ewk_view_notification_permission_callback_set(Evas_Object *o, Ewk_View_Notification_Permission_Callback callback, void *user_data)
+{
+ EWK_VIEW_IMPL_GET_OR_RETURN(o, impl);
+ impl->SetNotificationPermissionCallback(reinterpret_cast<tizen_webview::View_Notification_Permission_Callback>(callback), user_data);
+}
+
void ewk_view_draw_focus_ring_enable_set(Evas_Object* ewkView, Eina_Bool enable)
{
#if defined(OS_TIZEN_TV) && !defined(EWK_BRINGUP)
#include "ewk_window_features.h"
#include "ewk_quota_permission_request.h"
#include "ewk_geolocation.h"
+#include "ewk_notification.h"
#ifdef __cplusplus
extern "C" {
// #endif
/**
+ * Callback for ewk_view_notification_permission_callback_set
+ *
+ * @param o view object to request the notification permission
+ * @param request Ewk_Notification_Permission_Request object to get the information about notification permission request.
+ * @param user_data user data
+ *
+ * @return returned value is not used
+ */
+typedef Eina_Bool (*Ewk_View_Notification_Permission_Callback)(Evas_Object *o, Ewk_Notification_Permission_Request *request, void *user_data);
+
+/**
* The version you have to put into the version field
* in the @a Ewk_View_Smart_Class structure.
*/
*/
EAPI Eina_Bool ewk_view_web_login_request(Evas_Object* ewkView);
+/**
+ * Sets the notification permission callback.
+ *
+ * @param o view object to request the notification permission
+ * @param callback Ewk_View_Notification_Permission_Callback function to notification permission
+ * @param user_data user data
+ */
+EAPI void ewk_view_notification_permission_callback_set(Evas_Object *o, Ewk_View_Notification_Permission_Callback callback, void *user_data);
+
#ifdef __cplusplus
}
#endif
static void on_evas_resize(Ecore_Evas*);
static void __notification_show_cb(void *data, Evas_Object *obj, void *event_info);
-static void __notification_permission_cb(void *data, Evas_Object *obj, void *event_info);
+static Eina_Bool __notification_permission_cb(void *data, Evas_Object *obj, void *event_info);
static void __notification_cancel_cb(void *data, Evas_Object *obj, void *event_info);
static void __notification_cancel_byuser_cb(void *data, Evas_Object *obj, void *event_info);
static void __download_callback(const char*download_url, void* user_data);
evas_object_smart_callback_add(view, "authentication,challenge", __auth_challenge_cb, 0);
evas_object_smart_callback_add(view, "notification,show", __notification_show_cb,0);
evas_object_smart_callback_add(view, "notification,cancel", __notification_cancel_cb,0);
- evas_object_smart_callback_add(view, "notification,permission,request", __notification_permission_cb,0);
evas_object_smart_callback_add(view, "policy,response,decide", __policy_response_decide_cb, 0);
evas_object_smart_callback_add(view, "contextmenu,customize", __customize_context_menu_cb, 0);
evas_object_smart_callback_add(view, "contextmenu,selected", __customize_context_menu_item_selected_cb, 0);
ewk_view_custom_header_add(view, "X-Test-header", "X-Value-1");
+ ewk_view_notification_permission_callback_set(view, __notification_permission_cb, 0);
ewk_context_vibration_client_callbacks_set(context, __vibration_on_cb, __vibration_off_cb, NULL);
ewk_context_mime_override_callback_set(__mime_override_cb);
ewk_view_javascript_alert_callback_set(view, __ewk_view_javascript_alert_cb, 0);
printf ("APP.C callback called __notification_show_cb \n");
}
-void __notification_permission_cb(void *data, Evas_Object *obj, void *event_info)
+Eina_Bool __notification_permission_cb(void *data, Evas_Object *obj, void *event_info)
{
Ewk_Notification_Permission_Request *request = (Ewk_Notification_Permission_Request*)event_info;
if(request) {
printf("APP.C callback called __notification_permission_cb URL = %s, protocol = %s, port = %d\n",
ewk_security_origin_host_get(sec_origin), ewk_security_origin_protocol_get(sec_origin),ewk_security_origin_port_get(sec_origin));
}
- ewk_notification_permission_request_set(request, 1);
+ ewk_notification_permission_reply(request, EINA_TRUE);
}
+ return EINA_FALSE;
}
void __notification_cancel_cb(void *data, Evas_Object *obj, void *event_info)
'utc_blink_ewk_notification_clicked_func.cpp',
'utc_blink_ewk_notification_icon_url_get_func.cpp',
'utc_blink_ewk_notification_id_get_func.cpp',
+ 'utc_blink_ewk_notification_permission_reply_func.cpp',
'utc_blink_ewk_notification_permission_request_origin_get_func.cpp',
'utc_blink_ewk_notification_permission_request_set_func.cpp',
'utc_blink_ewk_notification_permission_request_suspend_func.cpp',
+ 'utc_blink_ewk_notification_policies_removed_func.cpp',
'utc_blink_ewk_notification_security_origin_get_func.cpp',
'utc_blink_ewk_notification_showed_func.cpp',
'utc_blink_ewk_notification_title_get_func.cpp',
'utc_blink_ewk_view_main_frame_get_func.cpp',
'utc_blink_ewk_view_mhtml_data_get_func.cpp',
'utc_blink_ewk_view_notification_closed_func.cpp',
+ 'utc_blink_ewk_view_notification_permission_callback_set_func.cpp',
'utc_blink_ewk_view_orientation_lock_callback_set_func.cpp',
'utc_blink_ewk_view_orientation_send_func.cpp',
'utc_blink_ewk_view_page_visibility_state_set_func.cpp',
<html>
+<meta name="viewport" content="initial-scale=1.0">
<head>
-<title>EWK Notifications</title>
+<style>
+button {
+ width: 100%;
+ height: 100%;
+}
+</style>
</head>
-<body onload="testNoti()">
-
-<h1>Sample Page</h1>
-
-<p id="notificationTest">This is a sample page to test EWK Notification APIs.</p>
-
+<body onload="test()">
+<button type="button" id="startButton" onclick="test()">start test</button>
<script type="text/javascript">
-
-function testNotifications()
-{
- if (window.webkitNotifications.checkPermission() == 0)
- {
- var icon = 'logo.png';
- var title = 'Notification Title';
- var body = 'Notification body content';
- var notification_test = window.webkitNotifications.createNotification(icon, title, body);
- notification_test.show();
- }
- else
- {
- window.webkitNotifications.requestPermission(testNotifications);
- }
-}
+function showNotification() {
+ var notification = new Notification("Notification Title", {
+ icon: "logo.png",
+ body: "Notification body content"
+ });
-function sleep()
-{
- var startTime = new Date().getTime();
- while(new Date().getTime() < startTime + 5000)
- {
-
- }
+ notification.onclick = function() {
+ document.title = "notification_clicked";
+ };
-}
+ notification.onshow = function() {
+ document.title = "notification_shown";
+ };
-function testNotifications1()
-{
- if (window.webkitNotifications.checkPermission() == 0)
- {
- var icon = 'logo.png1';
- var title = 'Notification Title1';
- var body = 'Notification body content1';
+ notification.onclose = function() {
+ document.title = "notification_closed";
+ };
+}
- var notification_test = window.webkitNotifications.createNotification(icon, title, body);
- notification_test.show();
+function test() {
+ console.log("Checking permissions");
+ if (!("Notification" in window)) {
+ console.log("Notifications not available!");
+ return;
}
- else
- {
- window.webkitNotifications.requestPermission(testNotifications);
+ if (Notification.permission === "granted") {
+ console.log("event_loop_stop:Permission granted");
+ showNotification();
+ } else {
+ console.log("Requesting permission...");
+ Notification.requestPermission(function (permission) {
+ console.log("received permission: " + permission);
+ if (permission === "granted") {
+ Notification.permission = permission;
+ console.log("event_loop_stop:Permission granted after request");
+ showNotification();
+ }
+ });
}
}
-function testNoti()
-{
- testNotifications();
- sleep();
- testNotifications1();
-
-}
-
</script>
-
</body>
</html>
+++ /dev/null
-<html>
- <head>
- <script>
- function noti() {
- window.webkitNotifications.requestPermission();
- console.log("Notifications are supported!1");
- }
- </script>
- </head>
-<body>
- <input type="button" value="Open Window" onclick="noti()">
-</body>
-</html>
class utc_blink_ewk_notification_body_get : public utc_blink_ewk_base {
protected:
+ utc_blink_ewk_notification_body_get() : body(NULL) {}
+
/* Startup function */
virtual void PostSetUp()
{
- evas_object_smart_callback_add(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest, this);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
evas_object_smart_callback_add(GetEwkWebView(), "notification,show", notificationShow, this);
}
/* Cleanup function */
virtual void PreTearDown()
{
- evas_object_smart_callback_del(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
evas_object_smart_callback_del(GetEwkWebView(), "notification,show", notificationShow);
}
- /* Callback for "notification,permission,request" */
- static void notificationPermissionRequest(void* data, Evas_Object* webview, void* event_info)
+ /* Callback for notification permission request */
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request* request, void* data)
{
utc_message("[notificationPermissionRequest] :: ");
- if (!event_info)
- utc_fail();
+ utc_blink_ewk_notification_body_get *owner = NULL;
+ OwnerFromVoid(data, &owner);
+ if (!request) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
+ }
//allow the notification
- ewk_notification_permission_request_set((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
+ ewk_notification_permission_reply(request, EINA_TRUE);
+ return EINA_TRUE;
}
/* Callback for "notification,show" */
utc_blink_ewk_notification_body_get* owner = static_cast<utc_blink_ewk_notification_body_get*>(data);
//call ewk_notification API
- const char* body = ewk_notification_body_get((Ewk_Notification*)event_info);
- if (strcmp(body, owner->notification_body_ref) == 0) {
- owner->EventLoopStop(Success);
- } else {
- owner->EventLoopStop(Failure);
- }
+ owner->body = strdup(ewk_notification_body_get((Ewk_Notification*)event_info));
+ owner->EventLoopStop(Success);
}
protected:
static const char* const resource_relative_path;
static const char* const notification_body_ref;
+ char* body;
};
-const char* const utc_blink_ewk_notification_body_get::resource_relative_path = "/common/sample_notification_1.html";
+const char* const utc_blink_ewk_notification_body_get::resource_relative_path = "/common/sample_notification_2.html";
const char* const utc_blink_ewk_notification_body_get::notification_body_ref = "Notification body content";
/**
TEST_F(utc_blink_ewk_notification_body_get, POS_TEST)
{
std::string resource_url = GetResourceUrl(resource_relative_path);
- Eina_Bool result = ewk_view_url_set(GetEwkWebView(), resource_url.c_str());
-
- MainLoopResult loop_result = EventLoopStart();
-
- if (loop_result != Success) {
- FAIL();
- }
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), resource_url.c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
+ ASSERT_TRUE(body);
+ ASSERT_STREQ(body, notification_body_ref);
+ free(body);
}
/**
class utc_blink_ewk_notification_clicked : public utc_blink_ewk_base
{
protected:
- /* Callback for "notification,permission,request" */
- static void notificationPermissionRequest(void* data, Evas_Object* webview, void* event_info)
+ utc_blink_ewk_notification_clicked() : clicked(false) {}
+
+ /* Callback for notification permission request */
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request* request, void* data)
{
utc_message("[notificationPermissionRequest] :: \n");
- if (!event_info) {
- FAIL();
+ utc_blink_ewk_notification_clicked *owner = NULL;
+ OwnerFromVoid(data, &owner);
+ if (!request) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
}
//allow the notification
- ewk_notification_permission_request_set(static_cast<Ewk_Notification_Permission_Request*>(event_info), EINA_TRUE);
+ ewk_notification_permission_reply(request, EINA_TRUE);
+ return EINA_TRUE;
}
/* Callback for "notification,show" */
FAIL();
}
- utc_blink_ewk_notification_clicked* owner = static_cast<utc_blink_ewk_notification_clicked*>(data);
-
uint64_t notification_id = ewk_notification_id_get(static_cast<Ewk_Notification*>(event_info));
ewk_notification_clicked(context, notification_id);
- owner->EventLoopStop(Success);;
+ }
+
+ static void titleChanged(void* data, Evas_Object* webview, void* event_info)
+ {
+ const char* title = static_cast<const char*>(event_info);
+ utc_message("[titleChanged] :: title = %s", title);
+ utc_blink_ewk_notification_clicked* owner = NULL;
+ OwnerFromVoid(data, &owner);
+ if (title && strcmp(title, "notification_clicked") == 0) {
+ owner->clicked = true;
+ owner->EventLoopStop(Success);
+ }
}
/* Startup function */
virtual void PostSetUp()
{
- evas_object_smart_callback_add(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest, this);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
evas_object_smart_callback_add(GetEwkWebView(), "notification,show", notificationShow, this);
+ evas_object_smart_callback_add(GetEwkWebView(), "title,changed", titleChanged, this);
}
/* Cleanup function */
virtual void PreTearDown()
{
- evas_object_smart_callback_del(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
evas_object_smart_callback_del(GetEwkWebView(), "notification,show", notificationShow);
+ evas_object_smart_callback_del(GetEwkWebView(), "title,changed", titleChanged);
+ }
+
+ // helper function
+ bool click()
+ {
+ utc_message("[click] :: ");
+ return ewk_view_script_execute(GetEwkWebView(), "document.getElementById(\"startButton\").click();", NULL, NULL) == EINA_TRUE;
}
protected:
static const char* const resource_relative_path;
+ bool clicked;
};
-const char* const utc_blink_ewk_notification_clicked::resource_relative_path = "/common/sample_notification_1.html";
+const char* const utc_blink_ewk_notification_clicked::resource_relative_path = "/common/sample_notification_2.html";
/**
* @brief Positive test case for ewk_notification_clicked()
TEST_F(utc_blink_ewk_notification_clicked, POS_TEST)
{
std::string resource_url = GetResourceUrl(resource_relative_path);
-
- if (!ewk_view_url_set(GetEwkWebView(), resource_url.c_str())) {
- FAIL();
- }
-
- EXPECT_EQ(Success, EventLoopStart());
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), resource_url.c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
+ ASSERT_TRUE(clicked);
}
/**
class utc_blink_ewk_notification_icon_url_get : public utc_blink_ewk_base {
protected:
+ utc_blink_ewk_notification_icon_url_get() : icon_url(NULL) {}
+
/* Startup function */
virtual void PostSetUp()
{
- evas_object_smart_callback_add(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest, this);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
evas_object_smart_callback_add(GetEwkWebView(), "notification,show", notificationShow, this);
}
/* Cleanup function */
virtual void PreTearDown()
{
- evas_object_smart_callback_del(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
evas_object_smart_callback_del(GetEwkWebView(), "notification,show", notificationShow);
}
- /* Callback for "notification,permission,request" */
- static void notificationPermissionRequest(void* data, Evas_Object* webview, void* event_info)
+ /* Callback for notification permission request */
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request* request, void* data)
{
utc_message("[notificationPermissionRequest] :: ");
- if (!event_info)
- utc_fail();
+ utc_blink_ewk_notification_icon_url_get *owner = NULL;
+ OwnerFromVoid(data, &owner);
+ if (!request) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
+ }
//allow the notification
- ewk_notification_permission_request_set((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
+ ewk_notification_permission_reply(request, EINA_TRUE);
+ return EINA_TRUE;
}
/* Callback for "notification,show" */
utc_blink_ewk_notification_icon_url_get* owner = static_cast<utc_blink_ewk_notification_icon_url_get*>(data);
//call ewk_notification API
- const char* iconURL = ewk_notification_icon_url_get((Ewk_Notification*)event_info);
- if (iconURL)
- {
- char* getIconName = strrchr((char*)iconURL, '/');
- getIconName++;
- utc_message("[notificationShpw] :: icon name: %s", getIconName);
- if (strcmp(getIconName, owner->notification_icon_ref) == 0) {
- owner->EventLoopStop(Success);
- return;
- }
-
+ owner->icon_url = ewk_notification_icon_url_get((Ewk_Notification*)event_info);
+ utc_message("[notificationShow] :: icon_url = %s", owner->icon_url);
+ if (owner->icon_url) {
+ char* getIconName = strrchr((char*)owner->icon_url, '/');
+ owner->icon_url = ++getIconName;
}
- owner->EventLoopStop(Failure);
+ owner->EventLoopStop(Success);
+ }
+
+ // helper function
+ bool click()
+ {
+ utc_message("[click] :: ");
+ return ewk_view_script_execute(GetEwkWebView(), "document.getElementById(\"startButton\").click();", NULL, NULL) == EINA_TRUE;
}
protected:
static const char* const resource_relative_path;
static const char* const notification_icon_ref;
+ const char* icon_url;
};
-const char* const utc_blink_ewk_notification_icon_url_get::resource_relative_path = "/common/sample_notification_1.html";
+const char* const utc_blink_ewk_notification_icon_url_get::resource_relative_path = "/common/sample_notification_2.html";
const char* const utc_blink_ewk_notification_icon_url_get::notification_icon_ref = "logo.png";
/**
TEST_F(utc_blink_ewk_notification_icon_url_get, POS_TEST)
{
std::string resource_url = GetResourceUrl(resource_relative_path);
- Eina_Bool result = ewk_view_url_set(GetEwkWebView(), resource_url.c_str());
-
- MainLoopResult loop_result = EventLoopStart();
-
- EXPECT_EQ(Success, loop_result);
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), resource_url.c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
+ ASSERT_TRUE(icon_url);
+ ASSERT_STREQ(icon_url, notification_icon_ref);
}
/**
class utc_blink_ewk_notification_id_get : public utc_blink_ewk_base {
protected:
+ utc_blink_ewk_notification_id_get() : id(0) {}
+
/* Startup function */
virtual void PostSetUp()
{
- evas_object_smart_callback_add(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest, this);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
evas_object_smart_callback_add(GetEwkWebView(), "notification,show", notificationShow, this);
}
/* Cleanup function */
virtual void PreTearDown()
{
- evas_object_smart_callback_del(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
evas_object_smart_callback_del(GetEwkWebView(), "notification,show", notificationShow);
}
- /* Callback for "notification,permission,request" */
- static void notificationPermissionRequest(void* data, Evas_Object* webview, void* event_info)
+ /* Callback for notification permission request */
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request* request, void* data)
{
utc_message("[notificationPermissionRequest] :: ");
- if (!event_info) {
- FAIL();
+ utc_blink_ewk_notification_id_get *owner = NULL;
+ OwnerFromVoid(data, &owner);
+ if (!request) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
}
//allow the notification
- ewk_notification_permission_request_set((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
+ ewk_notification_permission_reply(request, EINA_TRUE);
+ return EINA_TRUE;
}
/* Callback for "notification,show" */
utc_blink_ewk_notification_id_get* owner = static_cast<utc_blink_ewk_notification_id_get*>(data);
//call ewk_notification API
- int id = ewk_notification_id_get((Ewk_Notification*)event_info);
- if (id) {
- owner->EventLoopStop(Success);
- } else {
- owner->EventLoopStop(Failure);
- }
+ owner->id = ewk_notification_id_get((Ewk_Notification*)event_info);
+ owner->EventLoopStop(Success);
}
protected:
static const char* const resource_relative_path;
+ int id;
};
-const char* const utc_blink_ewk_notification_id_get::resource_relative_path = "/common/sample_notification_1.html";
+const char* const utc_blink_ewk_notification_id_get::resource_relative_path = "/common/sample_notification_2.html";
/**
* @brief Positive test case for ewk_notification_body_get(). Text returned by api is compared against expected text and result is set in notificationShow()
TEST_F(utc_blink_ewk_notification_id_get, POS_TEST)
{
std::string resource_url = GetResourceUrl(resource_relative_path);
- if (!ewk_view_url_set(GetEwkWebView(), resource_url.c_str())) {
- FAIL();
- }
-
- MainLoopResult loop_result = EventLoopStart();
-
- utc_check_eq(Success, loop_result);
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), resource_url.c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
+ ASSERT_TRUE(id);
}
/**
--- /dev/null
+// Copyright 2014 Samsung Electronics. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "utc_blink_ewk_base.h"
+
+class utc_blink_ewk_notification_permission_reply : public utc_blink_ewk_base {
+protected:
+ utc_blink_ewk_notification_permission_reply()
+ : utc_blink_ewk_base()
+ , notificationPermissionFirsttime(EINA_FALSE)
+ , notificationPermissionSecondtime(EINA_FALSE)
+ {
+ }
+
+ virtual ~utc_blink_ewk_notification_permission_reply() {
+ }
+
+ /* Callback for notification permission request */
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request* request, void* data)
+ {
+ utc_blink_ewk_notification_permission_reply* owner = static_cast<utc_blink_ewk_notification_permission_reply*>(data);
+
+ Ewk_Context *context = ewk_view_context_get(webview);
+ if (!request || !context) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
+ }
+
+ //allow the notification
+ ewk_notification_permission_reply(request, EINA_TRUE);
+
+ if (!owner->notificationPermissionFirsttime) {
+ owner->notificationPermissionFirsttime = EINA_TRUE;
+ } else {
+ owner->notificationPermissionSecondtime = EINA_TRUE;
+ owner->EventLoopStop(Failure);
+ }
+ return EINA_TRUE;
+ }
+
+ static void cb_console_message(utc_blink_ewk_notification_permission_reply *owner, Evas_Object *obj, void *event_info)
+ {
+ Ewk_Console_Message* console = static_cast<Ewk_Console_Message*>(event_info);
+ const char *cmsg = ewk_console_message_text_get(console);
+ if (!cmsg) {
+ return;
+ }
+ std::string msg(cmsg);
+ std::string::size_type pos = msg.find(':');
+ if (pos == std::string::npos) {
+ return;
+ }
+ if (msg.substr(0, pos) == "event_loop_stop") {
+ owner->EventLoopStop(Success);
+ }
+ }
+
+ // helper function
+ bool click()
+ {
+ utc_message("[click] :: ");
+ return ewk_view_script_execute(GetEwkWebView(), "document.getElementById(\"startButton\").click();", NULL, NULL) == EINA_TRUE;
+ }
+
+ /* Startup and cleanup functions */
+ virtual void PostSetUp()
+ {
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
+ evas_object_smart_callback_add(GetEwkWebView(), "console,message",
+ ToSmartCallback(cb_console_message), this);
+ }
+
+ virtual void PreTearDown()
+ {
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
+ evas_object_smart_callback_del(GetEwkWebView(), "console,message",
+ ToSmartCallback(cb_console_message));
+ }
+
+protected:
+ Eina_Bool notificationPermissionFirsttime;
+ Eina_Bool notificationPermissionSecondtime;
+ static const char* const resource_relative_path;
+};
+
+const char* const utc_blink_ewk_notification_permission_reply::resource_relative_path = "/common/sample_notification_2.html";
+
+/**
+ * @brief Positive test case for ewk_notification_permission_reply function
+ */
+TEST_F(utc_blink_ewk_notification_permission_reply, POS_TEST)
+{
+ std::string resource_url = GetResourceUrl(resource_relative_path);
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), resource_url.c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
+ ASSERT_EQ(EINA_TRUE, notificationPermissionFirsttime);
+ ASSERT_EQ(EINA_FALSE, notificationPermissionSecondtime);
+
+ ASSERT_TRUE(click());
+ ASSERT_EQ(Success, EventLoopStart());
+ ASSERT_EQ(EINA_TRUE, notificationPermissionFirsttime);
+ ASSERT_EQ(EINA_FALSE, notificationPermissionSecondtime);
+}
+
+/**
+ * @brief Tests whether function works properly in case of NULL value pass.
+ */
+TEST_F(utc_blink_ewk_notification_permission_reply, NEG_TEST)
+{
+ /* TODO: this code should use ewk_notification_cached_permissions_set and check its behaviour.
+ Results should be reported using one of utc_ macros */
+ ewk_notification_permission_reply(NULL,0);
+
+ // If NULL argument passing wont give segmentation fault negative test case will pass
+ SUCCEED();
+}
class utc_blink_ewk_notification_permission_request_origin_get : public utc_blink_ewk_base {
protected:
- static void script_execute_callback(Evas_Object* webview, const char* result_value, void* user_data)
- {
- utc_message("execution result: %s", result_value);
- }
-
- /* Callback for "load,finished" */
- void LoadFinished(Evas_Object* webview)
- {
- utc_message("[loadFinished] :: ");
- ewk_view_script_execute(webview, "noti();", script_execute_callback, this);
- }
-
- /* Callback for "notification,permission,request" */
- static void notificationPermissionRequest(void* data, Evas_Object* webview, void* event_info)
+ /* Callback for notification permission request */
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request *request, void* data)
{
utc_message("[notificationPermissionRequest] :: ");
- ASSERT_TRUE(data != NULL);
utc_blink_ewk_notification_permission_request_origin_get *owner = static_cast<utc_blink_ewk_notification_permission_request_origin_get *>(data);
+ if (!owner) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
+ }
MainLoopResult res = Failure;
- Ewk_Notification_Permission_Request *request = (Ewk_Notification_Permission_Request*)event_info;
const Ewk_Security_Origin* origin = ewk_notification_permission_request_origin_get(request);
if (origin) {
}
//allow the notification
- ewk_notification_permission_request_set(request, EINA_TRUE);
+ ewk_notification_permission_reply(request, EINA_TRUE);
owner->EventLoopStop(res);
+ return EINA_TRUE;
}
/* Startup and cleanup functions */
virtual void PostSetUp()
{
ewk_view_mouse_events_enabled_set(GetEwkWebView(), EINA_TRUE);
- evas_object_smart_callback_add(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest, this);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
}
virtual void PreTearDown()
{
- evas_object_smart_callback_del(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
}
protected:
static const uint16_t expected_origin_port;
};
-const char* const utc_blink_ewk_notification_permission_request_origin_get::resource_file = "common/sample_notification_3.html";
+const char* const utc_blink_ewk_notification_permission_request_origin_get::resource_file = "common/sample_notification_2.html";
const char* const utc_blink_ewk_notification_permission_request_origin_get::expected_origin_protocol = "";
const char* const utc_blink_ewk_notification_permission_request_origin_get::expected_origin_host = "";
const uint16_t utc_blink_ewk_notification_permission_request_origin_get::expected_origin_port = 65535;
-
/**
- * @brief Positive test case for ewk_notification_permission_request_set function
+ * @brief Positive test case for ewk_notification_permission_reply function
*/
TEST_F(utc_blink_ewk_notification_permission_request_origin_get, POS_TEST)
{
- /* TODO: this code should use ewk_notification_permission_request_set and check its behaviour.
+ /* TODO: this code should use ewk_notification_permission_reply and check its behaviour.
Results should be reported using one of utc_ macros */
-
ASSERT_TRUE(ewk_view_url_set(GetEwkWebView(), GetResourceUrl(resource_file).c_str()));
ASSERT_EQ(Success, EventLoopStart());
}
{
/* TODO: this code should use ewk_notification_cached_permissions_set and check its behaviour.
Results should be reported using one of utc_ macros */
- ewk_notification_permission_request_set(NULL,0);
+ ewk_notification_permission_reply(NULL,0);
// If NULL argument passing wont give segmentation fault negative test case will pass
utc_pass();
virtual ~utc_blink_ewk_notification_permission_request_set() {
}
- /* Callback for "notification,permission,request" */
- static void notificationPermissionRequest(void* data, Evas_Object* webview, void* event_info)
+ /* Callback for notification permission request */
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request* request, void* data)
{
- if (!data) {
- FAIL();
- }
-
utc_blink_ewk_notification_permission_request_set* owner = static_cast<utc_blink_ewk_notification_permission_request_set*>(data);
Ewk_Context *context = ewk_view_context_get(webview);
- if (!event_info || !context) {
- FAIL();
+ if (!request || !context) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
}
//allow the notification
- ewk_notification_permission_request_set((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
+ ewk_notification_permission_request_set(request, EINA_TRUE);
if (!owner->notificationPermissionFirsttime) {
owner->notificationPermissionFirsttime = EINA_TRUE;
owner->notificationPermissionSecondtime = EINA_TRUE;
owner->EventLoopStop(Failure);
}
+ return EINA_TRUE;
}
- /* Callback for "notification,show" */
- static void notificationShow(void* data, Evas_Object* webview, void* event_info)
+ static void cb_console_message(utc_blink_ewk_notification_permission_request_set *owner, Evas_Object *obj, void *event_info)
{
- if (!event_info) {
- FAIL();
+ Ewk_Console_Message* console = static_cast<Ewk_Console_Message*>(event_info);
+ const char *cmsg = ewk_console_message_text_get(console);
+ if (!cmsg) {
+ return;
}
-
- if (!data) {
- FAIL();
+ std::string msg(cmsg);
+ std::string::size_type pos = msg.find(':');
+ if (pos == std::string::npos) {
+ return;
}
+ if (msg.substr(0, pos) == "event_loop_stop") {
+ owner->EventLoopStop(Success);
+ }
+ }
- utc_blink_ewk_notification_permission_request_set* owner = static_cast<utc_blink_ewk_notification_permission_request_set*>(data);
-
- owner->EventLoopStop(Success);
+ // helper function
+ bool click()
+ {
+ utc_message("[click] :: ");
+ return ewk_view_script_execute(GetEwkWebView(), "document.getElementById(\"startButton\").click();", NULL, NULL) == EINA_TRUE;
}
/* Startup and cleanup functions */
virtual void PostSetUp()
{
- evas_object_smart_callback_add(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest, this);
- evas_object_smart_callback_add(GetEwkWebView(), "notification,show", notificationShow, this);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
+ evas_object_smart_callback_add(GetEwkWebView(), "console,message",
+ ToSmartCallback(cb_console_message), this);
}
virtual void PreTearDown()
{
- evas_object_smart_callback_del(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest);
- evas_object_smart_callback_del(GetEwkWebView(), "notification,show", notificationShow);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
+ evas_object_smart_callback_del(GetEwkWebView(), "console,message",
+ ToSmartCallback(cb_console_message));
}
protected:
TEST_F(utc_blink_ewk_notification_permission_request_set, POS_TEST)
{
std::string resource_url = GetResourceUrl(resource_relative_path);
-
- if (!ewk_view_url_set(GetEwkWebView(), resource_url.c_str())) {
- FAIL();
- }
- /* TODO: this code should use ewk_notification_permission_request_set and check its behaviour.
- Results should be reported using one of utc_ macros */
-
- MainLoopResult loop_result = EventLoopStart();
-
- if (loop_result != Success) {
- FAIL();
- }
-
- EXPECT_EQ(notificationPermissionSecondtime, EINA_FALSE);
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), resource_url.c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
+ ASSERT_EQ(EINA_TRUE, notificationPermissionFirsttime);
+ ASSERT_EQ(EINA_FALSE, notificationPermissionSecondtime);
+
+ ASSERT_TRUE(click());
+ ASSERT_EQ(Success, EventLoopStart());
+ ASSERT_EQ(EINA_TRUE, notificationPermissionFirsttime);
+ ASSERT_EQ(EINA_FALSE, notificationPermissionSecondtime);
}
/**
class utc_blink_ewk_notification_permission_request_suspend : public utc_blink_ewk_base {
protected:
- /* Callback for "notification,permission,request" */
- static void notificationPermissionRequest(void* data, Evas_Object* webview, void* event_info)
+ utc_blink_ewk_notification_permission_request_suspend() {}
+ /* Callback for notification permission request */
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request* request, void* data)
{
Ewk_Context *context = ewk_view_context_get(webview);
- if(!event_info || !context) {
- utc_message("event_info: %p\ncontext: %p", event_info, context);
- FAIL();
- return;
+ utc_blink_ewk_notification_permission_request_suspend *owner = NULL;
+ OwnerFromVoid(data, &owner);
+ if(!request || !context) {
+ utc_message("event_info: %p\ncontext: %p", request, context);
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
}
//allow the notification
- ewk_notification_permission_request_suspend((Ewk_Notification_Permission_Request*)event_info);
- ewk_notification_permission_request_set((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
+ ewk_notification_permission_request_suspend(request);
+ ewk_notification_permission_reply(request, EINA_TRUE);
+ owner->EventLoopStop(Success);
+ return EINA_TRUE;
}
- /* Callback for "notification,show" */
- static void notificationShow(void* data, Evas_Object* webview, void* event_info)
+ static void cb_console_message(utc_blink_ewk_notification_permission_request_suspend *owner, Evas_Object *obj, void *event_info)
{
- if (!data || !event_info) {
- utc_message("data: %p\nevent_info: %p", data, event_info);
- FAIL();
+ Ewk_Console_Message* console = static_cast<Ewk_Console_Message*>(event_info);
+ const char *cmsg = ewk_console_message_text_get(console);
+ if (!cmsg) {
+ return;
+ }
+ std::string msg(cmsg);
+ std::string::size_type pos = msg.find(':');
+ if (pos == std::string::npos) {
+ return;
+ }
+ if (msg.substr(0, pos) == "event_loop_stop") {
+ owner->EventLoopStop(Success);
}
-
- utc_blink_ewk_notification_permission_request_suspend* owner = static_cast<utc_blink_ewk_notification_permission_request_suspend*>(data);
- owner->EventLoopStop(Success);
}
/* Startup function */
+ bool click()
+ {
+ utc_message("[click] :: ");
+ return ewk_view_script_execute(GetEwkWebView(), "document.getElementById(\"startButton\").click();", NULL, NULL) == EINA_TRUE;
+ }
+
+ /* Startup and cleanup functions */
virtual void PostSetUp()
{
- evas_object_smart_callback_add(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest, this);
- evas_object_smart_callback_add(GetEwkWebView(), "notification,show", notificationShow, this);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
+ evas_object_smart_callback_add(GetEwkWebView(), "console,message",
+ ToSmartCallback(cb_console_message), this);
}
- /* Cleanup function */
virtual void PreTearDown()
{
- evas_object_smart_callback_del(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest);
- evas_object_smart_callback_del(GetEwkWebView(), "notification,show", notificationShow);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
+ evas_object_smart_callback_del(GetEwkWebView(), "console,message",
+ ToSmartCallback(cb_console_message));
}
protected:
static const char* const notification_title_ref;
};
-const char* const utc_blink_ewk_notification_permission_request_suspend::resource_relative_path = "/common/sample_notification_1.html";
+const char* const utc_blink_ewk_notification_permission_request_suspend::resource_relative_path = "/common/sample_notification_2.html";
const char* const utc_blink_ewk_notification_permission_request_suspend::notification_title_ref = "Notification Title";
/**
TEST_F(utc_blink_ewk_notification_permission_request_suspend, POS_TEST)
{
std::string resource_url = GetResourceUrl(resource_relative_path);
- if (!ewk_view_url_set(GetEwkWebView(), resource_url.c_str())) {
- FAIL();
- }
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), resource_url.c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
+ ASSERT_TRUE(click());
+ ASSERT_EQ(Success, EventLoopStart());
- MainLoopResult result = EventLoopStart();
- EXPECT_EQ(result, Success);
}
/**
--- /dev/null
+// Copyright 2014 Samsung Electronics. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "utc_blink_ewk_base.h"
+
+class utc_blink_ewk_notification_policies_removed : public utc_blink_ewk_base {
+protected:
+ utc_blink_ewk_notification_policies_removed()
+ : permission_requested_(false), proto_(NULL), host_(NULL)
+ {
+ }
+
+ ~utc_blink_ewk_notification_policies_removed()
+ {
+ if (proto_) free(proto_);
+ if (host_) free(host_);
+ }
+
+ void PostSetUp()
+ {
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), cb_permission_request, this);
+ evas_object_smart_callback_add(GetEwkWebView(), "console,message",
+ ToSmartCallback(cb_console_message), this);
+ // clear permissions
+ ewk_notification_cached_permissions_set(ewk_view_context_get(GetEwkWebView()), NULL);
+ }
+
+ void PreTearDown()
+ {
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
+ evas_object_smart_callback_del(GetEwkWebView(), "console,message",
+ ToSmartCallback(cb_console_message));
+ }
+
+ /* Callback for notification permission request */
+ static Eina_Bool cb_permission_request(Evas_Object *obj, Ewk_Notification_Permission_Request *request, void *data)
+ {
+ utc_message("[cb_permission_request()]");
+ utc_blink_ewk_notification_policies_removed *owner = NULL;
+ OwnerFromVoid(data, &owner);
+ if (!request) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
+ }
+ const Ewk_Security_Origin* origin = ewk_notification_permission_request_origin_get(request);
+ if (!origin) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
+ }
+ owner->proto_ = strdup(ewk_security_origin_protocol_get(origin));
+ utc_message("[cb_permission_request] :: proto_ : %s", owner->proto_);
+ owner->host_ = strdup(ewk_security_origin_host_get(origin));
+ utc_message("[cb_permission_request] :: host_ : %s", owner->host_);
+ owner->permission_requested_ = true;
+ ewk_notification_permission_reply(request, EINA_TRUE);
+ return EINA_TRUE;
+ }
+
+ static void cb_console_message(utc_blink_ewk_notification_policies_removed *owner, Evas_Object *obj, void *event_info)
+ {
+ Ewk_Console_Message* console = static_cast<Ewk_Console_Message*>(event_info);
+ const char *cmsg = ewk_console_message_text_get(console);
+ if (!cmsg) {
+ return;
+ }
+ std::string msg(cmsg);
+ std::string::size_type pos = msg.find(':');
+ if (pos == std::string::npos) {
+ return;
+ }
+ if (msg.substr(0, pos) == "event_loop_stop") {
+ owner->EventLoopStop(Success);
+ }
+ }
+
+ // helper function
+ bool click()
+ {
+ utc_message("[click] :: ");
+ return ewk_view_script_execute(GetEwkWebView(), "document.getElementById(\"startButton\").click();", NULL, NULL) == EINA_TRUE;
+ }
+
+protected:
+ bool permission_requested_;
+ char *proto_;
+ char *host_;
+ static const char * const expected_proto_;
+ static const char * const expected_host_;
+ static const char * const resource_file_;
+};
+
+const char * const utc_blink_ewk_notification_policies_removed::expected_proto_ = "";
+const char * const utc_blink_ewk_notification_policies_removed::expected_host_ = "";
+const char * const utc_blink_ewk_notification_policies_removed::resource_file_ = "common/sample_notification_2.html";
+
+TEST_F(utc_blink_ewk_notification_policies_removed, POS_TEST)
+{
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), GetResourceUrl(resource_file_).c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
+
+ ASSERT_TRUE(permission_requested_);
+ ASSERT_STREQ(expected_proto_, proto_);
+ ASSERT_STREQ(expected_host_, host_);
+
+ permission_requested_ = false;
+ ASSERT_TRUE(click());
+ ASSERT_EQ(Success, EventLoopStart());
+
+ ASSERT_FALSE(permission_requested_);
+
+ Eina_List *list = NULL;
+ Ewk_Security_Origin *origin = ewk_security_origin_new_from_string((std::string(proto_) + "://" + std::string(host_)).c_str());
+ list = eina_list_append(list, origin);
+ ewk_notification_policies_removed(ewk_view_context_get(GetEwkWebView()), list);
+ ewk_security_origin_free(origin);
+ ASSERT_TRUE(click());
+ ASSERT_EQ(Success, EventLoopStart());
+
+ ASSERT_TRUE(permission_requested_);
+}
+
+TEST_F(utc_blink_ewk_notification_policies_removed, NEG_TEST)
+{
+ ewk_notification_policies_removed(ewk_view_context_get(GetEwkWebView()), NULL);
+ SUCCEED();
+}
class utc_blink_ewk_notification_security_origin_get_func : public utc_blink_ewk_base
{
protected:
+ utc_blink_ewk_notification_security_origin_get_func() {}
- /* Callback for "notification,permission,request" */
- static void notificationPermissionRequest(void* owner, Evas_Object* webview, void* event_info)
+ /* Callback for notification permission request */
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request* request, void* data)
{
utc_message("[notificationPermissionRequest] ::");
- ASSERT_TRUE(NULL != event_info);
+ utc_blink_ewk_notification_security_origin_get_func *owner = NULL;
+ OwnerFromVoid(data, &owner);
+ if (!request) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
+ }
//allow the notification
- ewk_notification_permission_request_set(static_cast<Ewk_Notification_Permission_Request*>(event_info), EINA_TRUE);
+ ewk_notification_permission_reply(request, EINA_TRUE);
+ return EINA_TRUE;
}
/* Callback for "notification,show" */
- static void notificationShow(void* owner, Evas_Object* webview, void* event_info)
+ static void notificationShow(void* data, Evas_Object* webview, void* event_info)
{
utc_message("[notificationShow] ::");
ASSERT_TRUE(event_info != NULL);
- ASSERT_TRUE(owner != NULL);
+ ASSERT_TRUE(data != NULL);
//call ewk_notification API
const Ewk_Security_Origin* origin = ewk_notification_security_origin_get(static_cast<Ewk_Notification*>(event_info));
ASSERT_TRUE(origin != NULL);
+ utc_blink_ewk_notification_security_origin_get_func *owner = NULL;
+ OwnerFromVoid(data, &owner);
- ASSERT_STREQ(ewk_security_origin_protocol_get(origin), "");
- ASSERT_STREQ(ewk_security_origin_host_get(origin), "");
- ASSERT_EQ(ewk_security_origin_port_get(origin), 0);
- static_cast<utc_blink_ewk_notification_security_origin_get_func*>(owner)->EventLoopStop(Success);
+ owner->protocol = ewk_security_origin_protocol_get(origin);
+ owner->host = ewk_security_origin_host_get(origin);
+ owner->port = ewk_security_origin_port_get(origin);
+
+ owner->EventLoopStop(Success);
}
void PostSetUp()
{
- evas_object_smart_callback_add(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest, this);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
evas_object_smart_callback_add(GetEwkWebView(), "notification,show", notificationShow, this);
}
void PreTearDown()
{
- evas_object_smart_callback_del(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
evas_object_smart_callback_del(GetEwkWebView(), "notification,show", notificationShow);
}
+
+ // helper function
+ bool click()
+ {
+ utc_message("[click] :: ");
+ return ewk_view_script_execute(GetEwkWebView(), "document.getElementById(\"startButton\").click();", NULL, NULL) == EINA_TRUE;
+ }
+
+protected:
+ const char* protocol;
+ const char* host;
+ uint16_t port;
};
/**
*/
TEST_F(utc_blink_ewk_notification_security_origin_get_func, POS_TEST)
{
- ASSERT_TRUE(ewk_view_url_set(GetEwkWebView(), GetResourceUrl("common/sample_notification_1.html").c_str()));
- EXPECT_EQ(Success, EventLoopStart());
+ std::string resource_url = GetResourceUrl("common/sample_notification_2.html");
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), resource_url.c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
+ ASSERT_TRUE(protocol);
+ ASSERT_TRUE(host);
+ ASSERT_STREQ("", protocol);
+ ASSERT_STREQ("", host);
+ ASSERT_EQ(0, port);
}
/**
class utc_blink_ewk_notification_showed : public utc_blink_ewk_base {
protected:
- /* Callback for "notification,permission,request" */
- static void notificationPermissionRequest(void* data, Evas_Object* webview, void* event_info)
+ utc_blink_ewk_notification_showed() {}
+
+ /* Callback for notification permission request */
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request* request, void* data)
{
utc_message("[notificationPermissionRequest] :: \n");
- if (!event_info)
- FAIL();
+ utc_blink_ewk_notification_showed *owner = NULL;
+ OwnerFromVoid(data, &owner);
+ if (!request) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
+ }
//allow the notification
- ewk_notification_permission_request_set((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
+ ewk_notification_permission_reply(request, EINA_TRUE);
+ return EINA_TRUE;
}
/* Callback for "notification,show" */
uint64_t notification_id = ewk_notification_id_get((Ewk_Notification*)event_info);
ewk_notification_showed(context, notification_id);
- owner->EventLoopStop(Success);;
+ owner->EventLoopStop(Success);
}
/* Startup function */
virtual void PostSetUp()
{
- evas_object_smart_callback_add(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest, this);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
evas_object_smart_callback_add(GetEwkWebView(), "notification,show", notificationShow, this);
}
/* Cleanup function */
virtual void PreTearDown()
{
- evas_object_smart_callback_del(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
evas_object_smart_callback_del(GetEwkWebView(), "notification,show", notificationShow);
}
static const char* const resource_relative_path;
};
-const char* const utc_blink_ewk_notification_showed::resource_relative_path = "/common/sample_notification_1.html";
+const char* const utc_blink_ewk_notification_showed::resource_relative_path = "/common/sample_notification_2.html";
/**
* @brief Positive test case for ewk_notification_showed()
TEST_F(utc_blink_ewk_notification_showed, POS_TEST)
{
std::string resource_url = GetResourceUrl(resource_relative_path);
-
- if (!ewk_view_url_set(GetEwkWebView(), resource_url.c_str())) {
- FAIL();
- }
-
- MainLoopResult main_result = EventLoopStart();
-
- utc_check_eq(Success, main_result);
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), resource_url.c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
}
/**
class utc_blink_ewk_notification_title_get : public utc_blink_ewk_base {
protected:
- /* Callback for "notification,permission,request" */
- static void notificationPermissionRequest(void* data, Evas_Object* webview, void* event_info)
+ utc_blink_ewk_notification_title_get() : title(NULL) {}
+
+ /* Callback for notification permission request */
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request* request, void* data)
{
utc_message("[notificationPermissionRequest] :: ");
-
- if (!event_info) {
- FAIL();
+ utc_blink_ewk_notification_title_get *owner = NULL;
+ OwnerFromVoid(data, &owner);
+ if (!request) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
}
//allow the notification
- ewk_notification_permission_request_set((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
+ ewk_notification_permission_reply(request, EINA_TRUE);
+ return EINA_TRUE;
}
/* Callback for "notification,show" */
utc_blink_ewk_notification_title_get* owner = static_cast<utc_blink_ewk_notification_title_get*>(data);
//call ewk_notification API
- const char* getTitle = ewk_notification_title_get((Ewk_Notification*)event_info);
- if (strcmp(getTitle, notification_title_ref) == 0) {
- owner->EventLoopStop(Success);
- } else {
- owner->EventLoopStop(Failure);
- }
+ owner->title = ewk_notification_title_get((Ewk_Notification*)event_info);
+ owner->EventLoopStop(Success);
}
/* Startup function */
virtual void PostSetUp()
{
- evas_object_smart_callback_add(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest, this);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
evas_object_smart_callback_add(GetEwkWebView(), "notification,show", notificationShow, this);
}
/* Cleanup function */
virtual void PreTearDown()
{
- evas_object_smart_callback_del(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
evas_object_smart_callback_del(GetEwkWebView(), "notification,show", notificationShow);
}
protected:
static const char* const resource_relative_path;
static const char* const notification_title_ref;
+ const char* title;
};
-const char* const utc_blink_ewk_notification_title_get::resource_relative_path = "/common/sample_notification_1.html";
+const char* const utc_blink_ewk_notification_title_get::resource_relative_path = "/common/sample_notification_2.html";
const char* const utc_blink_ewk_notification_title_get::notification_title_ref = "Notification Title";
/**
{
std::string resource_url = GetResourceUrl(resource_relative_path);
- if (!ewk_view_url_set(GetEwkWebView(), resource_url.c_str())) {
- FAIL();
- }
-
- MainLoopResult loop_result = EventLoopStart();
-
- utc_check_eq(Success, loop_result);
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), resource_url.c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
+ ASSERT_TRUE(title);
+ ASSERT_STREQ(notification_title_ref, title);
}
/**
utc_fail();
//allow the notification
- ewk_notification_permission_request_set((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
+ ewk_notification_permission_reply((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
}
/* Callback for "notification,show" */
utc_fail();
//allow the notification
- ewk_notification_permission_request_set((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
+ ewk_notification_permission_reply((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
}
/* Callback for "notification,show" */
utc_fail();
//allow the notification
- ewk_notification_permission_request_set((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
+ ewk_notification_permission_reply((Ewk_Notification_Permission_Request*)event_info, EINA_TRUE);
}
/* Callback for "notification,show" */
class utc_blink_ewk_view_notification_closed : public utc_blink_ewk_base
{
protected:
- /* Callback for "notification,permission,request" */
- static void notificationPermissionRequest(void* data, Evas_Object* webview, void* event_info)
+ utc_blink_ewk_view_notification_closed()
+ : closed(false)
+ , old_notification(NULL)
+ {}
+
+ /* Callback for notification permission request */
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request* request, void* data)
{
utc_message("[notificationPermissionRequest] :: \n");
- if (!event_info)
- utc_fail();
+ assert(data != NULL);
+ utc_blink_ewk_view_notification_closed* owner = NULL;
+ OwnerFromVoid(data, &owner);
+ if (!request) {
+ owner->EventLoopStop(Failure);
+ return EINA_FALSE;
+ }
+
//allow the notification
- ewk_notification_permission_request_set(static_cast<Ewk_Notification_Permission_Request*>(event_info), EINA_TRUE);
+ ewk_notification_permission_reply(request, EINA_TRUE);
}
/* Callback for "notification,show" */
owner->EventLoopStop(Success);
}
+ static void titleChanged(void* data, Evas_Object* webview, void* event_info)
+ {
+ const char* title = static_cast<const char*>(event_info);
+ utc_message("[titleChanged] :: title = %s", title);
+ utc_blink_ewk_view_notification_closed* owner = NULL;
+ OwnerFromVoid(data, &owner);
+ if (title && strcmp(title, "notification_closed") == 0) {
+ owner->closed = true;
+ owner->EventLoopStop(Success);
+ }
+ }
+
/* Startup function */
void PostSetUp()
{
old_notification=0;
- evas_object_smart_callback_add(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest, this);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
evas_object_smart_callback_add(GetEwkWebView(), "notification,show", notificationShow, this);
+ evas_object_smart_callback_add(GetEwkWebView(), "title,changed", titleChanged, this);
}
/* Cleanup function */
void PreTearDown()
{
- evas_object_smart_callback_del(GetEwkWebView(), "notification,permission,request", notificationPermissionRequest);
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, NULL);
evas_object_smart_callback_del(GetEwkWebView(), "notification,show", notificationShow);
+ evas_object_smart_callback_del(GetEwkWebView(), "title,changed", titleChanged);
}
protected:
- static const char*const sample;
+ static const char* const sample;
+ bool closed;
Ewk_Notification* old_notification;
};
-const char*const utc_blink_ewk_view_notification_closed::sample="common/sample_notification_1.html";
+const char*const utc_blink_ewk_view_notification_closed::sample="common/sample_notification_2.html";
/**
* @brief Positive test case for ewk_notification_showed()
*/
TEST_F(utc_blink_ewk_view_notification_closed, POS_TEST)
{
- if(!ewk_view_url_set(GetEwkWebView(), GetResourceUrl(sample).c_str()))
- utc_fail();
-
- if(!EventLoopStart())
- utc_fail();
+ std::string resource_url = GetResourceUrl(sample);
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), resource_url.c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
Eina_List *list = NULL;
list = eina_list_append(list, old_notification);
- ewk_view_notification_closed(GetEwkWebView(), list);
- utc_pass();
+ ASSERT_EQ(EINA_TRUE, ewk_view_notification_closed(GetEwkWebView(), list));
+ ASSERT_EQ(Success, EventLoopStart());
+ ASSERT_TRUE(closed);
}
/**
--- /dev/null
+// Copyright 2014 Samsung Electronics. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "utc_blink_ewk_base.h"
+
+class utc_blink_ewk_view_notification_permission_callback_set : public utc_blink_ewk_base
+{
+ protected:
+ utc_blink_ewk_view_notification_permission_callback_set() : called(false) {}
+
+ void LoadFinished(Evas_Object *o)
+ {
+ EventLoopStop(Success);
+ }
+
+ static Eina_Bool notificationPermissionRequest(Evas_Object* webview, Ewk_Notification_Permission_Request* request, void* data)
+ {
+ utc_blink_ewk_view_notification_permission_callback_set *owner = NULL;
+ OwnerFromVoid(data, &owner);
+ owner->called = true;
+ owner->EventLoopStop(Success);
+ return EINA_TRUE;
+ }
+
+ // helper function
+ bool click()
+ {
+ utc_message("[click] :: ");
+ return ewk_view_script_execute(GetEwkWebView(), "document.getElementById(\"startButton\").click();", NULL, NULL) == EINA_TRUE;
+ }
+
+ protected:
+ bool called;
+ static const char* const sample;
+};
+
+const char* const utc_blink_ewk_view_notification_permission_callback_set::sample = "common/sample_notification_2.html";
+
+TEST_F(utc_blink_ewk_view_notification_permission_callback_set, POS_TEST)
+{
+ std::string resource_url = GetResourceUrl(sample);
+ ASSERT_EQ(EINA_TRUE, ewk_view_url_set(GetEwkWebView(), resource_url.c_str()));
+ ASSERT_EQ(Success, EventLoopStart());
+
+ ASSERT_TRUE(click());
+ ASSERT_EQ(Timeout, EventLoopStart(5.0));
+
+ ASSERT_FALSE(called);
+
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), notificationPermissionRequest, this);
+
+ ASSERT_TRUE(click());
+ ASSERT_EQ(Success, EventLoopStart());
+
+ ASSERT_TRUE(called);
+ called = false;
+
+ ewk_view_notification_permission_callback_set(GetEwkWebView(), NULL, this);
+
+ ASSERT_TRUE(click());
+ ASSERT_EQ(Timeout, EventLoopStart(5.0));
+
+ ASSERT_FALSE(called);
+}
+
+TEST_F(utc_blink_ewk_view_notification_permission_callback_set, NEG_TEST)
+{
+ ewk_view_notification_permission_callback_set(NULL, NULL, NULL);
+}
+++ /dev/null
-// Copyright 2014 Samsung Electronics. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "ewk_notification_private.h"
-#include "tizen_webview/public/tw_url.h"
-#include "tizen_webview/public/tw_security_origin.h"
-
-// _Ewk_Notification ----------------------------------------------------------
-_Ewk_Notification::_Ewk_Notification(
- const std::string& body,
- const std::string& iconURL,
- const std::string& replaceID,
- const std::string& title,
- uint64_t notificationID,
- const tizen_webview::URL& origin)
- : body_(body),
- iconURL_(iconURL),
- replaceID_(replaceID),
- title_(title),
-#if 0
- notificationID_(notificationID),
-#else
-#warning "[M37] params.notification_id does not exist"
- notificationID_(0),
-#endif
- securityOrigin_(new tizen_webview::Security_Origin(origin.getHost(),
- origin.getProtocol(),
- origin.getPort())) {
-}
-
-_Ewk_Notification::~_Ewk_Notification() {
- delete securityOrigin_;
-}
-
-// _Ewk_Notification_Permission_Request ---------------------------------------
-_Ewk_Notification_Permission_Request::_Ewk_Notification_Permission_Request(
- Evas_Object* webview, int callback_context,
- const tizen_webview::URL& source_origin)
- : webview_(webview),
- origin_(new tizen_webview::Security_Origin(source_origin)),
- decided_(false),
- suspended_(false),
- callback_context_(callback_context) {
-}
-
-_Ewk_Notification_Permission_Request::~_Ewk_Notification_Permission_Request() {
- delete origin_;
-}
+++ /dev/null
-// Copyright (c) 2014 The Chromium Authors. All rights reserved.
-// Copyright 2013 Samsung Electronics. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef TIZEN_WEBVIEW_PRIVATE_TW_NOTIFICATION_IMPL_H_
-#define TIZEN_WEBVIEW_PRIVATE_TW_NOTIFICATION_IMPL_H_
-
-#include <Eina.h>
-#include <Evas.h>
-
-#include "base/strings/utf_string_conversions.h"
-#include "content/public/common/show_desktop_notification_params.h"
-
-#include "eweb_view.h"
-#include "eweb_context.h"
-
-namespace tizen_webview {
-class Security_Origin;
-class URL;
-}
-
-struct _Ewk_Notification {
- std::string body_;
- std::string iconURL_;
- std::string replaceID_;
- std::string title_;
- uint64_t notificationID_;
- tizen_webview::Security_Origin* securityOrigin_;
-
- _Ewk_Notification(const std::string& body,
- const std::string& iconURL,
- const std::string& replaceID,
- const std::string& title,
- uint64_t notificationID,
- const tizen_webview::URL& securityOrigin);
- ~_Ewk_Notification();
-};
-
-struct _Ewk_Notification_Permission_Request {
- Evas_Object* webview_;
- tizen_webview::Security_Origin* origin_;
- bool decided_;
- bool suspended_;
- int callback_context_; // required by content API
-
- _Ewk_Notification_Permission_Request(Evas_Object* webview,
- int callback_context, const tizen_webview::URL& source_origin);
- ~_Ewk_Notification_Permission_Request();
-};
-
-#endif // TIZEN_WEBVIEW_PRIVATE_TW_NOTIFICATION_IMPL_H_
#include "browser/notification/notification_controller_efl.h"
-#include "content/browser/renderer_host/render_view_host_impl.h"
-#include "content/public/browser/web_contents.h"
+#include <Eina.h>
-#include "API/ewk_notification_private.h"
#include "eweb_view.h"
-
+#include "content/browser/renderer_host/render_view_host_impl.h"
+#include "content/public/browser/web_contents.h"
#include "tizen_webview/public/tw_notification.h"
#include "tizen_webview/public/tw_security_origin.h"
+#include "tizen_webview/tw_misc_utility.h"
using tizen_webview::NotificationPermissionRequest;
using tizen_webview::Security_Origin;
RenderViewHost* render_view_host =
wv->web_contents().GetRenderViewHost();
-#warning "[M38] need proper impl. for desktop notification"
-// if (render_view_host) {
-// render_view_host->DesktopNotificationPermissionRequestDone(
-// notification->GetInternalCallbackContext());
-// if (isAllowed)
-// render_view_host->DesktopNotificationPostDisplay(
-// notification->GetInternalCallbackContext());
-// }
+ if (render_view_host) {
+ GURL origin = tizen_webview::GetGURL(
+ notification->GetSecurityOrigin()->GetURL());
+ // save decision in permissions map
+ permissions_mutex_.Acquire();
+ permissions_map_[origin] = isAllowed;
+ permissions_mutex_.Release();
+ }
+}
+
+void NotificationControllerEfl::SetPermissions(
+ const std::map<const char*, Eina_Bool>& permissions) {
+ base::AutoLock locker(permissions_mutex_);
+ permissions_map_.clear();
+ std::map<const char*, Eina_Bool>::const_iterator it = permissions.begin();
+ for (; it != permissions.end(); ++it) {
+ permissions_map_[GURL(it->first)] = (it->second == EINA_TRUE);
+ }
+}
+
+void NotificationControllerEfl::AddPermission(const GURL origin,
+ bool allowed) {
+ base::AutoLock locker(permissions_mutex_);
+ permissions_map_[origin] = allowed;
+}
+
+blink::WebNotificationPermission
+NotificationControllerEfl::CheckPermissionForOrigin(
+ const GURL &origin) const {
+ base::AutoLock locker(permissions_mutex_);
+ std::map<GURL, bool>::const_iterator it = permissions_map_.find(origin);
+ if (it == permissions_map_.end())
+ return blink::WebNotificationPermissionDefault;
+ return it->second ?
+ blink::WebNotificationPermissionAllowed :
+ blink::WebNotificationPermissionDenied;
+}
+
+void NotificationControllerEfl::ClearPermissions() {
+ base::AutoLock locker(permissions_mutex_);
+ permissions_map_.clear();
+}
+
+void NotificationControllerEfl::RemovePermissions(Eina_List* origins) {
+ Eina_List* list = NULL;
+ void* data = NULL;
+ base::AutoLock locker(permissions_mutex_);
+ EINA_LIST_FOREACH(origins, list, data) {
+ tizen_webview::Security_Origin* o =
+ static_cast<tizen_webview::Security_Origin*>(data);
+ GURL origin = tizen_webview::GetGURL(o->GetURL());
+ permissions_map_.erase(origin);
+ }
}
bool NotificationControllerEfl::IsNotificationPresent(const base::string16& replaceid, uint64_t& notification_id) {
return false;
}
+void NotificationControllerEfl::RequestPermission(
+ WebContents* web_contents,
+ const GURL& requesting_frame,
+ const base::Callback<void(bool)>& result_callback) {
+ const bool kDefaultResponse = false;
+
+ WebContentsDelegate* delegate = web_contents->GetDelegate();
+ if (!delegate) {
+ LOG(ERROR) << "Dropping PermissionNotification request caused by lack "
+ "of the WebContents delegate";
+ result_callback.Run(kDefaultResponse);
+ return;
+ }
+
+ WebContentsDelegateEfl* delegat_efl =
+ static_cast<WebContentsDelegateEfl*>(delegate);
+ EWebView* web_view = delegat_efl->web_view();
+ if (!web_view) {
+ LOG(ERROR) << "Dropping PermissionNotification request caused by lack "
+ "of the WebView";
+ result_callback.Run(kDefaultResponse);
+ return;
+ }
+ scoped_ptr<NotificationPermissionRequest> notification_permission(
+ new NotificationPermissionRequest(web_view->evas_object(),
+ result_callback, tizen_webview::GetURL(requesting_frame)));
+
+ if (!web_view->IsNotificationPermissionCallbackSet()) {
+ LOG(ERROR) << "Dropping PermissionNotification request caused by lack "
+ "of the Notification Permission Callback";
+ result_callback.Run(kDefaultResponse);
+ return;
+ }
+
+ blink::WebNotificationPermission web_notification_permission =
+ CheckPermissionForOrigin(requesting_frame);
+ if (web_notification_permission ==
+ blink::WebNotificationPermissionDefault) {
+ web_view->InvokeNotificationPermissionCallback(
+ notification_permission.get());
+ if (notification_permission->IsSuspended()) {
+ notification_permission.release();
+ return;
+ }
+ } else {
+ result_callback.Run(web_notification_permission ==
+ blink::WebNotificationPermissionAllowed);
+ }
+}
+
}//namespace
#ifndef NOTIFICATION_CONTROLLER_EFL_H
#define NOTIFICATION_CONTROLLER_EFL_H
+#include <map>
+
#include <Eina.h>
#include <Evas.h>
-#include "base/strings/utf_string_conversions.h"
+
+#include "base/callback.h"
#include "base/id_map.h"
+#include "base/memory/ref_counted.h"
+#include "base/strings/utf_string_conversions.h"
+#include "third_party/WebKit/public/platform/WebNotificationPermission.h"
+#include "tizen_webview/public/tw_url.h"
+#include "url/gurl.h"
+
namespace tizen_webview {
class NotificationPermissionRequest;
namespace content {
+class WebContents;
+
struct NotificationData {
int render_process_id;
int render_view_id;
}
};
-class NotificationControllerEfl {
+class NotificationControllerEfl :
+ public base::RefCountedThreadSafe<NotificationControllerEfl> {
public:
NotificationControllerEfl();
~NotificationControllerEfl();
tizen_webview::NotificationPermissionRequest* notification,
bool isAllowed);
+ // Sets the permissions for given origins
+ void SetPermissions(const std::map<const char*, Eina_Bool> &permissions);
+
+ // Adds permission to map
+ void AddPermission(const GURL origin, bool allowed);
+
+ // Checks stored permission for given origin
+ blink::WebNotificationPermission CheckPermissionForOrigin(
+ const GURL& origin) const;
+
+ // Removes all stored permissions
+ void ClearPermissions();
+
+ // Removes stored permissions for given origins
+ void RemovePermissions(Eina_List* origins);
+
// Checks if the notification is already present.
// If present returns the notification id of the notification else false
bool IsNotificationPresent(const base::string16& replaceid, uint64_t& notification_id);
+
+ void RequestPermission(WebContents* web_contents,
+ const GURL& requesting_frame,
+ const base::Callback<void(bool)>& result_callback);
+
private:
IDMap<NotificationData, IDMapOwnPointer> notification_map; // This stores the notifications displayed to the user
+ std::map<GURL, bool> permissions_map_;
+ mutable base::Lock permissions_mutex_;
DISALLOW_COPY_AND_ASSIGN(NotificationControllerEfl);
};
#include "content/public/browser/notification_registrar.h"
#include "content/public/browser/notification_source.h"
#include "content/public/browser/notification_types.h"
+#include "content/public/browser/web_contents.h"
#include "tizen_webview/public/tw_error.h"
using content::BrowserThread;
return getter_->cookieManager();
}
+#if defined(ENABLE_NOTIFICATIONS)
+scoped_refptr<NotificationControllerEfl>
+ BrowserContextEfl::ResourceContextEfl::GetNotificationController() const {
+ return notification_controller_efl_;
+}
+
+void BrowserContextEfl::ResourceContextEfl::set_notification_controller_efl(
+ const scoped_refptr<NotificationControllerEfl>& controller) {
+ notification_controller_efl_ = controller;
+}
+#endif
+
BrowserContextEfl::BrowserContextEfl(EWebContext* web_context, bool incognito)
: resource_context_(NULL),
web_context_(web_context),
#if defined(ENABLE_NOTIFICATIONS)
- notification_controllerefl_(new NotificationControllerEfl()),
+ notification_controller_efl_(new NotificationControllerEfl()),
#endif
temp_dir_creation_attempted_(false),
incognito_(incognito) {
}
ResourceContext* BrowserContextEfl::GetResourceContext() {
- if (!resource_context_)
+ if (!resource_context_) {
resource_context_ = new ResourceContextEfl();
+#if defined(ENABLE_NOTIFICATIONS)
+ resource_context_->set_notification_controller_efl(
+ notification_controller_efl_);
+#endif
+ }
return resource_context_;
}
return path;
}
-content::NotificationControllerEfl*
-BrowserContextEfl::GetNotificationController() const {
#if defined(ENABLE_NOTIFICATIONS)
- return notification_controllerefl_.get();
-#else
- return NULL;
-#endif
+scoped_refptr<content::NotificationControllerEfl>
+ BrowserContextEfl::GetNotificationController() const {
+ return notification_controller_efl_;
}
+#endif
net::URLRequestContextGetter* BrowserContextEfl::CreateRequestContext(
content::ProtocolHandlerMap* protocol_handlers,
base::WeakPtr<CookieManager> GetCookieManager() const;
+#if defined(ENABLE_NOTIFICATIONS)
+ scoped_refptr<NotificationControllerEfl> GetNotificationController() const;
+ void set_notification_controller_efl(
+ const scoped_refptr<NotificationControllerEfl> &controller);
+#endif
+
private:
scoped_refptr<URLRequestContextGetterEfl> getter_;
HTTPCustomHeadersEflMap http_custom_headers_;
mutable base::Lock http_custom_headers_lock_;
+#if defined(ENABLE_NOTIFICATIONS)
+ scoped_refptr<NotificationControllerEfl> notification_controller_efl_;
+#endif
DISALLOW_COPY_AND_ASSIGN(ResourceContextEfl);
};
EWebContext* WebContext() const
{ return web_context_; }
- content::NotificationControllerEfl* GetNotificationController() const;
+#if defined(ENABLE_NOTIFICATIONS)
+ scoped_refptr<content::NotificationControllerEfl>
+ GetNotificationController() const;
+#endif
private:
static void ReadCertificateAndAdd(base::FilePath* file_path);
scoped_refptr<URLRequestContextGetterEfl> request_context_getter_;
EWebContext* web_context_;
#if defined(ENABLE_NOTIFICATIONS)
- scoped_ptr<NotificationControllerEfl> notification_controllerefl_;
+ scoped_refptr<NotificationControllerEfl> notification_controller_efl_;
#endif
DownloadManagerDelegateEfl download_manager_delegate_;
base::ScopedTempDir temp_dir_;
'API/ewk_geolocation_private.h',
'API/ewk_hit_test_private.cc',
'API/ewk_hit_test_private.h',
- 'API/ewk_notification_private.cc',
- 'API/ewk_notification_private.h',
'API/ewk_policy_decision_private.cc',
'API/ewk_policy_decision_private.h',
'API/ewk_security_origin_private.h',
using tizen_webview::URL;
using tizen_webview::Security_Origin;
-#warning "[M38] tempoary disable notification. remove below line"
-#undef ENABLE_NOTIFICATIONS
-
namespace content {
ContentBrowserClientEfl::ContentBrowserClientEfl()
resource_type, overridable, strict_enforcement, callback, result);
}
+blink::WebNotificationPermission
+ ContentBrowserClientEfl::CheckDesktopNotificationPermission(
+ const GURL& source_url,
+ ResourceContext* context,
+ int) {
+ BrowserContextEfl::ResourceContextEfl* context_efl =
+ static_cast<BrowserContextEfl::ResourceContextEfl*>(context);
+#if defined(ENABLE_NOTIFICATIONS)
+ return context_efl->GetNotificationController()->CheckPermissionForOrigin(
+ source_url.GetOrigin());
+#else
+ return blink::WebNotificationPermissionDefault;
+#endif
+}
+
void ContentBrowserClientEfl::ShowDesktopNotification(
const content::ShowDesktopNotificationHostMsgParams& params,
BrowserContext* browser_context,
const GURL& requesting_frame,
bool user_gesture,
const base::Callback<void(bool)>& result_callback) {
+ DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
int render_process_id = web_contents->GetRenderProcessHost()->GetID();
int render_view_id = web_contents->GetRenderViewHost()->GetRoutingID();
- GURL origin = requesting_frame.GetOrigin();
BrowserContextEfl* browser_context =
static_cast<BrowserContextEfl*>(web_contents->GetBrowserContext());
const GeolocationPermissionContextEfl& geolocation_permission_context =
browser_context->GetGeolocationPermissionContext();
switch (permission) {
- case content::PERMISSION_GEOLOCATION:
+ case content::PERMISSION_GEOLOCATION: {
if (!browser_context) {
LOG(ERROR) << "Dropping GeolocationPermission request";
result_callback.Run(false);
requesting_frame,
result_callback);
break;
+ }
+ case content::PERMISSION_NOTIFICATIONS:
+#if defined(ENABLE_NOTIFICATIONS)
+ {
+ scoped_refptr<content::NotificationControllerEfl> notification_controller
+ = browser_context->GetNotificationController();
+ DCHECK(notification_controller.get());
+ notification_controller->RequestPermission(web_contents,
+ requesting_frame,
+ result_callback);
+ break;
+ }
+#endif
case content::PERMISSION_PROTECTED_MEDIA:
case content::PERMISSION_MIDI_SYSEX:
- case content::PERMISSION_NOTIFICATIONS:
- case content::PERMISSION_PUSH_MESSAGING:
+ case content::PERMISSION_PUSH_MESSAGING: {
NOTIMPLEMENTED() << "RequestPermission not implemented for "
<< permission;
+ ContentBrowserClient::RequestPermission(permission,
+ web_contents,
+ bridge_id,
+ requesting_frame,
+ user_gesture,
+ result_callback);
break;
- default:
+ }
+ default: {
NOTREACHED() << "Invalid RequestPermission for " << permission;
+ }
}
}
const base::Callback<void(bool)>& callback,
CertificateRequestResultType* result) override;
+ blink::WebNotificationPermission
+ CheckDesktopNotificationPermission(
+ const GURL& source_url,
+ ResourceContext* context,
+ int render_process_id) override;
+
// Show a desktop notification. If |worker| is true, the request came from an
// HTML5 web worker, otherwise, it came from a renderer.
virtual void ShowDesktopNotification(
callback->Run(iconUrls);
}
+void EWebView::SetNotificationPermissionCallback(
+ View_Notification_Permission_Callback callback, void *user_data) {
+ if (!callback) {
+ notification_permission_callback_.reset(nullptr);
+ return;
+ }
+ notification_permission_callback_.reset(
+ new NotificationPermissionCallback(evas_object_, callback, user_data));
+}
+
+bool EWebView::IsNotificationPermissionCallbackSet() const {
+ return notification_permission_callback_;
+}
+
+bool EWebView::InvokeNotificationPermissionCallback(
+ NotificationPermissionRequest *request) {
+ if (!notification_permission_callback_) {
+ return false;
+ }
+ return notification_permission_callback_->Run(request);
+}
+
void EwkViewPlainTextGetCallback::TriggerCallback(Evas_Object* obj, const std::string& content_text)
{
if(callback_)
};
class AsyncHitTestRequest;
+class NotificationPermissionCallback {
+ public:
+ NotificationPermissionCallback(
+ Evas_Object* obj,
+ tizen_webview::View_Notification_Permission_Callback func,
+ void* user_data)
+ : obj_(obj), func_(func), user_data_(user_data) {}
+ bool Run(tizen_webview::NotificationPermissionRequest* request) {
+ if (func_) {
+ return (func_)(obj_, request, user_data_) == EINA_TRUE;
+ }
+ return false;
+ }
+
+private:
+ Evas_Object* obj_;
+ tizen_webview::View_Notification_Permission_Callback func_;
+ void* user_data_;
+};
+
class JavaScriptDialogManagerEfl;
class WebViewGeolocationPermissionCallback;
void InvokeWebAppCapableGetCallback(bool capable, int callbackId);
void InvokeWebAppIconUrlGetCallback(const std::string &iconUrl, int callbackId);
void InvokeWebAppIconUrlsGetCallback(const std::map<std::string, std::string> &iconUrls, int callbackId);
+ void SetNotificationPermissionCallback(tizen_webview::View_Notification_Permission_Callback callback, void* user_data);
+ bool IsNotificationPermissionCallbackSet() const;
+ bool InvokeNotificationPermissionCallback(tizen_webview::NotificationPermissionRequest* request);
bool GetMHTMLData(tizen_webview::View_MHTML_Data_Get_Callback callback, void* user_data);
void OnMHTMLContentGet(const std::string& mhtml_content, int callback_id);
IDMap<WebApplicationIconUrlsGetCallback, IDMapOwnPointer> web_app_icon_urls_get_callback_map_;
IDMap<WebApplicationCapableGetCallback, IDMapOwnPointer> web_app_capable_get_callback_map_;
IDMap< WebAppScreenshotCapturedCallback, IDMapOwnPointer> screen_capture_cb_map_;
+ scoped_ptr<NotificationPermissionCallback> notification_permission_callback_;
content::DevToolsDelegateEfl* inspector_server_;
#ifdef TIZEN_EDGE_EFFECT
scoped_refptr<EdgeEffect> edge_effect_;
AuthChallenge,
NotificationShow,
NotificationCancel,
- NotificationPermissionRequest,
PolicyResponseDecide,
ContextMenuCustomize,
ContextMenuItemSelected,
DECLARE_EWK_VIEW_CALLBACK(AuthChallenge, "authentication,challenge", _Ewk_Auth_Challenge*);
DECLARE_EWK_VIEW_CALLBACK(NotificationShow, "notification,show", tizen_webview::Notification*);
DECLARE_EWK_VIEW_CALLBACK(NotificationCancel, "notification,cancel", uint64_t*);
-DECLARE_EWK_VIEW_CALLBACK(NotificationPermissionRequest, "notification,permission,request", tizen_webview::NotificationPermissionRequest*);
DECLARE_EWK_VIEW_CALLBACK(PolicyResponseDecide, "policy,response,decide", tizen_webview::PolicyDecision*);
DECLARE_EWK_VIEW_CALLBACK(ContextMenuCustomize, "contextmenu,customize", _Ewk_Context_Menu*);
DECLARE_EWK_VIEW_CALLBACK(ContextMenuItemSelected, "contextmenu,selected", _Ewk_Context_Menu_Item*);
namespace tizen_webview {
class Hit_Test;
class Security_Origin;
+class NotificationPermissionRequest;
// from ewk_context.h
typedef void (*Local_File_System_Origins_Get_Callback)(Eina_List *origins, void *user_data);
typedef void (*Web_App_Icon_URLs_Get_Callback)(Eina_List *icon_urls, void *user_data);
/**
+ * Callback for ewk_view_notification_permission_callback_set
+ *
+ * @param o view object to request the notification permission
+ * @param request Ewk_Notification_Permission_Request object to get the information about notification permission request.
+ * @param user_data user data
+ */
+typedef Eina_Bool (*View_Notification_Permission_Callback)(Evas_Object *o, NotificationPermissionRequest *request, void *user_data);
+
+/**
* Callback for ewk_view_script_execute
*
* @param o the view object
#include "tw_notification.h"
-#include "API/ewk_notification_private.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/web_contents.h"
+#include "eweb_view.h"
+#include "tw_web_context.h"
+
+using content::BrowserThread;
namespace tizen_webview {
const std::string& title,
uint64_t notificationID,
const tizen_webview::URL& origin)
- : impl(new Impl(body, iconURL, replaceID, title, notificationID, origin)) {
+ : body_(body)
+ , iconURL_(iconURL)
+ , replaceID_(replaceID)
+ , title_(title)
+ , notificationID_(notificationID)
+ , origin_(new Security_Origin(origin)) {
}
Notification::~Notification() {
- delete impl;
}
const char* Notification::GetBody() const {
- return impl->body_.c_str();
+ return body_.c_str();
}
const char* Notification::GetIconUrl() const {
- return impl->iconURL_.c_str();
+ return iconURL_.c_str();
}
const char* Notification::GetReplaceId() const {
- return impl->replaceID_.c_str();
+ return replaceID_.c_str();
}
const char* Notification::GetTitle() const {
- return impl->title_.c_str();
+ return title_.c_str();
}
int Notification::GetID() const {
- return impl->notificationID_;
+ return notificationID_;
}
const Security_Origin* Notification::GetSecurityOrigin() const {
- return impl->securityOrigin_;
+ return origin_.get();
}
// tizen_webview::NotificationPermissionRequest -------------------------------
NotificationPermissionRequest::NotificationPermissionRequest(
- Evas_Object* webview, int callback_context, const URL& source_origin)
- : impl(new _Ewk_Notification_Permission_Request(
- webview, callback_context,source_origin)) {
+ Evas_Object* webview,
+ const base::Callback<void(bool)>& callback,
+ const URL& source_origin)
+ : webview_(webview)
+ , origin_(new Security_Origin(source_origin))
+ , callback_(callback)
+ , decided_(false)
+ , suspended_(false)
+{
}
NotificationPermissionRequest::~NotificationPermissionRequest() {
- delete impl;
}
Evas_Object* NotificationPermissionRequest::GetWebviewEvasObject() const {
- return impl->webview_;
+ return webview_;
}
const Security_Origin* NotificationPermissionRequest::GetSecurityOrigin() const {
- return impl->origin_;
+ return origin_.get();
}
bool NotificationPermissionRequest::IsDecided() const {
- return impl->decided_;
+ return decided_;
}
bool NotificationPermissionRequest::IsSuspended() const {
- return impl->suspended_;
+ return suspended_;
}
void NotificationPermissionRequest::SetSuspend(bool suspend) const {
- impl->suspended_ = suspend;
-}
-
-int NotificationPermissionRequest::GetInternalCallbackContext() const {
- return impl->callback_context_;
+ suspended_ = suspend;
+}
+
+void NotificationPermissionRequest::Reply(bool allow) {
+#if defined(ENABLE_NOTIFICATIONS)
+ if (decided_)
+ return;
+ decided_ = true;
+ EWebView* view = EWebView::FromEvasObject(webview_);
+ if (view) {
+ view->context()->browser_context()->GetNotificationController()->
+ SetPermissionForNotification(this, allow);
+ }
+ callback_.Run(allow);
+
+ if (suspended_) {
+ // If decision was suspended, then it was not deleted by the creator
+ // Deletion of this object must be done after decision was made, as
+ // this object will no longer be valid. But if decision was not suspended
+ // it will be deleted right after permission callbacks are executed.
+ BrowserThread::DeleteSoon(BrowserThread::UI, FROM_HERE, this);
+ }
+#endif
}
} // namespace tizen_webview
#include <Evas.h>
#include <string>
+
+#include "base/callback.h"
+#include "base/memory/scoped_ptr.h"
+
#include "tizen_webview/public/tw_macro.h"
+#include "tizen_webview/public/tw_security_origin.h"
struct _Ewk_Notification;
struct _Ewk_Notification_Permission_Request;
namespace content {
class NotificationControllerEfl;
+class WebContents;
}
namespace tizen_webview {
-class Security_Origin;
class URL;
class Notification {
const Security_Origin* GetSecurityOrigin() const;
private:
- typedef ::_Ewk_Notification Impl;
- Impl *impl;
+ std::string body_;
+ std::string iconURL_;
+ std::string replaceID_;
+ std::string title_;
+ uint64_t notificationID_;
+ scoped_ptr<Security_Origin> origin_;
+
DISALLOW_COPY_AND_ASSIGN(Notification);
};
class NotificationPermissionRequest {
public:
NotificationPermissionRequest(Evas_Object* webview,
- int callback_context,
+ const base::Callback<void(bool)>& callback,
const tizen_webview::URL& source_origin);
~NotificationPermissionRequest();
bool IsDecided() const;
bool IsSuspended() const;
void SetSuspend(bool suspend) const;
+ void Reply(bool allow);
private:
- // get chromium internal callback context
- int GetInternalCallbackContext() const;
- friend class content::NotificationControllerEfl;
-
- typedef ::_Ewk_Notification_Permission_Request Impl;
- Impl *impl;
-
+ Evas_Object* webview_;
+ scoped_ptr<Security_Origin> origin_;
+ base::Callback<void(bool)> callback_;
+ bool decided_;
+ mutable bool suspended_;
DISALLOW_COPY_AND_ASSIGN(NotificationPermissionRequest);
};
// found in the LICENSE file.
#include "tw_security_origin.h"
+#include "tizen_webview/tw_misc_utility.h"
#include "tizen_webview/public/tw_url.h"
+#include "url/gurl.h"
namespace tizen_webview {
return port;
}
+Security_Origin* Security_Origin::CreateFromString(const char *url) {
+ if (!url)
+ return 0;
+
+ GURL gurl(url);
+ if (gurl.is_empty() || !gurl.is_valid())
+ return 0;
+
+ return new Security_Origin(tizen_webview::GetURL(gurl));
+}
+
} // namespace tizen_webview
Eina_Stringshare* GetProtocol() const;
int GetPort() const;
+ static Security_Origin* CreateFromString(const char* url);
+
private:
Eina_Stringshare* host;
Eina_Stringshare* protocol;
return impl_->InvokeWebAppIconUrlsGetCallback(iconUrls, callbackId);
}
+void WebView::SetNotificationPermissionCallback(
+ View_Notification_Permission_Callback callback, void* user_data) {
+ return impl_->SetNotificationPermissionCallback(callback, user_data);
+}
+
bool WebView::SaveAsPdf(int width, int height, const std::string& file_name) {
return impl_->SaveAsPdf(width, height, file_name);
}
void InvokeWebAppIconUrlGetCallback(const std::string &iconUrl, int callbackId);
void InvokeWebAppIconUrlsGetCallback(const std::map<std::string, std::string> &iconUrls, int callbackId);
+ // ---- Notification Permission Request
+ void SetNotificationPermissionCallback(
+ tizen_webview::View_Notification_Permission_Callback callback,
+ void* user_data);
+
// ---- Misc.
bool SaveAsPdf(int width, int height, const std::string& file_name);
// Returns TCP port number with Inspector, or 0 if error.
projects / platform / framework / web / chromium-efl.git / commitdiff