Refactor printing enum policies handlers

This CL allows to add new printing enum policies handlers by providing
only policy and pref names and map from policy string value to enum.

Bug: 1008941
Change-Id: I25be44e38b0b76dd378c2640d491bd3e4e17165b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1832805Reviewed-by: Lei Zhang <thestig@chromium.org>
Reviewed-by: Sergey Poromov <poromov@chromium.org>
Commit-Queue: Nikita Podguzov <nikitapodguzov@chromium.org>
Cr-Commit-Position: refs/heads/master@{#702138}

chrome/browser/policy/printing_restrictions_policy_handler.h

@@ -7,6 +7,7 @@
 
 #include <memory>
 
+#include "base/containers/flat_map.h"
 #include "components/policy/core/browser/configuration_policy_handler.h"
 #include "printing/backend/printing_restrictions.h"
 
@@ -16,13 +17,19 @@ namespace policy {
 
 class PolicyMap;
 
-class PrintingAllowedColorModesPolicyHandler
-    : public TypeCheckingPolicyHandler {
+template <class Mode>
+class PrintingEnumPolicyHandler : public TypeCheckingPolicyHandler {
+  static_assert(std::is_enum<Mode>::value,
+                "PrintingEnumPolicyHandler can only be used with enums");
+
  public:
-  PrintingAllowedColorModesPolicyHandler();
-  ~PrintingAllowedColorModesPolicyHandler() override;
+  PrintingEnumPolicyHandler(
+      const char* policy_name,
+      const char* pref_name,
+      const base::flat_map<std::string, Mode>& policy_value_to_mode);
+  ~PrintingEnumPolicyHandler() override;
 
-  // ConfigurationPolicyHandler implementation:
+  // ConfigurationPolicyHandler:
   bool CheckPolicySettings(const PolicyMap& policies,
                            PolicyErrorMap* errors) override;
   void ApplyPolicySettings(const PolicyMap& policies,
@@ -31,104 +38,64 @@ class PrintingAllowedColorModesPolicyHandler
  private:
   bool GetValue(const PolicyMap& policies,
                 PolicyErrorMap* errors,
-                printing::ColorModeRestriction* result);
+                Mode* result);
+
+  const char* const policy_name_;
+  const char* const pref_name_;
+  base::flat_map<std::string, Mode> policy_value_to_mode_;
+};
+
+class PrintingAllowedColorModesPolicyHandler
+    : public PrintingEnumPolicyHandler<printing::ColorModeRestriction> {
+ public:
+  PrintingAllowedColorModesPolicyHandler();
+  ~PrintingAllowedColorModesPolicyHandler() override;
 };
 
 class PrintingAllowedDuplexModesPolicyHandler
-    : public TypeCheckingPolicyHandler {
+    : public PrintingEnumPolicyHandler<printing::DuplexModeRestriction> {
  public:
   PrintingAllowedDuplexModesPolicyHandler();
   ~PrintingAllowedDuplexModesPolicyHandler() override;
-
-  // ConfigurationPolicyHandler implementation:
-  bool CheckPolicySettings(const PolicyMap& policies,
-                           PolicyErrorMap* errors) override;
-  void ApplyPolicySettings(const PolicyMap& policies,
-                           PrefValueMap* prefs) override;
-
- private:
-  bool GetValue(const PolicyMap& policies,
-                PolicyErrorMap* errors,
-                printing::DuplexModeRestriction* result);
 };
 
-class PrintingAllowedPinModesPolicyHandler : public TypeCheckingPolicyHandler {
+class PrintingAllowedPinModesPolicyHandler
+    : public PrintingEnumPolicyHandler<printing::PinModeRestriction> {
  public:
   PrintingAllowedPinModesPolicyHandler();
   ~PrintingAllowedPinModesPolicyHandler() override;
-
-  // ConfigurationPolicyHandler implementation:
-  bool CheckPolicySettings(const PolicyMap& policies,
-                           PolicyErrorMap* errors) override;
-  void ApplyPolicySettings(const PolicyMap& policies,
-                           PrefValueMap* prefs) override;
-
- private:
-  bool GetValue(const PolicyMap& policies,
-                PolicyErrorMap* errors,
-                printing::PinModeRestriction* result);
-};
-
-class PrintingAllowedPageSizesPolicyHandler : public ListPolicyHandler {
- public:
-  PrintingAllowedPageSizesPolicyHandler();
-  ~PrintingAllowedPageSizesPolicyHandler() override;
-
-  // ListPolicyHandler implementation:
-  bool CheckListEntry(const base::Value& value) override;
-  void ApplyList(std::unique_ptr<base::ListValue> filtered_list,
-                 PrefValueMap* prefs) override;
 };
 
-class PrintingColorDefaultPolicyHandler : public TypeCheckingPolicyHandler {
+class PrintingColorDefaultPolicyHandler
+    : public PrintingEnumPolicyHandler<printing::ColorModeRestriction> {
  public:
   PrintingColorDefaultPolicyHandler();
   ~PrintingColorDefaultPolicyHandler() override;
-
-  // ConfigurationPolicyHandler implementation:
-  bool CheckPolicySettings(const PolicyMap& policies,
-                           PolicyErrorMap* errors) override;
-  void ApplyPolicySettings(const PolicyMap& policies,
-                           PrefValueMap* prefs) override;
-
- private:
-  bool GetValue(const PolicyMap& policies,
-                PolicyErrorMap* errors,
-                printing::ColorModeRestriction* result);
 };
 
-class PrintingDuplexDefaultPolicyHandler : public TypeCheckingPolicyHandler {
+class PrintingDuplexDefaultPolicyHandler
+    : public PrintingEnumPolicyHandler<printing::DuplexModeRestriction> {
  public:
   PrintingDuplexDefaultPolicyHandler();
   ~PrintingDuplexDefaultPolicyHandler() override;
-
-  // ConfigurationPolicyHandler implementation:
-  bool CheckPolicySettings(const PolicyMap& policies,
-                           PolicyErrorMap* errors) override;
-  void ApplyPolicySettings(const PolicyMap& policies,
-                           PrefValueMap* prefs) override;
-
- private:
-  bool GetValue(const PolicyMap& policies,
-                PolicyErrorMap* errors,
-                printing::DuplexModeRestriction* result);
 };
 
-class PrintingPinDefaultPolicyHandler : public TypeCheckingPolicyHandler {
+class PrintingPinDefaultPolicyHandler
+    : public PrintingEnumPolicyHandler<printing::PinModeRestriction> {
  public:
   PrintingPinDefaultPolicyHandler();
   ~PrintingPinDefaultPolicyHandler() override;
+};
 
-  // ConfigurationPolicyHandler implementation:
-  bool CheckPolicySettings(const PolicyMap& policies,
-                           PolicyErrorMap* errors) override;
-  void ApplyPolicySettings(const PolicyMap& policies,
-                           PrefValueMap* prefs) override;
+class PrintingAllowedPageSizesPolicyHandler : public ListPolicyHandler {
+ public:
+  PrintingAllowedPageSizesPolicyHandler();
+  ~PrintingAllowedPageSizesPolicyHandler() override;
 
- private:
-  bool GetValue(const PolicyMap& policies,
-                PolicyErrorMap* errors,
-                printing::PinModeRestriction* result);
+  // ListPolicyHandler implementation:
+  bool CheckListEntry(const base::Value& value) override;
+  void ApplyList(std::unique_ptr<base::ListValue> filtered_list,
+                 PrefValueMap* prefs) override;
 };
 
 class PrintingSizeDefaultPolicyHandler : public TypeCheckingPolicyHandler {

printing/backend/printing_restrictions.cc

@@ -15,74 +15,4 @@ const char kDefaultPinMode[] = "defaultPinMode";
 const char kPageWidthUm[] = "WidthUm";
 const char kPageHeightUm[] = "HeightUm";
 
-PrintingRestrictions::PrintingRestrictions() {}
-
-PrintingRestrictions::~PrintingRestrictions() {}
-
-base::Optional<ColorModeRestriction> GetColorModeForName(
-    const std::string& mode_name) {
-  if (mode_name == "monochrome")
-    return ColorModeRestriction::kMonochrome;
-
-  if (mode_name == "color")
-    return ColorModeRestriction::kColor;
-
-  return base::nullopt;
-}
-
-base::Optional<ColorModeRestriction> GetAllowedColorModesForName(
-    const std::string& mode_name) {
-  if (mode_name == "any")
-    return ColorModeRestriction::kUnset;
-
-  return GetColorModeForName(mode_name);
-}
-
-base::Optional<DuplexModeRestriction> GetDuplexModeForName(
-    const std::string& mode_name) {
-  if (mode_name == "simplex")
-    return DuplexModeRestriction::kSimplex;
-
-  if (mode_name == "long-edge")
-    return DuplexModeRestriction::kLongEdge;
-
-  if (mode_name == "short-edge")
-    return DuplexModeRestriction::kShortEdge;
-
-  return base::nullopt;
-}
-
-base::Optional<DuplexModeRestriction> GetAllowedDuplexModesForName(
-    const std::string& mode_name) {
-  if (mode_name == "any")
-    return DuplexModeRestriction::kUnset;
-
-  if (mode_name == "simplex")
-    return DuplexModeRestriction::kSimplex;
-
-  if (mode_name == "duplex")
-    return DuplexModeRestriction::kDuplex;
-
-  return base::nullopt;
-}
-
-base::Optional<PinModeRestriction> GetPinModeForName(
-    const std::string& mode_name) {
-  if (mode_name == "pin")
-    return PinModeRestriction::kPin;
-
-  if (mode_name == "no_pin")
-    return PinModeRestriction::kNoPin;
-
-  return base::nullopt;
-}
-
-base::Optional<PinModeRestriction> GetAllowedPinModesForName(
-    const std::string& mode_name) {
-  if (mode_name == "any")
-    return PinModeRestriction::kUnset;
-
-  return GetPinModeForName(mode_name);
-}
-
 }  // namespace printing

printing/backend/printing_restrictions.h

@@ -5,11 +5,7 @@
 #ifndef PRINTING_BACKEND_PRINTING_RESTRICTIONS_H_
 #define PRINTING_BACKEND_PRINTING_RESTRICTIONS_H_
 
-#include <vector>
-
-#include "base/optional.h"
 #include "printing/printing_export.h"
-#include "ui/gfx/geometry/size.h"
 
 namespace printing {
 
@@ -39,23 +35,6 @@ enum class PinModeRestriction {
   kNoPin = 2,
 };
 
-struct PRINTING_EXPORT PrintingRestrictions {
-  PrintingRestrictions();
-  ~PrintingRestrictions();
-
-  // A bitmask of |ColorModeRestriction| specifying the allowed color modes.
-  ColorModeRestriction color_modes;
-
-  // A bitmask of |DuplexModeRestriction| specifying the allowed duplex modes.
-  DuplexModeRestriction duplex_modes;
-
-  // Specifies allowed PIN printing modes.
-  PinModeRestriction pin_modes;
-
-  // List of page sizes in microns.
-  std::vector<gfx::Size> page_sizes_um;
-};
-
 // Dictionary key for printing policies.
 // Must coincide with the name of field in |print_preview.Policies| in
 // chrome/browser/resources/print_preview/data/destination.js
@@ -71,36 +50,6 @@ PRINTING_EXPORT extern const char kDefaultPinMode[];
 PRINTING_EXPORT extern const char kPageWidthUm[];
 PRINTING_EXPORT extern const char kPageHeightUm[];
 
-// Translate color mode from |kPrintingColorDefault| policy to
-// |ColorModeRestriction| enum. Invalid values translated as |base::nullopt|.
-base::Optional<ColorModeRestriction> PRINTING_EXPORT
-GetColorModeForName(const std::string& mode_name);
-
-// Translate color mode from |kPrintingAllowedColorModes| policy to
-// |ColorModeRestriction| enum. Invalid values translated as |base::nullopt|.
-base::Optional<ColorModeRestriction> PRINTING_EXPORT
-GetAllowedColorModesForName(const std::string& mode_name);
-
-// Translate duplex mode from |kPrintingDuplexDefault| policy to
-// |DuplexModeRestriction| enum. Invalid values translated as |base::nullopt|.
-base::Optional<DuplexModeRestriction> PRINTING_EXPORT
-GetDuplexModeForName(const std::string& mode_name);
-
-// Translate color mode from |kPrintingAllowedDuplexModes| policy to
-// |DuplexModeRestriction| enum. Invalid values translated as |base::nullopt|.
-base::Optional<DuplexModeRestriction> PRINTING_EXPORT
-GetAllowedDuplexModesForName(const std::string& mode_name);
-
-// Translate PIN printing mode from |kPrintingPinDefault| policy to
-// |PinModeRestriction| enum. Invalid values translated as |base::nullopt|.
-base::Optional<PinModeRestriction> PRINTING_EXPORT
-GetPinModeForName(const std::string& mode_name);
-
-// Translate PIN printing mode from |kPrintingPinAllowedModes| policy to
-// |PinModeRestriction| enum. Invalid values translated as |base::nullopt|.
-base::Optional<PinModeRestriction> PRINTING_EXPORT
-GetAllowedPinModesForName(const std::string& mode_name);
-
 }  // namespace printing
 
 #endif  // PRINTING_BACKEND_PRINTING_RESTRICTIONS_H_