[PPM] requestPermission implementation

[Verification] Code compiles without error. Tested in chrome console.

Change-Id: I2515dd8c5e8e10e3f92da8104d519ccc81fea970
Signed-off-by: Lukasz Bardeli <l.bardeli@samsung.com>

diff --git a/src/ppm/ppm_api.js b/src/ppm/ppm_api.js
index fa0cd6f16bff2c505db2b348e575e9297b8fbbc4..6bc52a06e8d45edeb9c64b507cb2e4ee734ac0b6 100644 (file)
--- 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 e09fa8c4c0543ac17df6240da0bf5874d9d6d98f..7f419a320e5ec0a3dd70dd7490f6d517f8c9d617 100644 (file)
--- 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<ResponseCallbackData> data{static_cast<ResponseCallbackData*>(user_data)};
+
+  picojson::value event = picojson::value(picojson::object());
+  picojson::object& obj = event.get<picojson::object>();
+
+  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<std::string>();
@@ -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<std::string>();
   LoggerD("Requesting privilege: %s ", privilege.c_str());
 
-  auto get = [this, privilege,
-              callback_id](const std::shared_ptr<picojson::value>& response) -> void {
-    ScopeLogger("Entered into asynchronous function, get");
-
-    picojson::object& obj = response->get<picojson::object>();
+  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<void*>(user_data));
 
-  auto data = std::shared_ptr<picojson::value>(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<picojson::value>(get, data);
+  ReportSuccess(out);
 }
 
 }  // namespace ppm

diff --git a/src/ppm/ppm_instance.h b/src/ppm/ppm_instance.h
index 1c135b5a7713d57bd937001fa72abfd3ddd7cb22..9d1825ce641ab648980f187e06e3cc907593a170 100644 (file)
--- a/src/ppm/ppm_instance.h
+++ b/src/ppm/ppm_instance.h
@@ -20,8 +20,8 @@
 #include <string>
 
 #include "common/extension.h"
-#include "common/platform_result.h"
 #include "common/platform_exception.h"
+#include "common/platform_result.h"
 
 #include <privacy_privilege_manager.h>
 
@@ -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