From f7bec39ba7c3b0bf9047b22a790d9549e365ab9b Mon Sep 17 00:00:00 2001 From: Lukasz Bardeli Date: Thu, 26 Oct 2017 09:51:47 +0200 Subject: [PATCH] [PPM] requestPermission implementation [Verification] Code compiles without error. Tested in chrome console. Change-Id: I2515dd8c5e8e10e3f92da8104d519ccc81fea970 Signed-off-by: Lukasz Bardeli --- src/ppm/ppm_api.js | 9 +---- src/ppm/ppm_instance.cc | 86 ++++++++++++++++++++++++++++++----------- src/ppm/ppm_instance.h | 8 ++-- 3 files changed, 69 insertions(+), 34 deletions(-) diff --git a/src/ppm/ppm_api.js b/src/ppm/ppm_api.js index fa0cd6f1..6bc52a06 100644 --- a/src/ppm/ppm_api.js +++ b/src/ppm/ppm_api.js @@ -20,12 +20,6 @@ var type_ = xwalk.utils.type; var types_ = validator_.Types; var native_ = new xwalk.utils.NativeManager(extension); -var PermissionRequestResult = { - ALLOW_FOREVER: 'ALLOW_FOREVER', - DENY_FOREVER: 'DENY_FOREVER', - DENY_ONCE: 'DENY_ONCE' -}; - function PPMManager() { } @@ -58,8 +52,7 @@ PPMManager.prototype.requestPermission = function() { if (native_.isFailure(result)) { native_.callIfPossible(args.errorCallback, native_.getErrorObject(result)); } else { - // TODO fill with proper data - args.successCallback(result.result); + args.successCallback(result.result, result.privilege); } }; diff --git a/src/ppm/ppm_instance.cc b/src/ppm/ppm_instance.cc index e09fa8c4..7f419a32 100644 --- a/src/ppm/ppm_instance.cc +++ b/src/ppm/ppm_instance.cc @@ -20,7 +20,6 @@ #include "common/logger.h" #include "common/picojson.h" -#include "common/task-queue.h" namespace extension { namespace ppm { @@ -29,8 +28,16 @@ namespace { const std::string kPPMCheckResultAllow = "PPM_ALLOW"; const std::string kPPMCheckResultDeny = "PPM_DENY"; const std::string kPPMCheckResultAsk = "PPM_ASK"; +const std::string kPPMCheckRequestResultAllowForever = "PPM_ALLOW_FOREVER"; +const std::string kPPMCheckRequestResultDenyForever = "PPM_DENY_FOREVER"; +const std::string kPPMCheckRequestResultDenyOnce = "PPM_DENY_ONCE"; } +struct ResponseCallbackData { + PPMInstance* _instance; + double callbackId; +}; + PPMInstance::PPMInstance() { ScopeLogger(); using std::placeholders::_1; @@ -48,8 +55,7 @@ PPMInstance::~PPMInstance() { ScopeLogger(); } -common::PlatformResult PPMInstance::convertError(int err, - const std::string& message) { +common::PlatformResult PPMInstance::convertError(int err, const std::string& message) { ScopeLogger(); char* error = nullptr; @@ -59,34 +65,68 @@ common::PlatformResult PPMInstance::convertError(int err, error = (char*)message.c_str(); } - switch(err) { + switch (err) { case PRIVACY_PRIVILEGE_MANAGER_ERROR_INVALID_PARAMETER: return common::PlatformResult(common::ErrorCode::INVALID_VALUES_ERR, error); case PRIVACY_PRIVILEGE_MANAGER_ERROR_IO_ERROR: case PRIVACY_PRIVILEGE_MANAGER_ERROR_ALREADY_IN_PROGRESS: case PRIVACY_PRIVILEGE_MANAGER_ERROR_OUT_OF_MEMORY: case PRIVACY_PRIVILEGE_MANAGER_ERROR_UNKNOWN: - return common::PlatformResult(common::ErrorCode::ABORT_ERR, message); + return common::PlatformResult(common::ErrorCode::ABORT_ERR, error); default: - return common::PlatformResult(common::ErrorCode::ABORT_ERR, "Unknown error."); + return common::PlatformResult(common::ErrorCode::ABORT_ERR, "Abort error."); } } std::string PPMInstance::CheckResultToString(ppm_check_result_e result) { ScopeLogger(); - switch(result) { + switch (result) { case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_ALLOW: return kPPMCheckResultAllow; - case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_DENY: - return kPPMCheckResultDeny; case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_ASK: return kPPMCheckResultAsk; + case PRIVACY_PRIVILEGE_MANAGER_CHECK_RESULT_DENY: default: return kPPMCheckResultDeny; } } +std::string PPMInstance::CheckRequestResultToString(ppm_request_result_e result) { + ScopeLogger(); + + switch (result) { + case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_ALLOW_FOREVER: + return kPPMCheckRequestResultAllowForever; + case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_DENY_FOREVER: + return kPPMCheckRequestResultDenyForever; + case PRIVACY_PRIVILEGE_MANAGER_REQUEST_RESULT_DENY_ONCE: + default: + return kPPMCheckRequestResultDenyOnce; + } +} + +void PPMInstance::ResponseCallback(ppm_call_cause_e cause, ppm_request_result_e result, + const char* privilege, void* user_data) { + ScopeLogger(); + + std::unique_ptr data{static_cast(user_data)}; + + picojson::value event = picojson::value(picojson::object()); + picojson::object& obj = event.get(); + + obj.insert(std::make_pair("callbackId", picojson::value(data->callbackId))); + + if (PRIVACY_PRIVILEGE_MANAGER_CALL_CAUSE_ANSWER == cause) { + obj.insert(std::make_pair("result", picojson::value(CheckRequestResultToString(result)))); + obj.insert(std::make_pair("privilege", picojson::value(privilege))); + } else { + LogAndReportError( + common::PlatformResult(common::ErrorCode::ABORT_ERR, "Get callback data failed"), &obj); + } + common::Instance::PostMessage(data->_instance, event.serialize().c_str()); +} + void PPMInstance::checkPermission(const picojson::value& args, picojson::object& out) { ScopeLogger(); const std::string& privilege = args.get("privilege").get(); @@ -97,12 +137,12 @@ void PPMInstance::checkPermission(const picojson::value& args, picojson::object& int ret = ppm_check_permission(privilege.c_str(), &result); if (PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE != ret) { - LogAndReportError(convertError(ret), &out, ("checkPermission error: %d (%s)", - ret, get_error_message(ret))); + LogAndReportError(convertError(ret), &out, + ("checkPermission error: %d (%s)", ret, get_error_message(ret))); return; } - ReportSuccess(picojson::value(CheckResultToString(result)),out); + ReportSuccess(picojson::value(CheckResultToString(result)), out); } void PPMInstance::requestPermission(const picojson::value& args, picojson::object& out) { @@ -113,20 +153,20 @@ void PPMInstance::requestPermission(const picojson::value& args, picojson::objec const std::string& privilege = args.get("privilege").get(); LoggerD("Requesting privilege: %s ", privilege.c_str()); - auto get = [this, privilege, - callback_id](const std::shared_ptr& response) -> void { - ScopeLogger("Entered into asynchronous function, get"); - - picojson::object& obj = response->get(); + ResponseCallbackData* user_data{new ResponseCallbackData()}; + user_data->_instance = this; + user_data->callbackId = callback_id; - ReportSuccess(obj); - obj.insert(std::make_pair("callbackId", picojson::value(callback_id))); - Instance::PostMessage(this, response->serialize().c_str()); - }; + int ret = + ppm_request_permission(privilege.c_str(), ResponseCallback, static_cast(user_data)); - auto data = std::shared_ptr(new picojson::value(picojson::object())); + if (PRIVACY_PRIVILEGE_MANAGER_ERROR_NONE != ret) { + LogAndReportError(convertError(ret), &out, + ("checkPermission error: %d (%s)", ret, get_error_message(ret))); + return; + } - common::TaskQueue::GetInstance().Async(get, data); + ReportSuccess(out); } } // namespace ppm diff --git a/src/ppm/ppm_instance.h b/src/ppm/ppm_instance.h index 1c135b5a..9d1825ce 100644 --- a/src/ppm/ppm_instance.h +++ b/src/ppm/ppm_instance.h @@ -20,8 +20,8 @@ #include #include "common/extension.h" -#include "common/platform_result.h" #include "common/platform_exception.h" +#include "common/platform_result.h" #include @@ -37,9 +37,11 @@ class PPMInstance : public common::ParsedInstance { void checkPermission(const picojson::value& args, picojson::object& out); void requestPermission(const picojson::value& args, picojson::object& out); - static common::PlatformResult convertError(int err, - const std::string& message = ""); + static common::PlatformResult convertError(int err, const std::string& message = ""); static std::string CheckResultToString(ppm_check_result_e result); + static std::string CheckRequestResultToString(ppm_request_result_e result); + static void ResponseCallback(ppm_call_cause_e cause, ppm_request_result_e result, + const char* privilege, void* user_data); }; } // namespace ppm -- 2.34.1