From: Junghyun Yeon <jungh.yeon@samsung.com>
Date: Fri, 2 Jul 2021 09:30:02 +0000 (+0900)
Subject: Cleanup code
X-Git-Tag: submit/tizen/20210706.065823~5
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=362b4cb1230b28639add7ec23bfbbd6656c80c7a;p=platform%2Fcore%2Fappfw%2Fpkgmgr-info.git

Cleanup code

- Change codes for coding rule.
- Add some empty lines for readability.
- Remove unnecessary function variable declaration.
- Remove certinfo remove function which is no longer used.

Change-Id: If7d8206982d4989f34ab024caa6e52ea5a42b9da
Signed-off-by: Junghyun Yeon <jungh.yeon@samsung.com>
---

diff --git a/src/client/pkginfo_client.cc b/src/client/pkginfo_client.cc
index fcf5afb4..2322a506 100644
--- a/src/client/pkginfo_client.cc
+++ b/src/client/pkginfo_client.cc
@@ -144,7 +144,7 @@ bool PkgInfoClient::RequestHandlerDirectAccess() {
   result_parcel_.reset(
       reinterpret_cast<pkgmgr_common::parcel::AbstractParcelable *>(
           dl_func(req_type_, &raw[0], raw.size(),
-          pkgmgr_common::SystemLocale::GetInst().Get().c_str())));
+              pkgmgr_common::SystemLocale::GetInst().Get().c_str())));
 
   return true;
 }
diff --git a/src/common/parcel/abstract_parcelable.cc b/src/common/parcel/abstract_parcelable.cc
index 6b648a4f..738b5a64 100644
--- a/src/common/parcel/abstract_parcelable.cc
+++ b/src/common/parcel/abstract_parcelable.cc
@@ -23,11 +23,11 @@ namespace parcel {
 
 AbstractParcelable::~AbstractParcelable() {}
 
-bool AbstractParcelable::ReadInt(tizen_base::Parcel* parcel, int *val) {
+bool AbstractParcelable::ReadInt(tizen_base::Parcel* parcel, int* val) {
   return parcel->ReadInt32(val);
 }
 
-bool AbstractParcelable::ReadString(tizen_base::Parcel* parcel, char **val) {
+bool AbstractParcelable::ReadString(tizen_base::Parcel* parcel, char** val) {
   bool is_null;
   if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE)
     return false;
@@ -43,6 +43,7 @@ bool AbstractParcelable::ReadString(tizen_base::Parcel* parcel, char **val) {
 std::optional<std::string> AbstractParcelable::ReadString(
     tizen_base::Parcel* parcel) {
   bool is_null;
+
   if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE)
     return std::nullopt;
 
@@ -62,6 +63,7 @@ void AbstractParcelable::WriteString(tizen_base::Parcel* parcel,
     parcel->WriteBool(true);
     return;
   }
+
   parcel->WriteBool(false);
   parcel->WriteCString(str);
 }
@@ -72,6 +74,7 @@ void AbstractParcelable::WriteString(tizen_base::Parcel* parcel,
     parcel->WriteBool(true);
     return;
   }
+
   parcel->WriteBool(false);
   parcel->WriteString(*str);
 }
@@ -93,13 +96,21 @@ void AbstractParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
   ret_ = ret;
 }
 
-uid_t AbstractParcelable::GetUid() { return uid_; }
+uid_t AbstractParcelable::GetUid() {
+  return uid_;
+}
 
-void AbstractParcelable::SetUid(uid_t uid) { uid_ = uid; }
+void AbstractParcelable::SetUid(uid_t uid) {
+  uid_ = uid;
+}
 
-ParcelableType AbstractParcelable::GetType() { return type_; }
+ParcelableType AbstractParcelable::GetType() {
+  return type_;
+}
 
-int AbstractParcelable::GetRequestResult() { return ret_; }
+int AbstractParcelable::GetRequestResult() {
+  return ret_;
+}
 
 }  // namespace parcel
 }  // namespace pkgmgr_common
