Fix StepCheckBackgroundCategory

- Summarize variable name.
- Add functions to find category from list.
- Adjust return value of some functions.
- Change function name for readability.
- Separate some operations for readability.

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

diff --git a/src/common/step/security/step_check_background_category.cc b/src/common/step/security/step_check_background_category.cc
index 54da4958811213169ace9e1ea18328d4b3a6d102..0cf46fa6260645cbff1abae29b53f55634218c7b 100644 (file)
--- a/src/common/step/security/step_check_background_category.cc
+++ b/src/common/step/security/step_check_background_category.cc
@@ -14,6 +14,7 @@ namespace {
 namespace ci = common_installer;
 
 const utils::VersionNumber ver24("2.4");
+const std::string kSystem("system");
 
 }  // namespace
 
@@ -22,14 +23,19 @@ namespace security {
 
 StepCheckBackgroundCategory::StepCheckBackgroundCategory(
     ci::InstallerContext* context) : Step(context),
-        known_background_categories_ {
+        known_bg_cats_ {
             "media", "download", "background-network",
             "location", "sensor", "iot-communication" },
-        not_unknown_background_categories_ {
+        unknown_bg_cats_ {
             "media", "download", "background-network", "location",
             "sensor", "iot-communication", "system" } {
 }
 
+bool StepCheckBackgroundCategory::FindCats(
+    const BackgroundCatSet& bg_cats, std::string value) const {
+  return (bg_cats.find(value) != bg_cats.end());
+}
+
 GList* StepCheckBackgroundCategory::CopyValuesToBackgroundCategory(
     const BackgroundCatSet& values, GList* backgroundCategories) const {
   for (const auto& background_category : values) {
@@ -48,100 +54,99 @@ bool StepCheckBackgroundCategory::IsTrustedCert(
 
 bool StepCheckBackgroundCategory::ShouldSendFail(
     ci::PrivilegeLevel privilege,
-    const BackgroundCatSet& background_categories) const {
+    const BackgroundCatSet& bg_cats) const {
   return (privilege == ci::PrivilegeLevel::PUBLIC &&
-      background_categories.find("system") != background_categories.end()) ||
+      FindCats(bg_cats, kSystem)) ||
       (privilege == ci::PrivilegeLevel::UNTRUSTED &&
-          !background_categories.empty());
+          !bg_cats.empty());
 }
 
 bool StepCheckBackgroundCategory::ShouldSendAll(
     const utils::VersionNumber& version,
-    bool background_support,
+    bool bg_support,
     ci::PrivilegeLevel privilege,
-    const BackgroundCatSet& background_categories) const {
-  return version < ver24 && background_support &&
-      ((privilege == ci::PrivilegeLevel::PUBLIC &&
-          background_categories.find("system") ==
-              background_categories.end()) || IsTrustedCert(privilege));
+    const BackgroundCatSet& bg_cats) const {
+  if (version >= ver24 || !bg_support)
+    return false;
+
+  if ((privilege == ci::PrivilegeLevel::PUBLIC &&
+          !FindCats(bg_cats, kSystem)) || IsTrustedCert(privilege))
+    return true;
+
+  return false;
 }
 
 bool StepCheckBackgroundCategory::ShouldSendSystem(
     ci::PrivilegeLevel privilege,
-    const BackgroundCatSet& background_categories) const {
-  return IsTrustedCert(privilege) &&
-      background_categories.find("system") != background_categories.end();
+    const BackgroundCatSet& bg_cats) const {
+  return IsTrustedCert(privilege) && FindCats(bg_cats, kSystem);
 }
 
 bool StepCheckBackgroundCategory::ShouldSendKnown(
     const utils::VersionNumber& version,
-    bool background_support,
+    bool bg_support,
     ci::PrivilegeLevel privilege,
-    const BackgroundCatSet& background_categories) const {
+    const BackgroundCatSet& bg_cats) const {
   BackgroundCatSet intersect;
-  std::set_intersection(known_background_categories_.begin(),
-      known_background_categories_.end(),
-      background_categories.begin(), background_categories.end(),
+  std::set_intersection(known_bg_cats_.begin(), known_bg_cats_.end(),
+      bg_cats.begin(), bg_cats.end(),
       std::inserter(intersect, intersect.begin()));
 
-  return !(ShouldSendFail(privilege, background_categories) ||
+  return !(ShouldSendFail(privilege, bg_cats) ||
       ShouldSendAll(
-          version, background_support, privilege, background_categories)) &&
-      !background_categories.empty() && !intersect.empty();
+          version, bg_support, privilege, bg_cats)) &&
+      !bg_cats.empty() && !intersect.empty();
 }
 
 bool StepCheckBackgroundCategory::ShouldSendUnknown(
     ci::PrivilegeLevel privilege,
-    const BackgroundCatSet& background_categories) const {
+    const BackgroundCatSet& bg_cats) const {
   BackgroundCatSet diff;
-  std::set_difference(background_categories.begin(),
-      background_categories.end(),
-      not_unknown_background_categories_.begin(),
-      not_unknown_background_categories_.end(),
+  std::set_difference(bg_cats.begin(), bg_cats.end(),
+      unknown_bg_cats_.begin(), unknown_bg_cats_.end(),
       std::inserter(diff, diff.begin()));
 
-  return !(ShouldSendFail(privilege, background_categories) ||
-      background_categories.empty() || diff.empty());
+  return !(ShouldSendFail(privilege, bg_cats) ||
+      bg_cats.empty() || diff.empty());
 }
 
 void StepCheckBackgroundCategory::GetBackgroundCategories(
     const application_x& app,
-    BackgroundCatSet* background_categories) const {
+    BackgroundCatSet* bg_cats) const {
   for (const char* background_category : GListRange<char*>(
       app.background_category)) {
-    background_categories->insert(background_category);
+    bg_cats->insert(background_category);
   }
 }
 
-ci::Step::Status StepCheckBackgroundCategory::DoSendFail(
+bool StepCheckBackgroundCategory::Validate(
     ci::PrivilegeLevel privilege,
-    const BackgroundCatSet& background_categories) const {
-  if (ShouldSendFail(privilege, background_categories)) {
+    const BackgroundCatSet& bg_cats) const {
+  if (ShouldSendFail(privilege, bg_cats)) {
     LOG(ERROR) << "Installation fail caused by background-category";
-    return Status::ERROR;
+    return false;
   }
 
-  return Status::OK;
+  return true;
 }
 
 void StepCheckBackgroundCategory::DoSendAll(
     const utils::VersionNumber& version,
-    bool background_support,
+    bool bg_support,
     ci::PrivilegeLevel privilege,
-    const BackgroundCatSet& background_categories,
+    const BackgroundCatSet& bg_cats,
     application_x* app) const {
-  if (ShouldSendAll(version, background_support, privilege,
-      background_categories)) {
+  if (ShouldSendAll(version, bg_support, privilege, bg_cats)) {
     app->background_category = CopyValuesToBackgroundCategory(
-        known_background_categories_, app->background_category);
+        known_bg_cats_, app->background_category);
   }
 }
 
 void StepCheckBackgroundCategory::DoSendSystem(
     ci::PrivilegeLevel privilege,
-    const BackgroundCatSet& background_categories,
+    const BackgroundCatSet& bg_cats,
     application_x* app) const {
-  if (ShouldSendSystem(privilege, background_categories)) {
+  if (ShouldSendSystem(privilege, bg_cats)) {
     app->background_category = g_list_append(
         app->background_category, strdup("system"));
   }
@@ -149,45 +154,41 @@ void StepCheckBackgroundCategory::DoSendSystem(
 
 void StepCheckBackgroundCategory::DoSendKnown(
     const utils::VersionNumber& version,
-    bool background_support,
+    bool bg_support,
     ci::PrivilegeLevel privilege,
-    const BackgroundCatSet& background_categories,
+    const BackgroundCatSet& bg_cats,
     application_x* app) const {
-  if (ShouldSendKnown(version, background_support, privilege,
-      background_categories)) {
-    BackgroundCatSet to_insert;
-
-    // Get all known parsed values this is to handle case when more than one
-    // background-category element is declared and values are mixed
-    std::set_intersection(
-        known_background_categories_.begin(),
-        known_background_categories_.end(),
-        background_categories.begin(), background_categories.end(),
-        std::inserter(to_insert, to_insert.begin()));
+  if (!ShouldSendKnown(version, bg_support, privilege, bg_cats))
+    return;
+  BackgroundCatSet to_insert;
 
-    app->background_category = CopyValuesToBackgroundCategory(
-        to_insert, app->background_category);
-  }
+  // Get all known parsed values this is to handle case when more than one
+  // background-category element is declared and values are mixed
+  std::set_intersection(known_bg_cats_.begin(), known_bg_cats_.end(),
+      bg_cats.begin(), bg_cats.end(),
+      std::inserter(to_insert, to_insert.begin()));
+
+  app->background_category = CopyValuesToBackgroundCategory(
+      to_insert, app->background_category);
 }
 
 void StepCheckBackgroundCategory::DoSendUnknown(
     ci::PrivilegeLevel privilege,
-    const BackgroundCatSet& background_categories,
+    const BackgroundCatSet& bg_cats,
     application_x* app) const {
-  if (ShouldSendUnknown(privilege, background_categories)) {
-    BackgroundCatSet to_insert;
+  if (!ShouldSendUnknown(privilege, bg_cats))
+    return;
 
-    // Get all unknown parsed values this is to handle case when more than one
-    // background-category element is declared and values are mixed
-    std::set_difference(
-        background_categories.begin(), background_categories.end(),
-        not_unknown_background_categories_.begin(),
-        not_unknown_background_categories_.end(),
-        std::inserter(to_insert, to_insert.end()));
+  BackgroundCatSet to_insert;
 
-    app->background_category = CopyValuesToBackgroundCategory(
-        to_insert, app->background_category);
-  }
+  // Get all unknown parsed values this is to handle case when more than one
+  // background-category element is declared and values are mixed
+  std::set_difference(bg_cats.begin(), bg_cats.end(),
+      unknown_bg_cats_.begin(), unknown_bg_cats_.end(),
+      std::inserter(to_insert, to_insert.end()));
+
+  app->background_category = CopyValuesToBackgroundCategory(
+      to_insert, app->background_category);
 }
 
 void StepCheckBackgroundCategory::RemoveContextBackgroundCategories(
@@ -210,7 +211,7 @@ ci::Step::Status StepCheckBackgroundCategory::process() {
     GetBackgroundCategories(*app, &background_cat);
     RemoveContextBackgroundCategories(app);
 
-    if (DoSendFail(privilege_level, background_cat) == ci::Step::Status::ERROR)
+    if (!Validate(privilege_level, background_cat))
       return ci::Step::Status::ERROR;
     DoSendAll(version, background_supt, privilege_level, background_cat, app);
     DoSendSystem(privilege_level, background_cat, app);

diff --git a/src/common/step/security/step_check_background_category.h b/src/common/step/security/step_check_background_category.h
index 6eb0da4f0d0d4d549ae4a7c7fe6104d314afc7ac..546168c0eabe1b006ebae4aa5446de6df2653794 100644 (file)
--- a/src/common/step/security/step_check_background_category.h
+++ b/src/common/step/security/step_check_background_category.h
@@ -46,51 +46,52 @@ class StepCheckBackgroundCategory : public common_installer::Step {
   virtual bool GetBackgroundSupport() = 0;
 
  private:
+  bool FindCats(const BackgroundCatSet& bg_cats, std::string value) const;
   GList* CopyValuesToBackgroundCategory(
       const BackgroundCatSet& values, GList* backgroundCategories) const;
   bool IsTrustedCert(common_installer::PrivilegeLevel privilege) const;
   bool ShouldSendFail(common_installer::PrivilegeLevel privilege,
-                      const BackgroundCatSet& background_categories) const;
+                      const BackgroundCatSet& bg_cats) const;
   bool ShouldSendAll(const utils::VersionNumber& version,
                      bool background_support,
                      common_installer::PrivilegeLevel privilege,
-                     const BackgroundCatSet& background_categories) const;
+                     const BackgroundCatSet& bg_cats) const;
   bool ShouldSendSystem(common_installer::PrivilegeLevel privilege,
-                        const BackgroundCatSet& background_categories) const;
+                        const BackgroundCatSet& bg_cats) const;
   bool ShouldSendKnown(const utils::VersionNumber& version,
                        bool background_support,
                        common_installer::PrivilegeLevel privilege,
-                       const BackgroundCatSet& background_categories) const;
+                       const BackgroundCatSet& bg_cats) const;
   bool ShouldSendUnknown(common_installer::PrivilegeLevel privilege,
-                         const BackgroundCatSet& background_categories) const;
+                         const BackgroundCatSet& bg_cats) const;
 
-  common_installer::Step::Status DoSendFail(
+  bool Validate(
       common_installer::PrivilegeLevel privilege,
-      const BackgroundCatSet& background_categories) const;
+      const BackgroundCatSet& bg_cats) const;
   void DoSendAll(const utils::VersionNumber& version,
                  bool background_support,
                  common_installer::PrivilegeLevel privilege,
-                 const BackgroundCatSet& background_categories,
+                 const BackgroundCatSet& bg_cats,
                  application_x* app) const;
   void DoSendSystem(common_installer::PrivilegeLevel privilege,
-                    const BackgroundCatSet& background_categories,
+                    const BackgroundCatSet& bg_cats,
                     application_x* app) const;
   void DoSendKnown(const utils::VersionNumber& version,
                    bool background_support,
                    common_installer::PrivilegeLevel privilege,
-                   const BackgroundCatSet& background_categories,
+                   const BackgroundCatSet& bg_cats,
                    application_x* app) const;
   void DoSendUnknown(common_installer::PrivilegeLevel privilege,
-                     const BackgroundCatSet& background_categories,
+                     const BackgroundCatSet& bg_cats,
                      application_x* app) const;
 
   void GetBackgroundCategories(
       const application_x& app,
-      BackgroundCatSet* background_categories) const;
+      BackgroundCatSet* bg_cats) const;
   void RemoveContextBackgroundCategories(application_x* app) const;
 
-  const BackgroundCatSet known_background_categories_;
-  const BackgroundCatSet not_unknown_background_categories_;
+  const BackgroundCatSet known_bg_cats_;
+  const BackgroundCatSet unknown_bg_cats_;
 
   STEP_NAME(CheckBackgroundCategory)
 };