Use modified tizen_base::Parcel

To improve the performance of the parcel creation, the implementation of
the Parcel is changed. It uses malloc() instead of std::vector.

Requires:
 - https://review.tizen.org/gerrit/#/c/platform/core/base/bundle/+/281779/

Change-Id: Iebb0c2905b860fab8247971c9fe064c4f1c92a48
Signed-off-by: Hwankyu Jhun <h.jhun@samsung.com>

diff --git a/src/client/pkginfo_client.cc b/src/client/pkginfo_client.cc
index cbd3ae5..c595f28 100644 (file)
--- a/src/client/pkginfo_client.cc
+++ b/src/client/pkginfo_client.cc
@@ -80,19 +80,17 @@ bool PkgInfoClient::SendRequest() {
 
   tizen_base::Parcel p;
   p.WriteParcelable(*parcel_.get());
-  const auto& raw = p.GetRaw();
-  int len = raw.size();
 
   // CREATE_DB request type need to be executed directly by the caller
   if (req_type_ == pkgmgr_common::ReqType::CREATE_DB) {
     is_offline_ = true;
-    return RequestHandlerDirectAccess(p.GetRaw());
+    return RequestHandlerDirectAccess(&p);
   }
 
   if (!check_server.IsReady()) {
     LOG(WARNING) << "Server is not ready, try to direct access";
     is_offline_ = true;
-    return RequestHandlerDirectAccess(p.GetRaw());
+    return RequestHandlerDirectAccess(&p);
   }
 
   LOG(WARNING) << "Try to send request, Request type: "
@@ -102,7 +100,7 @@ bool PkgInfoClient::SendRequest() {
   if (!socket_->Connect(req_type_)) {
     LOG(ERROR) << "Failed to connect client socket, try to direct access";
     is_offline_ = true;
-    return RequestHandlerDirectAccess(p.GetRaw());
+    return RequestHandlerDirectAccess(&p);
   }
 
   if (socket_->SendData(&req_type_, sizeof(req_type_)) != 0) {
@@ -116,12 +114,13 @@ bool PkgInfoClient::SendRequest() {
     return false;
   }
 
+  size_t len = p.GetDataSize();
   if (socket_->SendData(&len, sizeof(len)) != 0) {
     LOG(ERROR) << "fail to send data";
     return false;
   }
 
-  if (socket_->SendData(&raw[0], len) != 0) {
+  if (socket_->SendData(p.GetData(), len) != 0) {
     LOG(ERROR) << "Fail to send data";
     return false;
   }
@@ -145,7 +144,7 @@ PkgInfoClient::GetResultParcel() {
     return nullptr;
   }
 
-  unsigned char* raw = new (std::nothrow) unsigned char[len];
+  unsigned char* raw = static_cast<unsigned char*>(malloc(len));
   if (raw == nullptr) {
     LOG(ERROR) << "Out of memory";
     return nullptr;
@@ -153,7 +152,7 @@ PkgInfoClient::GetResultParcel() {
 
   if (socket_->ReceiveData(raw, len) != 0) {
     LOG(ERROR) << "Fail to receive data";
-    delete[] raw;
+    free(raw);
     return nullptr;
   }
 
@@ -161,18 +160,14 @@ PkgInfoClient::GetResultParcel() {
 
   cpu_inheritance_invoker_.ClearCPUInheritance();
 
-  auto res = pkgmgr_common::parcel::ParcelableFactory::GetInst().CreateParcel(
+  return pkgmgr_common::parcel::ParcelableFactory::GetInst().CreateParcel(
       raw, len);
-  delete[] raw;
-
-  return res;
 }
 
-bool PkgInfoClient::RequestHandlerDirectAccess(
-    const std::vector<uint8_t>& raw) {
+bool PkgInfoClient::RequestHandlerDirectAccess(tizen_base::Parcel* parcel) {
   static std::mutex lock;
   static void* handle = nullptr;
-  static void* (*dl_func)(int, const unsigned char*, int, const char*);
+  static void* (*dl_func)(int, unsigned char*, int, const char*);
 
   std::unique_lock<std::mutex> u(lock);
   if (handle == nullptr) {
@@ -183,7 +178,7 @@ bool PkgInfoClient::RequestHandlerDirectAccess(
       return false;
     }
     dl_func = reinterpret_cast<void* (*)(
-        int, const unsigned char*, int, const char*)>(
+        int, unsigned char*, int, const char*)>(
             dlsym(handle, DIRECT_ACCESS_FUNC));
     if (dl_func == nullptr) {
       LOG(ERROR) << "cannot find " << DIRECT_ACCESS_FUNC << " symbol in "
@@ -195,9 +190,11 @@ bool PkgInfoClient::RequestHandlerDirectAccess(
   }
   u.unlock();
 
+  size_t len = 0;
+  uint8_t* raw = parcel->Detach(&len);
   result_parcel_.reset(
       reinterpret_cast<pkgmgr_common::parcel::AbstractParcelable*>(
-          dl_func(req_type_, &raw[0], raw.size(),
+          dl_func(req_type_, raw, len,
               pkgmgr_common::SystemLocale::GetInst(false).Get().c_str())));
 
   return true;

diff --git a/src/client/pkginfo_client.hh b/src/client/pkginfo_client.hh
index 67d50d0..d3ca9eb 100644 (file)
--- a/src/client/pkginfo_client.hh
+++ b/src/client/pkginfo_client.hh
@@ -34,7 +34,7 @@ class PkgInfoClient {
   std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> GetResultParcel();
 
  private:
-  bool RequestHandlerDirectAccess(const std::vector<uint8_t>& raw);
+  bool RequestHandlerDirectAccess(tizen_base::Parcel* parcel);
 
   std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> parcel_;
   std::shared_ptr<pkgmgr_common::parcel::AbstractParcelable> result_parcel_;

diff --git a/src/common/parcel/parcelable_factory.cc b/src/common/parcel/parcelable_factory.cc
index 669e8dd..df61796 100644 (file)
--- a/src/common/parcel/parcelable_factory.cc
+++ b/src/common/parcel/parcelable_factory.cc
@@ -41,11 +41,11 @@ ParcelableFactory& ParcelableFactory::GetInst() {
 }
 
 std::unique_ptr<AbstractParcelable> ParcelableFactory::CreateParcel(
-    const unsigned char* data, int size) {
+    unsigned char* data, int size, bool copy) {
   int tmp;
   std::unique_ptr<AbstractParcelable> res = nullptr;
 
-  tizen_base::Parcel parcel(data, size);
+  tizen_base::Parcel parcel(data, size, copy);
   parcel.ReadInt32(&tmp);
   parcel.ResetReader();
   ParcelableType type = static_cast<ParcelableType>(tmp);

diff --git a/src/common/parcel/parcelable_factory.hh b/src/common/parcel/parcelable_factory.hh
index 23edf90..ee95918 100644 (file)
--- a/src/common/parcel/parcelable_factory.hh
+++ b/src/common/parcel/parcelable_factory.hh
@@ -31,8 +31,8 @@ namespace parcel {
 class EXPORT_API ParcelableFactory {
  public:
   static ParcelableFactory& GetInst();
-  std::unique_ptr<AbstractParcelable> CreateParcel(
-      const unsigned char* data, int size);
+  std::unique_ptr<AbstractParcelable> CreateParcel(unsigned char* data,
+      int size, bool copy = false);
 
  private:
   ParcelableFactory();

diff --git a/src/server/create_cache_request.cc b/src/server/create_cache_request.cc
index a231aa0..0d49d0f 100644 (file)
--- a/src/server/create_cache_request.cc
+++ b/src/server/create_cache_request.cc
@@ -45,8 +45,9 @@ pkgmgr_common::ReqType CreateCacheRequest::GetRequestType() {
   return pkgmgr_common::ReqType::CREATE_CACHE;
 }
 
-bool CreateCacheRequest::SendData(tizen_base::Parcel parcel) {
-  bool ret = static_cast<bool>((parcel.GetRaw().data())[0]);
+bool CreateCacheRequest::SendData(const tizen_base::Parcel& parcel) {
+  bool ret;
+  const_cast<tizen_base::Parcel&>(parcel).ReadBool(&ret);
   if (listener_ != nullptr)
     listener_->OnCreateCacheDone(ret);
 

diff --git a/src/server/create_cache_request.hh b/src/server/create_cache_request.hh
index f16e981..18a03fe 100644 (file)
--- a/src/server/create_cache_request.hh
+++ b/src/server/create_cache_request.hh
@@ -44,7 +44,7 @@ class EXPORT_API CreateCacheRequest : public PkgRequest {
   pid_t GetSenderTID() override;
   uid_t GetSenderUID() override;
   pkgmgr_common::ReqType GetRequestType() override;
-  bool SendData(tizen_base::Parcel parcel) override;
+  bool SendData(const tizen_base::Parcel& parcel) override;
   bool GetPrivilegeChecked() override;
 
  private:

diff --git a/src/server/pkg_request.cc b/src/server/pkg_request.cc
index 5a00848..5de4a28 100644 (file)
--- a/src/server/pkg_request.cc
+++ b/src/server/pkg_request.cc
@@ -36,8 +36,7 @@ PkgRequest::PkgRequest(int fd)
 }
 
 PkgRequest::~PkgRequest() {
-  if (data_ != nullptr)
-    delete[] data_;
+  free(data_);
 }
 
 const unsigned char* PkgRequest::GetData() {
@@ -92,7 +91,7 @@ bool PkgRequest::ReceiveData() {
     return false;
   }
 
-  data_ = new (std::nothrow) unsigned char[data_size_];
+  data_ = static_cast<unsigned char*>(malloc(data_size_));
   if (data_ == nullptr) {
     LOG(ERROR) << "Out of memory";
     request_type_ = pkgmgr_common::REQ_TYPE_NONE;
@@ -101,7 +100,7 @@ bool PkgRequest::ReceiveData() {
   ret = socket_->ReceiveData(reinterpret_cast<void*>(data_), data_size_);
   if (ret < 0) {
     LOG(ERROR) << "Failed to ReceiveData";
-    delete[] data_;
+    free(data_);
     data_ = nullptr;
     request_type_ = pkgmgr_common::REQ_TYPE_NONE;
     return false;
@@ -110,13 +109,13 @@ bool PkgRequest::ReceiveData() {
   return true;
 }
 
-bool PkgRequest::SendData(tizen_base::Parcel parcel) {
-  const std::vector<uint8_t>& raw = parcel.GetRaw();
-  unsigned int size = raw.size();
+bool PkgRequest::SendData(const tizen_base::Parcel& parcel) {
+  auto* raw = parcel.GetData();
+  size_t size = parcel.GetDataSize();
   if (socket_->SendData(&size, sizeof(size)) < 0)
     return false;
 
-  return (socket_->SendData(raw.data(), size) == 0);
+  return (socket_->SendData(raw, size) == 0);
 }
 
 bool PkgRequest::GetPrivilegeChecked() {
@@ -127,4 +126,10 @@ void PkgRequest::SetPrivilegeChecked(bool checked) {
   privilege_checked_ = checked;
 }
 
+unsigned char* PkgRequest::DetachData() {
+  unsigned char* data = data_;
+  data_ = nullptr;
+  return data;
+}
+
 }  // namespace pkgmgr_server

diff --git a/src/server/pkg_request.hh b/src/server/pkg_request.hh
index 3ab6773..dcd2cfa 100644 (file)
--- a/src/server/pkg_request.hh
+++ b/src/server/pkg_request.hh
@@ -47,9 +47,10 @@ class EXPORT_API PkgRequest {
   virtual pid_t GetSenderTID();
   virtual uid_t GetSenderUID();
   virtual pkgmgr_common::ReqType GetRequestType();
-  virtual bool SendData(tizen_base::Parcel parcel);
+  virtual bool SendData(const tizen_base::Parcel& parcel);
   virtual bool GetPrivilegeChecked();
   virtual void SetPrivilegeChecked(bool cheked);
+  virtual unsigned char* DetachData();
 
  private:
   std::unique_ptr<pkgmgr_common::socket::DataSocket> socket_;

diff --git a/src/server/request_handler/abstract_request_handler.hh b/src/server/request_handler/abstract_request_handler.hh
index a823eda..5c093e7 100644 (file)
--- a/src/server/request_handler/abstract_request_handler.hh
+++ b/src/server/request_handler/abstract_request_handler.hh
@@ -23,7 +23,7 @@ namespace request_handler {
 class EXPORT_API AbstractRequestHandler {
  public:
   virtual ~AbstractRequestHandler() = default;
-  virtual bool HandleRequest(const unsigned char* data, int size,
+  virtual bool HandleRequest(unsigned char* data, int size,
       const std::string& locale) = 0;
 
   virtual tizen_base::Parcel ExtractResult();

diff --git a/src/server/request_handler/command_request_handler.cc b/src/server/request_handler/command_request_handler.cc
index d75a50c..47426fa 100644 (file)
--- a/src/server/request_handler/command_request_handler.cc
+++ b/src/server/request_handler/command_request_handler.cc
@@ -20,8 +20,8 @@ namespace pcp = pkgmgr_common::parcel;
 namespace pkgmgr_server {
 namespace request_handler {
 
-bool CommandRequestHandler::HandleRequest(const unsigned char* data, int size,
-                                             const std::string& locale) {
+bool CommandRequestHandler::HandleRequest(unsigned char* data, int size,
+    const std::string& locale) {
   auto abstract_parcel =
       pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 

diff --git a/src/server/request_handler/command_request_handler.hh b/src/server/request_handler/command_request_handler.hh
index 04e4d08..a999aff 100644 (file)
--- a/src/server/request_handler/command_request_handler.hh
+++ b/src/server/request_handler/command_request_handler.hh
@@ -20,11 +20,11 @@ namespace request_handler {
 
 class EXPORT_API CommandRequestHandler : public AbstractRequestHandler {
  public:
-  bool HandleRequest(const unsigned char* data, int size,
+  bool HandleRequest(unsigned char* data, int size,
       const std::string& locale) override;
 };
 
 }  // namespace request_handler
 }  // namespace pkgmgr_server
 
-#endif  // COMMAND_REQUEST_HANDLER_HH_
\ No newline at end of file
+#endif  // COMMAND_REQUEST_HANDLER_HH_

diff --git a/src/server/request_handler/create_cache_request_handler.cc b/src/server/request_handler/create_cache_request_handler.cc
index d23db49..93bdf1a 100644 (file)
--- a/src/server/request_handler/create_cache_request_handler.cc
+++ b/src/server/request_handler/create_cache_request_handler.cc
@@ -64,8 +64,8 @@ int CreateCacheRequestHandler::Scheduler::Set(int priority) {
 CreateCacheRequestHandler::CreateCacheRequestHandler(): scheduler_(gettid()) {
 }
 
-bool CreateCacheRequestHandler::HandleRequest(const unsigned char* data, int size,
-                                            const std::string& locale) {
+bool CreateCacheRequestHandler::HandleRequest(unsigned char* data, int size,
+    const std::string& locale) {
   psd::CacheDBHandler db(GetUID(), GetPID());
   db.SetLocale(locale);
 

diff --git a/src/server/request_handler/create_cache_request_handler.hh b/src/server/request_handler/create_cache_request_handler.hh
index a2efca4..ad0ce17 100644 (file)
--- a/src/server/request_handler/create_cache_request_handler.hh
+++ b/src/server/request_handler/create_cache_request_handler.hh
@@ -20,7 +20,7 @@ namespace request_handler {
 class EXPORT_API CreateCacheRequestHandler : public AbstractRequestHandler {
  public:
   CreateCacheRequestHandler();
-  bool HandleRequest(const unsigned char* data, int size,
+  bool HandleRequest(unsigned char* data, int size,
       const std::string& locale) override;
   tizen_base::Parcel ExtractResult() override;
 

diff --git a/src/server/request_handler/create_db_request_handler.cc b/src/server/request_handler/create_db_request_handler.cc
index 1e11cdc..2c7da13 100644 (file)
--- a/src/server/request_handler/create_db_request_handler.cc
+++ b/src/server/request_handler/create_db_request_handler.cc
@@ -22,8 +22,8 @@ namespace psd = pkgmgr_server::database;
 namespace pkgmgr_server {
 namespace request_handler {
 
-bool CreateDBRequestHandler::HandleRequest(const unsigned char* data, int size,
-                                           const std::string& locale) {
+bool CreateDBRequestHandler::HandleRequest(unsigned char* data, int size,
+    const std::string& locale) {
   auto abstract_parcel =
       pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 

diff --git a/src/server/request_handler/create_db_request_handler.hh b/src/server/request_handler/create_db_request_handler.hh
index 45a40bb..3057f32 100644 (file)
--- a/src/server/request_handler/create_db_request_handler.hh
+++ b/src/server/request_handler/create_db_request_handler.hh
@@ -19,7 +19,7 @@ namespace request_handler {
 
 class EXPORT_API CreateDBRequestHandler : public AbstractRequestHandler {
  public:
-  bool HandleRequest(const unsigned char* data, int size,
+  bool HandleRequest(unsigned char* data, int size,
       const std::string& locale) override;
 };
 

diff --git a/src/server/request_handler/get_appinfo_request_handler.cc b/src/server/request_handler/get_appinfo_request_handler.cc
index d7a1db7..827c09c 100644 (file)
--- a/src/server/request_handler/get_appinfo_request_handler.cc
+++ b/src/server/request_handler/get_appinfo_request_handler.cc
@@ -18,7 +18,7 @@ namespace psd = pkgmgr_server::database;
 namespace pkgmgr_server {
 namespace request_handler {
 
-bool GetAppinfoRequestHandler::HandleRequest(const unsigned char* data,
+bool GetAppinfoRequestHandler::HandleRequest(unsigned char* data,
     int size, const std::string& locale) {
   auto abstract_parcel =
       pcp::ParcelableFactory::GetInst().CreateParcel(data, size);

diff --git a/src/server/request_handler/get_appinfo_request_handler.hh b/src/server/request_handler/get_appinfo_request_handler.hh
index db1d5cd..cd58141 100644 (file)
--- a/src/server/request_handler/get_appinfo_request_handler.hh
+++ b/src/server/request_handler/get_appinfo_request_handler.hh
@@ -19,7 +19,7 @@ namespace request_handler {
 
 class EXPORT_API GetAppinfoRequestHandler : public AbstractRequestHandler {
  public:
-  bool HandleRequest(const unsigned char* data, int size,
+  bool HandleRequest(unsigned char* data, int size,
       const std::string &locale) override;
 };
 

diff --git a/src/server/request_handler/get_cert_request_handler.cc b/src/server/request_handler/get_cert_request_handler.cc
index 3e19d4a..3574db9 100644 (file)
--- a/src/server/request_handler/get_cert_request_handler.cc
+++ b/src/server/request_handler/get_cert_request_handler.cc
@@ -18,8 +18,8 @@ namespace psd = pkgmgr_server::database;
 namespace pkgmgr_server {
 namespace request_handler {
 
-bool GetCertRequestHandler::HandleRequest(const unsigned char* data, int size,
-                                          const std::string& locale) {
+bool GetCertRequestHandler::HandleRequest(unsigned char* data, int size,
+    const std::string& locale) {
   auto abstract_parcel =
       pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 

diff --git a/src/server/request_handler/get_cert_request_handler.hh b/src/server/request_handler/get_cert_request_handler.hh
index aa85106..011dc42 100644 (file)
--- a/src/server/request_handler/get_cert_request_handler.hh
+++ b/src/server/request_handler/get_cert_request_handler.hh
@@ -19,7 +19,7 @@ namespace request_handler {
 
 class EXPORT_API GetCertRequestHandler : public AbstractRequestHandler {
  public:
-  bool HandleRequest(const unsigned char* data, int size,
+  bool HandleRequest(unsigned char* data, int size,
       const std::string& locale) override;
 };
 

diff --git a/src/server/request_handler/get_depinfo_request_handler.cc b/src/server/request_handler/get_depinfo_request_handler.cc
index 0c132e6..e2c6328 100644 (file)
--- a/src/server/request_handler/get_depinfo_request_handler.cc
+++ b/src/server/request_handler/get_depinfo_request_handler.cc
@@ -19,8 +19,8 @@ namespace psd = pkgmgr_server::database;
 namespace pkgmgr_server {
 namespace request_handler {
 
-bool GetDepinfoRequestHandler::HandleRequest(const unsigned char* data, int size,
-                                             const std::string& locale) {
+bool GetDepinfoRequestHandler::HandleRequest(unsigned char* data, int size,
+    const std::string& locale) {
   auto abstract_parcel =
       pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 

diff --git a/src/server/request_handler/get_depinfo_request_handler.hh b/src/server/request_handler/get_depinfo_request_handler.hh
index 011497e..bae7179 100644 (file)
--- a/src/server/request_handler/get_depinfo_request_handler.hh
+++ b/src/server/request_handler/get_depinfo_request_handler.hh
@@ -19,7 +19,7 @@ namespace request_handler {
 
 class EXPORT_API GetDepinfoRequestHandler : public AbstractRequestHandler {
  public:
-  bool HandleRequest(const unsigned char* data, int size,
+  bool HandleRequest(unsigned char* data, int size,
       const std::string& locale) override;
 
 };

diff --git a/src/server/request_handler/get_pkginfo_request_handler.cc b/src/server/request_handler/get_pkginfo_request_handler.cc
index 698f38c..11884fe 100644 (file)
--- a/src/server/request_handler/get_pkginfo_request_handler.cc
+++ b/src/server/request_handler/get_pkginfo_request_handler.cc
@@ -19,7 +19,7 @@ namespace psd = pkgmgr_server::database;
 namespace pkgmgr_server {
 namespace request_handler {
 
-bool GetPkginfoRequestHandler::HandleRequest(const unsigned char* data,
+bool GetPkginfoRequestHandler::HandleRequest(unsigned char* data,
     int size, const std::string& locale) {
   auto abstract_parcel =
       pcp::ParcelableFactory::GetInst().CreateParcel(data, size);

diff --git a/src/server/request_handler/get_pkginfo_request_handler.hh b/src/server/request_handler/get_pkginfo_request_handler.hh
index 462f24a..f163a89 100644 (file)
--- a/src/server/request_handler/get_pkginfo_request_handler.hh
+++ b/src/server/request_handler/get_pkginfo_request_handler.hh
@@ -19,7 +19,7 @@ namespace request_handler {
 
 class EXPORT_API GetPkginfoRequestHandler : public AbstractRequestHandler {
  public:
-  bool HandleRequest(const unsigned char* data, int size,
+  bool HandleRequest(unsigned char* data, int size,
       const std::string& locale) override;
 };
 

diff --git a/src/server/request_handler/query_request_handler.cc b/src/server/request_handler/query_request_handler.cc
index 9ecdb51..2ccdffa 100644 (file)
--- a/src/server/request_handler/query_request_handler.cc
+++ b/src/server/request_handler/query_request_handler.cc
@@ -19,7 +19,7 @@ namespace psd = pkgmgr_server::database;
 namespace pkgmgr_server {
 namespace request_handler {
 
-bool QueryRequestHandler::HandleRequest(const unsigned char* data, int size,
+bool QueryRequestHandler::HandleRequest(unsigned char* data, int size,
                                         const std::string& locale) {
   auto abstract_parcel =
       pcp::ParcelableFactory::GetInst().CreateParcel(data, size);

diff --git a/src/server/request_handler/query_request_handler.hh b/src/server/request_handler/query_request_handler.hh
index 4dbb1b7..e96e235 100644 (file)
--- a/src/server/request_handler/query_request_handler.hh
+++ b/src/server/request_handler/query_request_handler.hh
@@ -20,7 +20,7 @@ namespace request_handler {
 
 class EXPORT_API QueryRequestHandler : public AbstractRequestHandler {
  public:
-  bool HandleRequest(const unsigned char* data, int size,
+  bool HandleRequest(unsigned char* data, int size,
       const std::string& locale) override;
 
 };

diff --git a/src/server/request_handler/request_handler_direct_access.cc b/src/server/request_handler/request_handler_direct_access.cc
index 31d55d4..afaa3a8 100644 (file)
--- a/src/server/request_handler/request_handler_direct_access.cc
+++ b/src/server/request_handler/request_handler_direct_access.cc
@@ -36,7 +36,7 @@
 #define EXPORT_API __attribute__((visibility("default")))
 
 extern "C" EXPORT_API void* _request_handler_direct_access(int req_type,
-    const unsigned char* data, int size, const char *locale) {
+    unsigned char* data, int size, const char *locale) {
   if (data == nullptr || size < 0 || locale == nullptr) {
     LOG(ERROR) << "Invalid parameter";
     return nullptr;
@@ -87,6 +87,7 @@ extern "C" EXPORT_API void* _request_handler_direct_access(int req_type,
 
   if (handler == nullptr) {
     LOG(ERROR) << "Can't reset handler with type : " << req_type;
+    free(data);
     return nullptr;
   }
 
@@ -95,13 +96,12 @@ extern "C" EXPORT_API void* _request_handler_direct_access(int req_type,
     return nullptr;
   }
   tizen_base::Parcel parcel = handler->ExtractResult();
-  const std::vector<uint8_t>& raw = parcel.GetRaw();
-  if (raw.size() == 0) {
+  if (parcel.GetDataSize() == 0) {
     LOG(ERROR) << "Fail to extract result";
     return nullptr;
   }
 
   return pkgmgr_common::parcel::ParcelableFactory::GetInst()
-      .CreateParcel(&raw[0], raw.size())
+      .CreateParcel(parcel.GetData(), parcel.GetDataSize(), true)
       .release();
 }

diff --git a/src/server/request_handler/request_handler_direct_access.h b/src/server/request_handler/request_handler_direct_access.h
index 3c82542..e7c2c0e 100644 (file)
--- a/src/server/request_handler/request_handler_direct_access.h
+++ b/src/server/request_handler/request_handler_direct_access.h
@@ -21,7 +21,7 @@
 extern "C" {
 #endif
 
-void *_request_handler_direct_access(int req_type, const unsigned char* data,
+void *_request_handler_direct_access(int req_type, unsigned char* data,
                int size, const char *locale);
 
 #ifdef __cplusplus

diff --git a/src/server/request_handler/set_cert_request_handler.cc b/src/server/request_handler/set_cert_request_handler.cc
index 25828d9..2852cca 100644 (file)
--- a/src/server/request_handler/set_cert_request_handler.cc
+++ b/src/server/request_handler/set_cert_request_handler.cc
@@ -19,8 +19,8 @@ namespace psd = pkgmgr_server::database;
 namespace pkgmgr_server {
 namespace request_handler {
 
-bool SetCertRequestHandler::HandleRequest(const unsigned char* data, int size,
-                                          const std::string& locale) {
+bool SetCertRequestHandler::HandleRequest(unsigned char* data, int size,
+    const std::string& locale) {
   auto abstract_parcel =
       pcp::ParcelableFactory::GetInst().CreateParcel(data, size);
 

diff --git a/src/server/request_handler/set_cert_request_handler.hh b/src/server/request_handler/set_cert_request_handler.hh
index 2663b7a..6e6a4ba 100644 (file)
--- a/src/server/request_handler/set_cert_request_handler.hh
+++ b/src/server/request_handler/set_cert_request_handler.hh
@@ -21,7 +21,7 @@ class EXPORT_API SetCertRequestHandler : public AbstractRequestHandler {
  public:
   SetCertRequestHandler(bool is_offline = false) :
       AbstractRequestHandler(), is_offline_(is_offline) {}
-  bool HandleRequest(const unsigned char* data, int size,
+  bool HandleRequest(unsigned char* data, int size,
       const std::string& locale) override;
 
  private:

diff --git a/src/server/request_handler/set_pkginfo_request_handler.cc b/src/server/request_handler/set_pkginfo_request_handler.cc
index a63d76d..24093ba 100644 (file)
--- a/src/server/request_handler/set_pkginfo_request_handler.cc
+++ b/src/server/request_handler/set_pkginfo_request_handler.cc
@@ -21,7 +21,7 @@ namespace psd = pkgmgr_server::database;
 namespace pkgmgr_server {
 namespace request_handler {
 
-bool SetPkginfoRequestHandler::HandleRequest(const unsigned char* data,
+bool SetPkginfoRequestHandler::HandleRequest(unsigned char* data,
     int size, const std::string& locale) {
   auto abstract_parcel =
       pcp::ParcelableFactory::GetInst().CreateParcel(data, size);

diff --git a/src/server/request_handler/set_pkginfo_request_handler.hh b/src/server/request_handler/set_pkginfo_request_handler.hh
index 2a5cf55..0c4821c 100644 (file)
--- a/src/server/request_handler/set_pkginfo_request_handler.hh
+++ b/src/server/request_handler/set_pkginfo_request_handler.hh
@@ -21,7 +21,7 @@ class EXPORT_API SetPkginfoRequestHandler : public AbstractRequestHandler {
  public:
   SetPkginfoRequestHandler(bool is_offline = false) :
       AbstractRequestHandler(), is_offline_(is_offline) {}
-  bool HandleRequest(const unsigned char* data, int size,
+  bool HandleRequest(unsigned char* data, int size,
       const std::string& locale) override;
 
  private:

diff --git a/src/server/worker_thread.cc b/src/server/worker_thread.cc
index 915b8c3..010111d 100644 (file)
--- a/src/server/worker_thread.cc
+++ b/src/server/worker_thread.cc
@@ -142,7 +142,7 @@ void WorkerThread::Run() {
       handler->PreExec();
       handler->SetUID(ConvertUID(req->GetSenderUID()));
       handler->SetPID(req->GetSenderPID());
-      if (!handler->HandleRequest(req->GetData(), req->GetSize(),
+      if (!handler->HandleRequest(req->DetachData(), req->GetSize(),
           locale_.GetObject()))
         LOG(ERROR) << "Failed to handle request";
 
@@ -200,7 +200,7 @@ void WorkerThread::SendError(const std::shared_ptr<PkgRequest>& req) {
       0, pkgmgr_common::parcel::ParcelableType::Unknown, PMINFO_R_ERROR);
   tizen_base::Parcel p;
   p.WriteParcelable(parcelable);
-  req->SendData(std::move(p));
+  req->SendData(p);
 }
 
 }  // namespace pkgmgr_server

diff --git a/test/unit_tests/test_parcel.cc b/test/unit_tests/test_parcel.cc
index 62dbeab..093f72f 100644 (file)
--- a/test/unit_tests/test_parcel.cc
+++ b/test/unit_tests/test_parcel.cc
@@ -256,57 +256,57 @@ TEST_F(ParcelTest, ParcelableFactory) {
   pp::DepInfoParcelable depinfo_parcelable;
 
   parcel.WriteParcelable(appinfo_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
-                                                      parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+      parcel.GetDataSize(), true);
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::AppInfo);
   parcel.Clear();
 
   parcel.WriteParcelable(certinfo_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
-                                                      parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+      parcel.GetDataSize(), true);
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::CertInfo);
   parcel.Clear();
 
   parcel.WriteParcelable(filter_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
-                                                      parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+      parcel.GetDataSize(), true);
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Filter);
   parcel.Clear();
 
   parcel.WriteParcelable(pkginfo_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
-                                                      parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+      parcel.GetDataSize(), true);
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::PkgInfo);
   parcel.Clear();
 
   parcel.WriteParcelable(query_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
-                                                      parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+      parcel.GetDataSize(), true);
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Query);
   parcel.Clear();
 
   parcel.WriteParcelable(result_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
-                                                      parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+      parcel.GetDataSize(), true);
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Result);
   parcel.Clear();
 
   parcel.WriteParcelable(command_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
-                                                      parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+      parcel.GetDataSize(), true);
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::Command);
   parcel.Clear();
 
   parcel.WriteParcelable(depinfo_parcelable);
-  ptr = pp::ParcelableFactory::GetInst().CreateParcel(&parcel.GetRaw()[0],
-                                                      parcel.GetRaw().size());
+  ptr = pp::ParcelableFactory::GetInst().CreateParcel(parcel.GetData(),
+      parcel.GetDataSize(), true);
   EXPECT_NE(ptr, nullptr);
   EXPECT_EQ(ptr->GetType(), pp::ParcelableType::DepInfo);
   parcel.Clear();