diff --git a/src/common/parcel/abstract_parcelable.hh b/src/common/parcel/abstract_parcelable.hh
index 0f052429..89594e66 100644
--- a/src/common/parcel/abstract_parcelable.hh
+++ b/src/common/parcel/abstract_parcelable.hh
@@ -32,7 +32,8 @@ enum ParcelableType {
 class EXPORT_API AbstractParcelable : public tizen_base::Parcelable {
  public:
   AbstractParcelable() : uid_(0), type_(ParcelableType::Unknown), ret_(0) {}
-  AbstractParcelable(uid_t uid, ParcelableType type, int ret = 0) : uid_(uid), type_(type), ret_(ret) {}
+  AbstractParcelable(uid_t uid, ParcelableType type, int ret = 0)
+      : uid_(uid), type_(type), ret_(ret) {}
 
   virtual ~AbstractParcelable();
   uid_t GetUid();
@@ -44,9 +45,9 @@ class EXPORT_API AbstractParcelable : public tizen_base::Parcelable {
   void ReadFromParcel(tizen_base::Parcel* parcel) override;
 
  protected:
-  bool ReadString(tizen_base::Parcel* parcel, char **val);
+  bool ReadString(tizen_base::Parcel* parcel, char** val);
   std::optional<std::string> ReadString(tizen_base::Parcel* parcel);
-  bool ReadInt(tizen_base::Parcel* parcel, int *val);
+  bool ReadInt(tizen_base::Parcel* parcel, int* val);
   void WriteString(tizen_base::Parcel* parcel, const char* str) const;
   void WriteString(tizen_base::Parcel* parcel,
       const std::optional<std::string>& str) const;
diff --git a/src/common/parcel/appinfo_parcelable.cc b/src/common/parcel/appinfo_parcelable.cc
index 62317352..740de2a9 100644
--- a/src/common/parcel/appinfo_parcelable.cc
+++ b/src/common/parcel/appinfo_parcelable.cc
@@ -25,8 +25,7 @@ namespace parcel {
 
 void AppInfoParcelable::WriteLabel(tizen_base::Parcel* parcel,
     GList* label) const {
-  int size = g_list_length(label);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(label));
 
   for (GList* tmp = label; tmp; tmp = tmp->next) {
     label_x* ptr = reinterpret_cast<label_x*>(tmp->data);
@@ -38,8 +37,7 @@ void AppInfoParcelable::WriteLabel(tizen_base::Parcel* parcel,
 
 void AppInfoParcelable::WriteIcon(tizen_base::Parcel* parcel,
     GList* icon) const {
-  int size = g_list_length(icon);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(icon));
 
   for (GList* tmp = icon; tmp; tmp = tmp->next) {
     icon_x* ptr = reinterpret_cast<icon_x*>(tmp->data);
@@ -53,8 +51,7 @@ void AppInfoParcelable::WriteIcon(tizen_base::Parcel* parcel,
 }
 void AppInfoParcelable::WriteImage(tizen_base::Parcel* parcel,
     GList* image) const {
-  int size = g_list_length(image);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(image));
 
   for (GList* tmp = image; tmp; tmp = tmp->next) {
     image_x* ptr = reinterpret_cast<image_x*>(tmp->data);
@@ -65,16 +62,14 @@ void AppInfoParcelable::WriteImage(tizen_base::Parcel* parcel,
 }
 void AppInfoParcelable::WriteCategory(tizen_base::Parcel* parcel,
     GList* category) const {
-  int size = g_list_length(category);
-  WriteInt(parcel, size);
-  for (GList* tmp = category; tmp; tmp = tmp->next) {
-    WriteString(parcel, reinterpret_cast<char *>(tmp->data));
-  }
+  WriteInt(parcel, g_list_length(category));
+
+  for (GList* tmp = category; tmp; tmp = tmp->next)
+    WriteString(parcel, reinterpret_cast<char*>(tmp->data));
 }
 void AppInfoParcelable::WriteMetadata(tizen_base::Parcel* parcel,
     GList* metadata) const {
-  int size = g_list_length(metadata);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(metadata));
 
   for (GList* tmp = metadata; tmp; tmp = tmp->next) {
     metadata_x* ptr = reinterpret_cast<metadata_x*>(tmp->data);
@@ -97,8 +92,7 @@ void AppInfoParcelable::WriteDatashare(tizen_base::Parcel* parcel,
 
 void AppInfoParcelable::WriteDatacontrol(tizen_base::Parcel* parcel,
     GList* datacontrol) const {
-  int size = g_list_length(datacontrol);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(datacontrol));
 
   for (GList* tmp = datacontrol; tmp; tmp = tmp->next) {
     datacontrol_x* ptr = reinterpret_cast<datacontrol_x*>(tmp->data);
@@ -108,22 +102,21 @@ void AppInfoParcelable::WriteDatacontrol(tizen_base::Parcel* parcel,
     WriteString(parcel, ptr->trusted);
     WriteInt(parcel, g_list_length(ptr->privileges));
     for (GList* tmp = ptr->privileges; tmp; tmp = tmp->next)
-      WriteString(parcel, reinterpret_cast<char *>(tmp->data));
+      WriteString(parcel, reinterpret_cast<char*>(tmp->data));
   }
 }
 
 void AppInfoParcelable::WriteBackgroundCategory(tizen_base::Parcel* parcel,
     GList* backgroundcategory) const {
-  int size = g_list_length(backgroundcategory);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(backgroundcategory));
+
   for (GList* tmp = backgroundcategory; tmp; tmp = tmp->next)
-    WriteString(parcel, reinterpret_cast<char *>(tmp->data));
+    WriteString(parcel, reinterpret_cast<char*>(tmp->data));
 }
 
 void AppInfoParcelable::WriteAppcontrol(tizen_base::Parcel* parcel,
     GList* appcontrol) const {
-  int size = g_list_length(appcontrol);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(appcontrol));
 
   for (GList* tmp = appcontrol; tmp; tmp = tmp->next) {
     appcontrol_x* ptr = reinterpret_cast<appcontrol_x*>(tmp->data);
@@ -134,14 +127,13 @@ void AppInfoParcelable::WriteAppcontrol(tizen_base::Parcel* parcel,
     WriteString(parcel, ptr->id);
     WriteInt(parcel, g_list_length(ptr->privileges));
     for (GList* tmp = ptr->privileges; tmp; tmp = tmp->next)
-      WriteString(parcel, reinterpret_cast<char *>(tmp->data));
+      WriteString(parcel, reinterpret_cast<char*>(tmp->data));
   }
 }
 
 void AppInfoParcelable::WriteSplashscreens(tizen_base::Parcel* parcel,
     GList* splashscreens) const {
-  int size = g_list_length(splashscreens);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(splashscreens));
 
   for (GList* tmp = splashscreens; tmp; tmp = tmp->next) {
     splashscreen_x* ptr = reinterpret_cast<splashscreen_x*>(tmp->data);
@@ -157,8 +149,7 @@ void AppInfoParcelable::WriteSplashscreens(tizen_base::Parcel* parcel,
 
 void AppInfoParcelable::WriteResControl(tizen_base::Parcel* parcel,
     GList* res_control) const {
-  int size = g_list_length(res_control);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(res_control));
 
   for (GList* tmp = res_control; tmp; tmp = tmp->next) {
     res_control_x* ptr = reinterpret_cast<res_control_x*>(tmp->data);
@@ -220,7 +211,7 @@ void AppInfoParcelable::ReadCategory(tizen_base::Parcel* parcel,
   ReadInt(parcel, &size);
 
   for (int i = 0; i < size; ++i) {
-    char *category = nullptr;
+    char* category = nullptr;
     ReadString(parcel, &category);
     *list = g_list_append(*list, category);
   }
@@ -268,7 +259,7 @@ void AppInfoParcelable::ReadDatacontrol(
     int privilege_size = 0;
     ReadInt(parcel, &privilege_size);
     for (int i = 0; i < privilege_size; ++i) {
-      char *privilege = nullptr;
+      char* privilege = nullptr;
       ReadString(parcel, &privilege);
       datacontrol->privileges =
           g_list_append(datacontrol->privileges, privilege);
@@ -283,7 +274,7 @@ void AppInfoParcelable::ReadBackgroundCategory(
   ReadInt(parcel, &size);
 
   for (int i = 0; i < size; ++i) {
-    char *category = nullptr;
+    char* category = nullptr;
     ReadString(parcel, &category);
     *list = g_list_append(*list, category);
   }
@@ -304,7 +295,7 @@ void AppInfoParcelable::ReadAppcontrol(
     int privilege_len = 0;
     ReadInt(parcel, &privilege_len);
     for (int i = 0; i < privilege_len; ++i) {
-      char *privilege = nullptr;
+      char* privilege = nullptr;
       ReadString(parcel, &privilege);
       appcontrol->privileges =
           g_list_append(appcontrol->privileges, privilege);
@@ -355,7 +346,7 @@ AppInfoParcelable::AppInfoParcelable()
     : AbstractParcelable(0, ParcelableType::AppInfo), auto_release_(true) {}
 
 AppInfoParcelable::AppInfoParcelable(int ret,
-    std::vector<application_x *>&& app_list, bool auto_release)
+    std::vector<application_x*>&& app_list, bool auto_release)
     : AbstractParcelable(0, ParcelableType::AppInfo, ret),
     app_list_(std::move(app_list)), auto_release_(auto_release) {}
 
@@ -363,20 +354,19 @@ AppInfoParcelable::~AppInfoParcelable() {
   if (!auto_release_)
     return;
 
-  for (auto app : app_list_) {
+  for (auto app : app_list_)
     pkgmgrinfo_basic_free_application(app);
-  }
 }
 
-const std::vector<application_x *>& AppInfoParcelable::GetAppInfo() {
+const std::vector<application_x*>& AppInfoParcelable::GetAppInfo() {
   return app_list_;
 }
 
-std::vector<application_x *> AppInfoParcelable::ExtractAppInfo() {
+std::vector<application_x*> AppInfoParcelable::ExtractAppInfo() {
   return std::move(app_list_);
 }
 
-application_x *AppInfoParcelable::ReadApplication(tizen_base::Parcel* parcel) {
+application_x* AppInfoParcelable::ReadApplication(tizen_base::Parcel* parcel) {
   application_x* application =
       reinterpret_cast<application_x*>(calloc(1, sizeof(application_x)));
 
@@ -445,7 +435,7 @@ application_x *AppInfoParcelable::ReadApplication(tizen_base::Parcel* parcel) {
 }
 
 bool AppInfoParcelable::WriteApplication(tizen_base::Parcel* parcel,
-    application_x *application) const {
+    application_x* application) const {
   WriteString(parcel, application->appid);
   WriteString(parcel, application->exec);
   WriteString(parcel, application->nodisplay);
diff --git a/src/common/parcel/appinfo_parcelable.hh b/src/common/parcel/appinfo_parcelable.hh
index e3489792..875e1aab 100644
--- a/src/common/parcel/appinfo_parcelable.hh
+++ b/src/common/parcel/appinfo_parcelable.hh
@@ -17,10 +17,11 @@ namespace parcel {
 class EXPORT_API AppInfoParcelable : public AbstractParcelable {
  public:
   AppInfoParcelable();
-  AppInfoParcelable(int ret, std::vector<application_x *>&& app_list, bool auto_release = true);
+  AppInfoParcelable(int ret, std::vector<application_x*>&& app_list,
+      bool auto_release = true);
   ~AppInfoParcelable();
-  const std::vector<application_x *>& GetAppInfo();
-  std::vector<application_x *> ExtractAppInfo();
+  const std::vector<application_x*>& GetAppInfo();
+  std::vector<application_x*> ExtractAppInfo();
 
   void WriteToParcel(tizen_base::Parcel* parcel) const override;
   void ReadFromParcel(tizen_base::Parcel* parcel) override;
@@ -32,15 +33,20 @@ class EXPORT_API AppInfoParcelable : public AbstractParcelable {
   void WriteCategory(tizen_base::Parcel* parcel, GList* category) const;
   void WriteMetadata(tizen_base::Parcel* parcel, GList* metadata) const;
   void WritePermission(tizen_base::Parcel* parcel, GList* permission) const;
-  void WriteLaunchConditions(tizen_base::Parcel* parcel, GList* launchconditions) const;
-  void WriteNotification(tizen_base::Parcel* parcel, GList* notification) const;
+  void WriteLaunchConditions(tizen_base::Parcel* parcel,
+      GList* launchconditions) const;
+  void WriteNotification(tizen_base::Parcel* parcel,
+      GList* notification) const;
   void WriteDatashare(tizen_base::Parcel* parcel, GList* datashare) const;
   void WriteDatacontrol(tizen_base::Parcel* parcel, GList* datacontrol) const;
-  void WriteBackgroundCategory(tizen_base::Parcel* parcel, GList* backgroundcategory) const;
+  void WriteBackgroundCategory(tizen_base::Parcel* parcel,
+      GList* backgroundcategory) const;
   void WriteAppcontrol(tizen_base::Parcel* parcel, GList* appcontrol) const;
-  void WriteSplashscreens(tizen_base::Parcel* parcel, GList* splashscreens) const;
+  void WriteSplashscreens(tizen_base::Parcel* parcel,
+      GList* splashscreens) const;
   void WriteResControl(tizen_base::Parcel* parcel, GList* splashscreens) const;
-  bool WriteApplication(tizen_base::Parcel* parcel, application_x *application) const;
+  bool WriteApplication(tizen_base::Parcel* parcel,
+      application_x* application) const;
   void ReadLabel(tizen_base::Parcel* parcel, GList** list);
   void ReadIcon(tizen_base::Parcel* parcel, GList** list);
   void ReadImage(tizen_base::Parcel* parcel, GList** list);
@@ -55,9 +61,9 @@ class EXPORT_API AppInfoParcelable : public AbstractParcelable {
   void ReadAppcontrol(tizen_base::Parcel* parcel, GList** list);
   void ReadSplashscreens(tizen_base::Parcel* parcel, GList** list);
   void ReadResControl(tizen_base::Parcel* parcel, GList** list);
-  application_x *ReadApplication(tizen_base::Parcel* parcel);
+  application_x* ReadApplication(tizen_base::Parcel* parcel);
 
-  std::vector<application_x *> app_list_;
+  std::vector<application_x*> app_list_;
   bool auto_release_;
 };
 
diff --git a/src/common/parcel/certinfo_parcelable.cc b/src/common/parcel/certinfo_parcelable.cc
index 1269c0eb..64444d03 100644
--- a/src/common/parcel/certinfo_parcelable.cc
+++ b/src/common/parcel/certinfo_parcelable.cc
@@ -71,12 +71,14 @@ const pkgmgr_certinfo_x* CertInfoParcelable::GetCertInfo() {
 
 pkgmgr_certinfo_x* CertInfoParcelable::ExtractCertInfo() {
   pkgmgr_certinfo_x* cert = cert_info_;
-  cert_info_ = nullptr;
 
+  cert_info_ = nullptr;
   return cert;
 }
 
-const std::string& CertInfoParcelable::GetPkgId() { return pkgid_; }
+const std::string& CertInfoParcelable::GetPkgId() {
+  return pkgid_;
+}
 
 void CertInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
   AbstractParcelable::WriteToParcel(parcel);
@@ -95,12 +97,14 @@ bool CertInfoParcelable::WriteCertInfo(tizen_base::Parcel* parcel) const {
     parcel->WriteBool(true);
     return true;
   }
+
   parcel->WriteBool(false);
   WriteInt(parcel, cert_info_->for_all_users);
   WriteString(parcel, cert_info_->pkgid);
   WriteString(parcel, cert_info_->cert_value);
   for (int i = 0; i < MAX_CERT_TYPE; ++i)
     WriteString(parcel, cert_info_->cert_info[i]);
+
   for (int i = 0; i < MAX_CERT_TYPE; ++i)
     WriteInt(parcel, cert_info_->cert_id[i]);
 
@@ -109,17 +113,20 @@ bool CertInfoParcelable::WriteCertInfo(tizen_base::Parcel* parcel) const {
 
 void CertInfoParcelable::ReadCertInfo(tizen_base::Parcel* parcel) {
   bool is_null = false;
-  if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE) return;
 
-  if (is_null) return;
+  if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE || is_null)
+    return;
 
   cert_info_ = reinterpret_cast<pkgmgr_certinfo_x*>(
       calloc(1, sizeof(pkgmgr_certinfo_x)));
+
   ReadInt(parcel, &cert_info_->for_all_users);
   ReadString(parcel, &cert_info_->pkgid);
   ReadString(parcel, &cert_info_->cert_value);
+
   for (int i = 0; i < MAX_CERT_TYPE; ++i)
     ReadString(parcel, &cert_info_->cert_info[i]);
+
   for (int i = 0; i < MAX_CERT_TYPE; ++i)
     ReadInt(parcel, &cert_info_->cert_id[i]);
 }
diff --git a/src/common/parcel/certinfo_parcelable.hh b/src/common/parcel/certinfo_parcelable.hh
index b0dc5670..cc6f7b4a 100644
--- a/src/common/parcel/certinfo_parcelable.hh
+++ b/src/common/parcel/certinfo_parcelable.hh
@@ -19,13 +19,16 @@ class EXPORT_API CertInfoParcelable : public AbstractParcelable {
  public:
   CertInfoParcelable();
   CertInfoParcelable(uid_t uid, std::string pkgid);
-  CertInfoParcelable(uid_t uid, pkgmgr_certinfo_x *cert_info, bool auto_release = true);
-  CertInfoParcelable(int ret, pkgmgr_certinfo_x *cert_info, bool auto_release = true);
+  CertInfoParcelable(uid_t uid, pkgmgr_certinfo_x* cert_info,
+      bool auto_release = true);
+  CertInfoParcelable(int ret, pkgmgr_certinfo_x* cert_info,
+      bool auto_release = true);
   CertInfoParcelable(uid_t uid,
-      pkgmgr_certinfo_x *cert_info, std::string pkgid, bool auto_release = true);
+      pkgmgr_certinfo_x* cert_info, std::string pkgid,
+      bool auto_release = true);
   ~CertInfoParcelable();
-  const pkgmgr_certinfo_x *GetCertInfo();
-  pkgmgr_certinfo_x *ExtractCertInfo();
+  const pkgmgr_certinfo_x* GetCertInfo();
+  pkgmgr_certinfo_x* ExtractCertInfo();
   const std::string& GetPkgId();
 
   void WriteToParcel(tizen_base::Parcel* parcel) const override;
@@ -37,7 +40,7 @@ class EXPORT_API CertInfoParcelable : public AbstractParcelable {
   void ReadCertInfo(tizen_base::Parcel* parcel);
   void ReadPkgId(tizen_base::Parcel* parcel);
 
-  pkgmgr_certinfo_x *cert_info_;
+  pkgmgr_certinfo_x* cert_info_;
   std::string pkgid_;
   bool auto_release_;
 };
diff --git a/src/common/parcel/depinfo_parcelable.cc b/src/common/parcel/depinfo_parcelable.cc
index 491b33fe..a98ceddc 100644
--- a/src/common/parcel/depinfo_parcelable.cc
+++ b/src/common/parcel/depinfo_parcelable.cc
@@ -69,6 +69,7 @@ void DepInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
 
 void DepInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
   int len = 0;
+
   AbstractParcelable::ReadFromParcel(parcel);
   pkgid_ = parcel->ReadString();
   ReadInt(parcel, &len);
@@ -78,14 +79,14 @@ void DepInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
 }
 
 void DepInfoParcelable::WriteDependency(tizen_base::Parcel* parcel,
-    dependency_x *dependency) const {
+    dependency_x* dependency) const {
   WriteString(parcel, dependency->pkgid);
   WriteString(parcel, dependency->depends_on);
   WriteString(parcel, dependency->type);
   WriteString(parcel, dependency->required_version);
 }
 
-dependency_x *DepInfoParcelable::ReadDependency(tizen_base::Parcel* parcel) {
+dependency_x* DepInfoParcelable::ReadDependency(tizen_base::Parcel* parcel) {
   dependency_x* dep =
       reinterpret_cast<dependency_x*>(calloc(1, sizeof(dependency_x)));
   ReadString(parcel, &dep->pkgid);
diff --git a/src/common/parcel/depinfo_parcelable.hh b/src/common/parcel/depinfo_parcelable.hh
index 149fc455..d8f0b95c 100644
--- a/src/common/parcel/depinfo_parcelable.hh
+++ b/src/common/parcel/depinfo_parcelable.hh
@@ -17,11 +17,12 @@ namespace parcel {
 class EXPORT_API DepInfoParcelable : public AbstractParcelable {
  public:
   DepInfoParcelable();
-  DepInfoParcelable(int ret, std::vector<dependency_x *>&& dependency_list, bool auto_release = true);
+  DepInfoParcelable(int ret, std::vector<dependency_x*>&& dependency_list,
+      bool auto_release = true);
   DepInfoParcelable(const std::string& pkgid);
   ~DepInfoParcelable();
-  const std::vector<dependency_x *>& GetDependencyInfo();
-  std::vector<dependency_x *> ExtractDependencyInfo();
+  const std::vector<dependency_x*>& GetDependencyInfo();
+  std::vector<dependency_x*> ExtractDependencyInfo();
   const std::string& GetPkgID();
 
   void WriteToParcel(tizen_base::Parcel* parcel) const override;
@@ -29,11 +30,11 @@ class EXPORT_API DepInfoParcelable : public AbstractParcelable {
 
  private:
   void WriteDependency(tizen_base::Parcel* parcel,
-      dependency_x *dependency) const;
-  dependency_x *ReadDependency(tizen_base::Parcel* parcel);
+      dependency_x* dependency) const;
+  dependency_x* ReadDependency(tizen_base::Parcel* parcel);
 
   std::string pkgid_;
-  std::vector<dependency_x *> dependency_list_;
+  std::vector<dependency_x*> dependency_list_;
   bool auto_release_;
 };
 
diff --git a/src/common/parcel/filter_parcelable.cc b/src/common/parcel/filter_parcelable.cc
index c73896f5..0d497215 100644
--- a/src/common/parcel/filter_parcelable.cc
+++ b/src/common/parcel/filter_parcelable.cc
@@ -30,7 +30,7 @@ FilterParcelable::FilterParcelable()
       filter_(nullptr),
       flag_(0), auto_release_(true) {}
 
-FilterParcelable::FilterParcelable(uid_t uid, pkgmgrinfo_filter_x *filter,
+FilterParcelable::FilterParcelable(uid_t uid, pkgmgrinfo_filter_x* filter,
                                    int flag, bool auto_release)
     : AbstractParcelable(uid, ParcelableType::Filter),
       filter_(filter),
@@ -44,24 +44,28 @@ FilterParcelable::~FilterParcelable() {
     pkgmgrinfo_pkginfo_filter_destroy(filter_);
 }
 
-const pkgmgrinfo_filter_x *FilterParcelable::GetFilter() { return filter_; }
+const pkgmgrinfo_filter_x* FilterParcelable::GetFilter() {
+  return filter_;
+}
 
-int FilterParcelable::GetFlag() { return flag_; }
+int FilterParcelable::GetFlag() {
+  return flag_;
+}
 
-void FilterParcelable::WriteToParcel(tizen_base::Parcel *parcel) const {
+void FilterParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
   AbstractParcelable::WriteToParcel(parcel);
   WriteInt(parcel, flag_);
   WriteFilter(parcel, filter_);
 }
 
-void FilterParcelable::ReadFromParcel(tizen_base::Parcel *parcel) {
+void FilterParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
   AbstractParcelable::ReadFromParcel(parcel);
   ReadInt(parcel, &flag_);
   ReadFilter(parcel);
 }
 
-bool FilterParcelable::WriteFilter(tizen_base::Parcel *parcel,
-                                   pkgmgrinfo_filter_x *filter) const {
+bool FilterParcelable::WriteFilter(tizen_base::Parcel* parcel,
+                                   pkgmgrinfo_filter_x* filter) const {
   if (filter == nullptr) {
     parcel->WriteBool(true);
     return true;
@@ -70,27 +74,28 @@ bool FilterParcelable::WriteFilter(tizen_base::Parcel *parcel,
   WriteInt(parcel, filter->uid);
 
   WriteInt(parcel, g_slist_length(filter->list));
-  for (GSList *list = filter->list; list; list = list->next)
+  for (GSList* list = filter->list; list; list = list->next)
     WritePkgmgrInfoNode(parcel,
-                        reinterpret_cast<pkgmgrinfo_node_x *>(list->data));
+                        reinterpret_cast<pkgmgrinfo_node_x*>(list->data));
 
   WriteInt(parcel, g_slist_length(filter->list_metadata));
-  for (GSList *list = filter->list_metadata; list; list = list->next)
+  for (GSList* list = filter->list_metadata; list; list = list->next)
     WritePkgmgrInfoMetadataNode(
-        parcel, reinterpret_cast<pkgmgrinfo_metadata_node_x *>(list->data));
+        parcel, reinterpret_cast<pkgmgrinfo_metadata_node_x*>(list->data));
 
   return true;
 }
 
-void FilterParcelable::ReadFilter(tizen_base::Parcel *parcel) {
+void FilterParcelable::ReadFilter(tizen_base::Parcel* parcel) {
   bool is_null = false;
   int val = 0;
-  if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE) return;
 
-  if (is_null) return;
+  if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE || is_null)
+    return;
 
-  filter_ = reinterpret_cast<pkgmgrinfo_filter_x *>(
+  filter_ = reinterpret_cast<pkgmgrinfo_filter_x*>(
       calloc(1, sizeof(pkgmgrinfo_filter_x)));
+
   ReadInt(parcel, &val);
   filter_->uid = val;
 
@@ -104,8 +109,8 @@ void FilterParcelable::ReadFilter(tizen_base::Parcel *parcel) {
                                             ReadPkgmgrInfoMetadataNode(parcel));
 }
 
-bool FilterParcelable::WritePkgmgrInfoNode(tizen_base::Parcel *parcel,
-                                           pkgmgrinfo_node_x *node) const {
+bool FilterParcelable::WritePkgmgrInfoNode(tizen_base::Parcel* parcel,
+                                           pkgmgrinfo_node_x* node) const {
   WriteInt(parcel, node->prop);
   WriteString(parcel, node->key);
   WriteString(parcel, node->value);
@@ -113,9 +118,9 @@ bool FilterParcelable::WritePkgmgrInfoNode(tizen_base::Parcel *parcel,
   return true;
 }
 
-pkgmgrinfo_node_x *FilterParcelable::ReadPkgmgrInfoNode(
-    tizen_base::Parcel *parcel) {
-  pkgmgrinfo_node_x *node = reinterpret_cast<pkgmgrinfo_node_x *>(
+pkgmgrinfo_node_x* FilterParcelable::ReadPkgmgrInfoNode(
+    tizen_base::Parcel* parcel) {
+  pkgmgrinfo_node_x* node = reinterpret_cast<pkgmgrinfo_node_x*>(
       calloc(1, sizeof(pkgmgrinfo_node_x)));
   ReadInt(parcel, &node->prop);
   ReadString(parcel, &node->key);
@@ -125,17 +130,17 @@ pkgmgrinfo_node_x *FilterParcelable::ReadPkgmgrInfoNode(
 }
 
 bool FilterParcelable::WritePkgmgrInfoMetadataNode(
-    tizen_base::Parcel *parcel, pkgmgrinfo_metadata_node_x *node) const {
+    tizen_base::Parcel* parcel, pkgmgrinfo_metadata_node_x* node) const {
   WriteString(parcel, node->key);
   WriteString(parcel, node->value);
 
   return true;
 }
 
-pkgmgrinfo_metadata_node_x *FilterParcelable::ReadPkgmgrInfoMetadataNode(
-    tizen_base::Parcel *parcel) {
-  pkgmgrinfo_metadata_node_x *node =
-      reinterpret_cast<pkgmgrinfo_metadata_node_x *>(
+pkgmgrinfo_metadata_node_x* FilterParcelable::ReadPkgmgrInfoMetadataNode(
+    tizen_base::Parcel* parcel) {
+  pkgmgrinfo_metadata_node_x* node =
+      reinterpret_cast<pkgmgrinfo_metadata_node_x*>(
           calloc(1, sizeof(pkgmgrinfo_metadata_node_x)));
   ReadString(parcel, &node->key);
   ReadString(parcel, &node->value);
diff --git a/src/common/parcel/filter_parcelable.hh b/src/common/parcel/filter_parcelable.hh
index 9615fc72..71667884 100644
--- a/src/common/parcel/filter_parcelable.hh
+++ b/src/common/parcel/filter_parcelable.hh
@@ -17,7 +17,8 @@ namespace parcel {
 class EXPORT_API FilterParcelable : public AbstractParcelable {
  public:
   FilterParcelable();
-  FilterParcelable(uid_t uid, pkgmgrinfo_filter_x *filter, int flag, bool auto_release = true);
+  FilterParcelable(uid_t uid, pkgmgrinfo_filter_x* filter,
+      int flag, bool auto_release = true);
   ~FilterParcelable();
   const pkgmgrinfo_filter_x* GetFilter();
   int GetFlag();
@@ -26,14 +27,17 @@ class EXPORT_API FilterParcelable : public AbstractParcelable {
   void ReadFromParcel(tizen_base::Parcel* parcel) override;
 
  private:
-  bool WriteFilter(tizen_base::Parcel* parcel, pkgmgrinfo_filter_x *filter) const;
-  bool WritePkgmgrInfoNode(tizen_base::Parcel* parcel, pkgmgrinfo_node_x *node) const;
-  bool WritePkgmgrInfoMetadataNode(tizen_base::Parcel* parcel, pkgmgrinfo_metadata_node_x *node) const;
+  bool WriteFilter(tizen_base::Parcel* parcel,
+      pkgmgrinfo_filter_x* filter) const;
+  bool WritePkgmgrInfoNode(tizen_base::Parcel* parcel,
+      pkgmgrinfo_node_x* node) const;
+  bool WritePkgmgrInfoMetadataNode(tizen_base::Parcel* parcel,
+      pkgmgrinfo_metadata_node_x* node) const;
   void ReadFilter(tizen_base::Parcel* parcel);
-  pkgmgrinfo_node_x *ReadPkgmgrInfoNode(tizen_base::Parcel *parcel);
-  pkgmgrinfo_metadata_node_x *ReadPkgmgrInfoMetadataNode(tizen_base::Parcel* parcel);
+  pkgmgrinfo_node_x* ReadPkgmgrInfoNode(tizen_base::Parcel* parcel);
+  pkgmgrinfo_metadata_node_x* ReadPkgmgrInfoMetadataNode(tizen_base::Parcel* parcel);
 
-  pkgmgrinfo_filter_x *filter_;
+  pkgmgrinfo_filter_x* filter_;
   int flag_;
   bool auto_release_;
 };
diff --git a/src/common/parcel/parcelable_factory.cc b/src/common/parcel/parcelable_factory.cc
index 2ced47a6..669e8ddd 100644
--- a/src/common/parcel/parcelable_factory.cc
+++ b/src/common/parcel/parcelable_factory.cc
@@ -44,8 +44,8 @@ std::unique_ptr<AbstractParcelable> ParcelableFactory::CreateParcel(
     const unsigned char* data, int size) {
   int tmp;
   std::unique_ptr<AbstractParcelable> res = nullptr;
-  tizen_base::Parcel parcel(data, size);
 
+  tizen_base::Parcel parcel(data, size);
   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 129af7d9..23edf902 100644
--- a/src/common/parcel/parcelable_factory.hh
+++ b/src/common/parcel/parcelable_factory.hh
@@ -31,7 +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(
+      const unsigned char* data, int size);
 
  private:
   ParcelableFactory();
diff --git a/src/common/parcel/pkginfo_parcelable.cc b/src/common/parcel/pkginfo_parcelable.cc
index 65d5c10a..656995b8 100644
--- a/src/common/parcel/pkginfo_parcelable.cc
+++ b/src/common/parcel/pkginfo_parcelable.cc
@@ -27,8 +27,7 @@ namespace parcel {
 
 void PkgInfoParcelable::WriteIcon(tizen_base::Parcel* parcel,
     GList* icon) const {
-  int size = g_list_length(icon);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(icon));
 
   for (GList* tmp = icon; tmp; tmp = tmp->next) {
     icon_x* ptr = reinterpret_cast<icon_x*>(tmp->data);
@@ -43,8 +42,7 @@ void PkgInfoParcelable::WriteIcon(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel,
     GList* label) const {
-  int size = g_list_length(label);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(label));
 
   for (GList* tmp = label; tmp; tmp = tmp->next) {
     label_x* ptr = reinterpret_cast<label_x*>(tmp->data);
@@ -56,8 +54,7 @@ void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel,
     GList* author) const {
-  int size = g_list_length(author);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(author));
 
   for (GList* tmp = author; tmp; tmp = tmp->next) {
     author_x* ptr = reinterpret_cast<author_x*>(tmp->data);
@@ -70,8 +67,7 @@ void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteDescription(tizen_base::Parcel* parcel,
     GList* description) const {
-  int size = g_list_length(description);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(description));
 
   for (GList* tmp = description; tmp; tmp = tmp->next) {
     description_x* ptr = reinterpret_cast<description_x*>(tmp->data);
@@ -88,8 +84,7 @@ void PkgInfoParcelable::WriteLicense(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel,
     GList* privileges) const {
-  int size = g_list_length(privileges);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(privileges));
 
   for (GList* tmp = privileges; tmp; tmp = tmp->next) {
     privilege_x* ptr = reinterpret_cast<privilege_x*>(tmp->data);
@@ -100,8 +95,7 @@ void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteAppdefinedPrivileges(tizen_base::Parcel* parcel,
     GList* appdefined_privileges) const {
-  int size = g_list_length(appdefined_privileges);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(appdefined_privileges));
 
   for (GList* tmp = appdefined_privileges; tmp; tmp = tmp->next) {
     appdefined_privilege_x* ptr =
@@ -114,8 +108,7 @@ void PkgInfoParcelable::WriteAppdefinedPrivileges(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteProvidesAppdefinedPrivileges(
     tizen_base::Parcel* parcel, GList* provides_appdefined_privileges) const {
-  int size = g_list_length(provides_appdefined_privileges);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(provides_appdefined_privileges));
 
   for (GList* tmp = provides_appdefined_privileges; tmp; tmp = tmp->next) {
     appdefined_privilege_x* ptr =
@@ -128,7 +121,7 @@ void PkgInfoParcelable::WriteProvidesAppdefinedPrivileges(
 
 void PkgInfoParcelable::WriteApplication(tizen_base::Parcel* parcel,
     GList* application) const {
-  std::vector<application_x *> app_vt;
+  std::vector<application_x*> app_vt;
 
   for (GList* tmp = application; tmp; tmp = tmp->next) {
     application_x* ptr = reinterpret_cast<application_x*>(tmp->data);
@@ -147,17 +140,15 @@ void PkgInfoParcelable::WriteCompatibility(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteDeviceprofile(tizen_base::Parcel* parcel,
     GList* deviceprofile) const {
-  int size = g_list_length(deviceprofile);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(deviceprofile));
 
   for (GList* tmp = deviceprofile; tmp; tmp = tmp->next)
-    WriteString(parcel, reinterpret_cast<char *>(tmp->data));
+    WriteString(parcel, reinterpret_cast<char*>(tmp->data));
 }
 
 void PkgInfoParcelable::WriteDependencies(tizen_base::Parcel* parcel,
     GList* dependencies) const {
-  int size = g_list_length(dependencies);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(dependencies));
 
   for (GList* tmp = dependencies; tmp; tmp = tmp->next) {
     dependency_x* ptr = reinterpret_cast<dependency_x*>(tmp->data);
@@ -169,8 +160,7 @@ void PkgInfoParcelable::WriteDependencies(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WritePlugin(tizen_base::Parcel* parcel,
     GList* plugin) const {
-  int size = g_list_length(plugin);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(plugin));
 
   for (GList* tmp = plugin; tmp; tmp = tmp->next) {
     plugin_x* ptr = reinterpret_cast<plugin_x*>(tmp->data);
@@ -183,8 +173,7 @@ void PkgInfoParcelable::WritePlugin(tizen_base::Parcel* parcel,
 
 void PkgInfoParcelable::WriteResAllowedPackages(tizen_base::Parcel* parcel,
     GList* res_allowed_packages) const {
-  int size = g_list_length(res_allowed_packages);
-  WriteInt(parcel, size);
+  WriteInt(parcel, g_list_length(res_allowed_packages));
 
   for (GList* tmp = res_allowed_packages; tmp; tmp = tmp->next) {
     res_allowed_package_x* ptr =
@@ -192,13 +181,13 @@ void PkgInfoParcelable::WriteResAllowedPackages(tizen_base::Parcel* parcel,
     WriteString(parcel, ptr->allowed_package);
 
     WriteInt(parcel, g_list_length(ptr->required_privileges));
-    for (GList *priv = ptr->required_privileges; priv; priv = priv->next)
-      WriteString(parcel, reinterpret_cast<char *>(priv->data));
+    for (GList* priv = ptr->required_privileges; priv; priv = priv->next)
+      WriteString(parcel, reinterpret_cast<char*>(priv->data));
   }
 }
 
 void PkgInfoParcelable::WritePackage(tizen_base::Parcel* parcel,
-    package_x *package) const {
+    package_x* package) const {
   WriteString(parcel, package->for_all_users);
   WriteString(parcel, package->package);
   WriteString(parcel, package->version);
@@ -367,9 +356,9 @@ void PkgInfoParcelable::ReadApplication(
   AppInfoParcelable apps;
   parcel->ReadParcelable(&apps);
 
-  std::vector<application_x *> vt = apps.ExtractAppInfo();
+  std::vector<application_x*> vt = apps.ExtractAppInfo();
 
-  for (application_x *application : vt)
+  for (application_x* application : vt)
     *list = g_list_append(*list, application);
 }
 
@@ -384,7 +373,7 @@ void PkgInfoParcelable::ReadDeviceprofile(
   ReadInt(parcel, &size);
 
   for (int i = 0; i < size; ++i) {
-    char *device_profile = nullptr;
+    char* device_profile = nullptr;
     ReadString(parcel, &device_profile);
     *list = g_list_append(*list, device_profile);
   }
@@ -434,10 +423,10 @@ void PkgInfoParcelable::ReadResAllowedPackages(tizen_base::Parcel* parcel,
     ReadString(parcel, &res_allowed_package->allowed_package);
 
     int priv_len;
-    GList *priv_list = nullptr;
+    GList* priv_list = nullptr;
     ReadInt(parcel, &priv_len);
     for (int i = 0; i < priv_len; ++i) {
-      char *priv = nullptr;
+      char* priv = nullptr;
       ReadString(parcel, &priv);
       priv_list = g_list_prepend(priv_list, priv);
     }
@@ -447,7 +436,7 @@ void PkgInfoParcelable::ReadResAllowedPackages(tizen_base::Parcel* parcel,
   }
 }
 
-package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
+package_x* PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
   package_x* package =
       reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
 
@@ -505,14 +494,14 @@ PkgInfoParcelable::PkgInfoParcelable()
     write_type_(PkgWriteType::None), auto_release_(true) {}
 
 PkgInfoParcelable::PkgInfoParcelable(
-    uid_t uid, std::vector<package_x *>&& pkg_list,
+    uid_t uid, std::vector<package_x*>&& pkg_list,
     PkgWriteType write_type, bool auto_release)
     : AbstractParcelable(uid, ParcelableType::PkgInfo),
     pkg_list_(std::move(pkg_list)), write_type_(write_type),
     auto_release_(auto_release) {}
 
 PkgInfoParcelable::PkgInfoParcelable(
-    int ret, std::vector<package_x *>&& pkg_list, bool auto_release)
+    int ret, std::vector<package_x*>&& pkg_list, bool auto_release)
     : AbstractParcelable(0, ParcelableType::PkgInfo, ret),
     pkg_list_(std::move(pkg_list)), write_type_(PkgWriteType::None),
     auto_release_(auto_release) {}
@@ -521,16 +510,15 @@ PkgInfoParcelable::~PkgInfoParcelable() {
   if (!auto_release_)
     return;
 
-  for (auto pkg : pkg_list_) {
+  for (auto pkg : pkg_list_)
     pkgmgrinfo_basic_free_package(pkg);
-  }
 }
 
-const std::vector<package_x *>& PkgInfoParcelable::GetPkgInfo() {
+const std::vector<package_x*>& PkgInfoParcelable::GetPkgInfo() {
   return pkg_list_;
 }
 
-std::vector<package_x *> PkgInfoParcelable::ExtractPkgInfo() {
+std::vector<package_x*> PkgInfoParcelable::ExtractPkgInfo() {
   return std::move(pkg_list_);
 }
 
@@ -544,9 +532,8 @@ void PkgInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
 
   WriteInt(parcel, pkg_list_.size());
 
-  for (auto pkg : pkg_list_) {
+  for (auto pkg : pkg_list_)
     WritePackage(parcel, pkg);
-  }
 }
 
 void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
@@ -560,9 +547,8 @@ void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
 
   ReadInt(parcel, &len);
 
-  for (int i = 0; i < len ; ++i) {
+  for (int i = 0; i < len ; ++i)
     pkg_list_.emplace_back(ReadPackage(parcel));
-  }
 }
 
 }  // namespace parcel
diff --git a/src/common/parcel/pkginfo_parcelable.hh b/src/common/parcel/pkginfo_parcelable.hh
index e10e05a4..8070c356 100644
--- a/src/common/parcel/pkginfo_parcelable.hh
+++ b/src/common/parcel/pkginfo_parcelable.hh
@@ -19,11 +19,13 @@ namespace parcel {
 class EXPORT_API PkgInfoParcelable : public AbstractParcelable {
  public:
   PkgInfoParcelable();
-  PkgInfoParcelable(uid_t uid, std::vector<package_x *>&& pkg_list, PkgWriteType write_type, bool auto_release = true);
-  PkgInfoParcelable(int ret, std::vector<package_x *>&& pkg_list, bool auto_release = true);
+  PkgInfoParcelable(uid_t uid, std::vector<package_x*>&& pkg_list,
+      PkgWriteType write_type, bool auto_release = true);
+  PkgInfoParcelable(int ret, std::vector<package_x*>&& pkg_list,
+      bool auto_release = true);
   ~PkgInfoParcelable();
-  const std::vector<package_x *>& GetPkgInfo();
-  std::vector<package_x *> ExtractPkgInfo();
+  const std::vector<package_x*>& GetPkgInfo();
+  std::vector<package_x*> ExtractPkgInfo();
   PkgWriteType GetWriteType();
 
   void WriteToParcel(tizen_base::Parcel* parcel) const override;
@@ -36,15 +38,21 @@ class EXPORT_API PkgInfoParcelable : public AbstractParcelable {
   void WriteDescription(tizen_base::Parcel* parcel, GList* description) const;
   void WriteLicense(tizen_base::Parcel* parcel, GList* license) const;
   void WritePrivileges(tizen_base::Parcel* parcel, GList* privileges) const;
-  void WriteAppdefinedPrivileges(tizen_base::Parcel* parcel, GList* appdefined_privileges) const;
-  void WriteProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel, GList* provides_appdefined_privileges) const;
+  void WriteAppdefinedPrivileges(tizen_base::Parcel* parcel,
+      GList* appdefined_privileges) const;
+  void WriteProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel,
+      GList* provides_appdefined_privileges) const;
   void WriteApplication(tizen_base::Parcel* parcel, GList* application) const;
-  void WriteCompatibility(tizen_base::Parcel* parcel, GList* compatibility) const;
-  void WriteDeviceprofile(tizen_base::Parcel* parcel, GList* deviceprofile) const;
-  void WriteDependencies(tizen_base::Parcel* parcel, GList* dependencies) const;
+  void WriteCompatibility(tizen_base::Parcel* parcel,
+      GList* compatibility) const;
+  void WriteDeviceprofile(tizen_base::Parcel* parcel,
+      GList* deviceprofile) const;
+  void WriteDependencies(tizen_base::Parcel* parcel,
+      GList* dependencies) const;
   void WritePlugin(tizen_base::Parcel* parcel, GList* plugin) const;
-  void WriteResAllowedPackages(tizen_base::Parcel* parcel, GList* plugin) const;
-  void WritePackage(tizen_base::Parcel* parcel, package_x *package) const;
+  void WriteResAllowedPackages(tizen_base::Parcel* parcel,
+      GList* plugin) const;
+  void WritePackage(tizen_base::Parcel* parcel, package_x* package) const;
   void ReadIcon(tizen_base::Parcel* parcel, GList** list);
   void ReadLabel(tizen_base::Parcel* parcel, GList** list);
   void ReadAuthor(tizen_base::Parcel* parcel, GList** list);
@@ -52,16 +60,17 @@ class EXPORT_API PkgInfoParcelable : public AbstractParcelable {
   void ReadLicense(tizen_base::Parcel* parcel, GList** list);
   void ReadPrivileges(tizen_base::Parcel* parcel, GList** list);
   void ReadAppdefinedPrivileges(tizen_base::Parcel* parcel, GList** list);
-  void ReadProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel, GList** list);
+  void ReadProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel,
+      GList** list);
   void ReadApplication(tizen_base::Parcel* parcel, GList** list);
   void ReadCompatibility(tizen_base::Parcel* parcel, GList** list);
   void ReadDeviceprofile(tizen_base::Parcel* parcel, GList** list);
   void ReadDependencies(tizen_base::Parcel* parcel, GList** list);
   void ReadPlugin(tizen_base::Parcel* parcel, GList** list);
   void ReadResAllowedPackages(tizen_base::Parcel* parcel, GList** list);
-  package_x *ReadPackage(tizen_base::Parcel* parcel);
+  package_x* ReadPackage(tizen_base::Parcel* parcel);
 
-  std::vector<package_x *> pkg_list_;
+  std::vector<package_x*> pkg_list_;
   PkgWriteType write_type_;
   bool auto_release_;
 };
diff --git a/src/common/parcel/query_parcelable.cc b/src/common/parcel/query_parcelable.cc
index 40fa0fa1..9ddf663e 100644
--- a/src/common/parcel/query_parcelable.cc
+++ b/src/common/parcel/query_parcelable.cc
@@ -79,10 +79,12 @@ void QueryParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
 
   AbstractParcelable::ReadFromParcel(parcel);
   ReadInt(parcel, &query_size);
+
   for (int i = 0; i < query_size; ++i) {
     StrArgs args;
     int index = -1;
     int arg_cnt = 0;
+
     ReadInt(parcel, &index);
     ReadInt(parcel, &arg_cnt);
 
@@ -91,8 +93,10 @@ void QueryParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
 
     query_args_.push_back(QueryArgs(index, std::move(args)));
   }
+
   ReadInt(parcel, &db_type);
   db_type_ = static_cast<DBType>(db_type);
+
   ReadInt(parcel, &op_type);
   op_type_ = static_cast<DBOperationType>(op_type);
 }
diff --git a/src/common/ready_checker.cc b/src/common/ready_checker.cc
index 48e4c5cb..61d9f67a 100644
--- a/src/common/ready_checker.cc
+++ b/src/common/ready_checker.cc
@@ -41,15 +41,17 @@ gboolean ReadyChecker::OnReceiveEvent(GIOChannel* channel, GIOCondition cond,
       if (nptr > buf + len)
         break;
 
-      if (event->len) {
-        if (event->mask & IN_CREATE &&
-            ready_checker->ready_file_ == event->name) {
-          _LOGI("server is ready (%s)", ready_checker->ready_file_.c_str());
-          ready_checker->ready_ = true;
-          ready_checker->Dispose();
-          return G_SOURCE_CONTINUE;
-        }
-      }
+      if (!event->len)
+        continue;
+
+      if (!(event->mask & IN_CREATE) ||
+          ready_checker->ready_file_ != event->name)
+        continue;
+
+      _LOGI("server is ready (%s)", ready_checker->ready_file_.c_str());
+      ready_checker->ready_ = true;
+      ready_checker->Dispose();
+      return G_SOURCE_CONTINUE;
     }
   }
 
@@ -62,6 +64,7 @@ ReadyChecker::ReadyChecker(const std::string& ready_path) {
     disposed_ = true;
     return;
   }
+
   auto it = ready_path.find_last_of("/");
   if (it == ready_path.npos) {
     _LOGE("Invalid path %s", ready_path.c_str());
@@ -75,6 +78,7 @@ ReadyChecker::ReadyChecker(const std::string& ready_path) {
     disposed_ = true;
     return;
   }
+
   ready_path_ = ready_path.substr(0, it);
   ready_file_ = ready_path.substr(it + 1);
   wd_ = inotify_add_watch(fd_, ready_path_.c_str(), IN_CREATE);
@@ -90,6 +94,7 @@ ReadyChecker::ReadyChecker(const std::string& ready_path) {
     Dispose();
     return;
   }
+
   tag_ = g_io_add_watch(channel_, G_IO_IN, OnReceiveEvent, this);
   if (tag_ == 0) {
     _LOGE("Failed to add watch");
diff --git a/src/common/ready_checker.hh b/src/common/ready_checker.hh
index bd6a2a07..49871a97 100644
--- a/src/common/ready_checker.hh
+++ b/src/common/ready_checker.hh
@@ -37,11 +37,6 @@ class EXPORT_API ReadyChecker {
   ReadyChecker& operator = (const ReadyChecker&) = delete;
   bool IsReady() const;
 
- private:
-  void Dispose();
-  static gboolean OnReceiveEvent(GIOChannel* channel, GIOCondition cond,
-      gpointer user_data);
-
  private:
   std::string ready_path_;
   std::string ready_file_;
@@ -51,6 +46,10 @@ class EXPORT_API ReadyChecker {
   int tag_ = 0;
   bool ready_ = false;
   bool disposed_ = false;
+
+  void Dispose();
+  static gboolean OnReceiveEvent(GIOChannel* channel, GIOCondition cond,
+      gpointer user_data);
 };
 
 }  // namespace pkgmgr_common
diff --git a/src/common/request_type.cc b/src/common/request_type.cc
index 9ae546b3..eabf6016 100644
--- a/src/common/request_type.cc
+++ b/src/common/request_type.cc
@@ -31,8 +31,7 @@ const char* ReqTypeToString(ReqType type) {
       "CREATE_DB",
       "ERROR_REQ_TYPE"
   };
-  if (type <= ReqType::REQ_TYPE_NONE
-     || type >= ReqType::MAX)
+  if (type <= ReqType::REQ_TYPE_NONE || type >= ReqType::MAX)
     return convertArray[ReqType::MAX];
 
   return convertArray[type];
diff --git a/src/common/socket/abstract_socket.cc b/src/common/socket/abstract_socket.cc
index a8e03f0b..244adc92 100644
--- a/src/common/socket/abstract_socket.cc
+++ b/src/common/socket/abstract_socket.cc
@@ -41,6 +41,7 @@ AbstractSocket::~AbstractSocket() {
 int AbstractSocket::SendData(const void* buf, unsigned int size) {
   auto buffer = static_cast<const unsigned char*>(buf);
   unsigned int left = size;
+
   while (left) {
     ssize_t send_byte = send(fd_, buffer, left, MSG_NOSIGNAL);
     if (send_byte < 0) {
@@ -57,7 +58,9 @@ int AbstractSocket::SendData(const void* buf, unsigned int size) {
 
 int AbstractSocket::ReceiveData(void* buf, unsigned int size) {
   bool is_blocking = true;
-  if (fcntl(fd_, F_GETFL, 0) & O_NONBLOCK) is_blocking = false;
+
+  if (fcntl(fd_, F_GETFL, 0) & O_NONBLOCK)
+    is_blocking = false;
 
   auto buffer = static_cast<unsigned char*>(buf);
   unsigned int left = size;
@@ -89,17 +92,26 @@ int AbstractSocket::ReceiveData(void* buf, unsigned int size) {
   return 0;
 }
 
-int AbstractSocket::GetFd() { return fd_; }
+int AbstractSocket::GetFd() {
+  return fd_;
+}
 
-std::string AbstractSocket::GetPath() { return path_; }
+std::string AbstractSocket::GetPath() {
+  return path_;
+}
 
-pid_t AbstractSocket::GetPID() { return pid_; }
+pid_t AbstractSocket::GetPID() {
+  return pid_;
+}
 
-uid_t AbstractSocket::GetUID() { return uid_; }
+uid_t AbstractSocket::GetUID() {
+  return uid_;
+}
 
 void AbstractSocket::SetOption() {
   int size = 2048;
   int ret = setsockopt(fd_, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
+
   if (ret < 0) {
     LOGE("setsockopt() is failed. fd(%d), errno(%d)", fd_, errno);
     return;
@@ -110,7 +122,9 @@ void AbstractSocket::SetOption() {
 }
 
 int AbstractSocket::Create() {
-  if (fd_ != -1) return 0;
+  if (fd_ != -1)
+    return 0;
+
   fd_ = ::socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
   if (fd_ < 0) {
     LOGE("socket() is failed. errno(%d)", errno);
diff --git a/src/common/socket/abstract_socket.hh b/src/common/socket/abstract_socket.hh
index e4160ebd..0bc91a45 100644
--- a/src/common/socket/abstract_socket.hh
+++ b/src/common/socket/abstract_socket.hh
@@ -44,19 +44,17 @@ class EXPORT_API AbstractSocket {
   pid_t GetPID();
   uid_t GetUID();
 
- protected:
-  void SetOption();
-  int Create();
-
- private:
-  void GetFdInfo();
-
  protected:
   std::string path_;
   int fd_;
   pid_t pid_ = -1;
   uid_t uid_ = -1;
   struct sockaddr_un addr_;
+  void SetOption();
+  int Create();
+
+ private:
+  void GetFdInfo();
 };
 
 }  // namespace socket
diff --git a/src/common/socket/client_socket.cc b/src/common/socket/client_socket.cc
index c0cd8dc4..231173fb 100644
--- a/src/common/socket/client_socket.cc
+++ b/src/common/socket/client_socket.cc
@@ -27,11 +27,12 @@
 namespace pkgmgr_common {
 namespace socket {
 
-ClientSocket::ClientSocket(std::string path) : AbstractSocket(std::move(path)) {
-}
+ClientSocket::ClientSocket(std::string path)
+    : AbstractSocket(std::move(path)) {}
 
 void ClientSocket::SetTimeout(int timeout_msec) {
-  if (timeout_msec == -1) timeout_msec = 5000;
+  if (timeout_msec == -1)
+    timeout_msec = 5000;
 
   if (timeout_msec < 0) {
     LOGE("Invalid timeout_msec parameter");
@@ -41,6 +42,7 @@ void ClientSocket::SetTimeout(int timeout_msec) {
   struct timeval timeout = {
       .tv_sec = static_cast<time_t>(timeout_msec / 1000),
       .tv_usec = static_cast<suseconds_t>((timeout_msec % 1000) * 1000)};
+
   int ret = setsockopt(fd_, SOL_SOCKET, SO_RCVTIMEO, &timeout,
       sizeof(timeout));
   if (ret < 0)
@@ -48,8 +50,11 @@ void ClientSocket::SetTimeout(int timeout_msec) {
 }
 
 bool ClientSocket::Connect() {
-  if (Create() < 0) return false;
+  if (Create() < 0)
+    return false;
+
   SetTimeout(5000);
+
   int ret = -1;
   int retry_cnt = 3;
   do {
@@ -77,6 +82,7 @@ bool ClientSocket::Connect() {
 
 int ClientSocket::TryConnection() {
   int flags = fcntl(fd_, F_GETFL, 0);
+
   if (fcntl(fd_, F_SETFL, flags | O_NONBLOCK) != 0) {
     LOGE("Failed to set flags(%d) on fd(%d), errno(%d)",
         flags | O_NONBLOCK, fd_, errno);
diff --git a/src/common/system_locale.cc b/src/common/system_locale.cc
index 557011fc..dd39f4ff 100644
--- a/src/common/system_locale.cc
+++ b/src/common/system_locale.cc
@@ -58,8 +58,10 @@ void SystemLocale::SetLocale() {
 
 void SystemLocale::LanChangedCb(keynode_t* node, void* user_data) {
   char* val = vconf_keynode_get_str(node);
+
   if (val == nullptr)
     return;
+
   SystemLocale* sl = reinterpret_cast<SystemLocale*>(user_data);
   sl->lang_ = val;
   sl->SetLocale();
diff --git a/src/common/system_locale.hh b/src/common/system_locale.hh
index 49196c6a..76a02b85 100644
--- a/src/common/system_locale.hh
+++ b/src/common/system_locale.hh
@@ -28,16 +28,15 @@ class EXPORT_API SystemLocale {
   void RegisterEvent(IEvent* listener);
   void UnRegisterEvent();
 
- private:
-   SystemLocale();
-  ~SystemLocale();
-  void SetLocale();
-  static void LanChangedCb(keynode_t* node, void* user_data);
-
  private:
   std::string lang_;
   std::string locale_;
   IEvent* listener_ = nullptr;
+
+  SystemLocale();
+  ~SystemLocale();
+  void SetLocale();
+  static void LanChangedCb(keynode_t* node, void* user_data);
 };
 
 }  // namespace pkgmgr_common
diff --git a/src/server/certinfo_internal.c b/src/server/certinfo_internal.c
index 6c61aa54..2d2cd8db 100644
--- a/src/server/certinfo_internal.c
+++ b/src/server/certinfo_internal.c
@@ -366,41 +366,3 @@ API int certinfo_internal_set(sqlite3 *db, const char *pkgid,
 
 	return PMINFO_R_OK;
 }
-
-API int certinfo_internal_delete(sqlite3 *db, const char *pkgid)
-{
-	char *query = NULL;
-	int ret;
-	sqlite3_stmt *stmt;
-
-	if (db == NULL || pkgid == NULL)
-		return PMINFO_R_EINVAL;
-
-	query = sqlite3_mprintf("UPDATE package_cert_info "
-			"SET package_count = package_count - 1 "
-			"WHERE package=%Q", pkgid);
-
-	ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
-	sqlite3_free(query);
-	if (ret != SQLITE_OK) {
-		_LOGE("prepare error: %s", sqlite3_errmsg(db));
-		return PMINFO_R_ERROR;
-	}
-
-	ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
-	if (ret != SQLITE_OK) {
-		_LOGE("bind error: %s", sqlite3_errmsg(db));
-		sqlite3_finalize(stmt);
-		return PMINFO_R_ERROR;
-	}
-
-	ret = sqlite3_step(stmt);
-	sqlite3_finalize(stmt);
-	if (ret != SQLITE_DONE) {
-		_LOGE("step error: %s", sqlite3_errmsg(db));
-		return PMINFO_R_ERROR;
-	}
-
-	return PMINFO_R_OK;
-
-}
diff --git a/src/server/pkgmgrinfo_internal.h b/src/server/pkgmgrinfo_internal.h
index 00556c89..f8ddd754 100644
--- a/src/server/pkgmgrinfo_internal.h
+++ b/src/server/pkgmgrinfo_internal.h
@@ -92,7 +92,6 @@ int pkginfo_internal_filter_get_list(sqlite3 *db, pkgmgrinfo_pkginfo_filter_h fi
 int appinfo_internal_filter_get_list(sqlite3 *db, pkgmgrinfo_appinfo_filter_h filter, uid_t db_uid, uid_t uid, const char *locale, GHashTable *list);
 int certinfo_internal_get(sqlite3 *db, const char *pkgid, uid_t uid, pkgmgrinfo_certinfo_h certinfo);
 int certinfo_internal_set(sqlite3 *db, const char *pkgid, pkgmgrinfo_instcertinfo_h handle, uid_t uid);
-int certinfo_internal_delete(sqlite3 *db, const char *pkgid);
 int get_query_result(sqlite3 *db, const char *query, GList *param, GList **list, int *row, int *col);
 int execute_write_queries(sqlite3 *db, GList *queries, GList *params_list);
 int pkginfo_internal_filter_get_depends_on(sqlite3 *db, const char *pkgid, GList **list);