Skip to content

GitLab

T
tangled
Commit 9c1601a7 authored by Nikita Podguzov's avatar Nikita Podguzov Committed by Commit Bot
Browse files
Options

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: default avatarLei Zhang <thestig@chromium.org>
Reviewed-by: default avatarSergey Poromov <poromov@chromium.org>
Commit-Queue: Nikita Podguzov <nikitapodguzov@chromium.org>
Cr-Commit-Position: refs/heads/master@{#702138}
parent 582a74f6
Hide whitespace changes
Inline Side-by-side
Showing with 139 additions and 418 deletions
chrome/browser/policy/printing_restrictions_policy_handler.cc
View file @ 9c1601a7
...@@ -12,135 +12,132 @@ ...@@ -12,135 +12,132 @@
namespace policy { namespace policy {
PrintingAllowedColorModesPolicyHandler::PrintingAllowedColorModesPolicyHandler() template <class Mode>
: TypeCheckingPolicyHandler(key::kPrintingAllowedColorModes, PrintingEnumPolicyHandler<Mode>::PrintingEnumPolicyHandler(
base::Value::Type::STRING) {} const char* policy_name,
const char* pref_name,
PrintingAllowedColorModesPolicyHandler:: const base::flat_map<std::string, Mode>& policy_value_to_mode)
~PrintingAllowedColorModesPolicyHandler() {} : TypeCheckingPolicyHandler(policy_name, base::Value::Type::STRING),
policy_name_(policy_name),
bool PrintingAllowedColorModesPolicyHandler::GetValue( pref_name_(pref_name),
const PolicyMap& policies, policy_value_to_mode_(policy_value_to_mode) {}
PolicyErrorMap* errors,
printing::ColorModeRestriction* result) { template <class Mode>
const base::Value* value; PrintingEnumPolicyHandler<Mode>::~PrintingEnumPolicyHandler() = default;
if (CheckAndGetValue(policies, errors, &value) && value) {
base::Optional<printing::ColorModeRestriction> mode = template <class Mode>
printing::GetAllowedColorModesForName(value->GetString()); bool PrintingEnumPolicyHandler<Mode>::CheckPolicySettings(
if (mode.has_value()) {
if (result)
*result = mode.value();
return true;
} else if (errors) {
errors->AddError(key::kPrintingAllowedColorModes,
IDS_POLICY_VALUE_FORMAT_ERROR);
}
}
return false;
}
bool PrintingAllowedColorModesPolicyHandler::CheckPolicySettings(
const PolicyMap& policies, const PolicyMap& policies,
PolicyErrorMap* errors) { PolicyErrorMap* errors) {
return GetValue(policies, errors, nullptr); return GetValue(policies, errors, nullptr);
} }
void PrintingAllowedColorModesPolicyHandler::ApplyPolicySettings( template <class Mode>
void PrintingEnumPolicyHandler<Mode>::ApplyPolicySettings(
const PolicyMap& policies, const PolicyMap& policies,
PrefValueMap* prefs) { PrefValueMap* prefs) {
printing::ColorModeRestriction value; Mode value;
if (GetValue(policies, nullptr, &value)) { if (GetValue(policies, nullptr, &value)) {
prefs->SetInteger(prefs::kPrintingAllowedColorModes, prefs->SetInteger(pref_name_, static_cast<int>(value));
static_cast<int>(value));
} }
} }
PrintingAllowedDuplexModesPolicyHandler:: template <class Mode>
PrintingAllowedDuplexModesPolicyHandler() bool PrintingEnumPolicyHandler<Mode>::GetValue(const PolicyMap& policies,
: TypeCheckingPolicyHandler(key::kPrintingAllowedDuplexModes, PolicyErrorMap* errors,
base::Value::Type::STRING) {} Mode* result) {
PrintingAllowedDuplexModesPolicyHandler::
~PrintingAllowedDuplexModesPolicyHandler() {}
bool PrintingAllowedDuplexModesPolicyHandler::GetValue(
const PolicyMap& policies,
PolicyErrorMap* errors,
printing::DuplexModeRestriction* result) {
const base::Value* value; const base::Value* value;
if (CheckAndGetValue(policies, errors, &value) && value) { if (CheckAndGetValue(policies, errors, &value) && value) {
base::Optional<printing::DuplexModeRestriction> mode = base::Optional<Mode> mode;
printing::GetAllowedDuplexModesForName(value->GetString()); auto it = policy_value_to_mode_.find(value->GetString());
if (it != policy_value_to_mode_.end())
mode = it->second;
if (mode.has_value()) { if (mode.has_value()) {
if (result) if (result)
*result = mode.value(); *result = mode.value();
return true; return true;
} else if (errors) {
errors->AddError(key::kPrintingAllowedDuplexModes,
IDS_POLICY_VALUE_FORMAT_ERROR);
} }
if (errors)
errors->AddError(policy_name_, IDS_POLICY_VALUE_FORMAT_ERROR);
} }
return false; return false;
} }
bool PrintingAllowedDuplexModesPolicyHandler::CheckPolicySettings( PrintingAllowedColorModesPolicyHandler::PrintingAllowedColorModesPolicyHandler()
const PolicyMap& policies, : PrintingEnumPolicyHandler<printing::ColorModeRestriction>(
PolicyErrorMap* errors) { key::kPrintingAllowedColorModes,
return GetValue(policies, errors, nullptr); prefs::kPrintingAllowedColorModes,
} {
{"any", printing::ColorModeRestriction::kUnset},
{"monochrome", printing::ColorModeRestriction::kMonochrome},
{"color", printing::ColorModeRestriction::kColor},
}) {}
void PrintingAllowedDuplexModesPolicyHandler::ApplyPolicySettings( PrintingAllowedColorModesPolicyHandler::
const PolicyMap& policies, ~PrintingAllowedColorModesPolicyHandler() = default;
PrefValueMap* prefs) {
printing::DuplexModeRestriction value; PrintingAllowedDuplexModesPolicyHandler::
if (GetValue(policies, nullptr, &value)) { PrintingAllowedDuplexModesPolicyHandler()
prefs->SetInteger(prefs::kPrintingAllowedDuplexModes, : PrintingEnumPolicyHandler<printing::DuplexModeRestriction>(
static_cast<int>(value)); key::kPrintingAllowedDuplexModes,
} prefs::kPrintingAllowedDuplexModes,
} {
{"any", printing::DuplexModeRestriction::kUnset},
{"simplex", printing::DuplexModeRestriction::kSimplex},
{"duplex", printing::DuplexModeRestriction::kDuplex},
}) {}
PrintingAllowedDuplexModesPolicyHandler::
~PrintingAllowedDuplexModesPolicyHandler() = default;
PrintingAllowedPinModesPolicyHandler::PrintingAllowedPinModesPolicyHandler() PrintingAllowedPinModesPolicyHandler::PrintingAllowedPinModesPolicyHandler()
: TypeCheckingPolicyHandler(key::kPrintingAllowedPinModes, : PrintingEnumPolicyHandler<printing::PinModeRestriction>(
base::Value::Type::STRING) {} key::kPrintingAllowedPinModes,
prefs::kPrintingAllowedPinModes,
{
{"any", printing::PinModeRestriction::kUnset},
{"pin", printing::PinModeRestriction::kPin},
{"no_pin", printing::PinModeRestriction::kNoPin},
}) {}
PrintingAllowedPinModesPolicyHandler::~PrintingAllowedPinModesPolicyHandler() =
default;
PrintingAllowedPinModesPolicyHandler::~PrintingAllowedPinModesPolicyHandler() {} PrintingColorDefaultPolicyHandler::PrintingColorDefaultPolicyHandler()
: PrintingEnumPolicyHandler<printing::ColorModeRestriction>(
key::kPrintingColorDefault,
prefs::kPrintingColorDefault,
{
{"monochrome", printing::ColorModeRestriction::kMonochrome},
{"color", printing::ColorModeRestriction::kColor},
}) {}
bool PrintingAllowedPinModesPolicyHandler::GetValue( PrintingColorDefaultPolicyHandler::~PrintingColorDefaultPolicyHandler() =
const PolicyMap& policies, default;
PolicyErrorMap* errors,
printing::PinModeRestriction* result) {
const base::Value* value;
if (CheckAndGetValue(policies, errors, &value) && value) {
base::Optional<printing::PinModeRestriction> mode =
printing::GetAllowedPinModesForName(value->GetString());
if (mode.has_value()) {
if (result)
*result = mode.value();
return true; PrintingDuplexDefaultPolicyHandler::PrintingDuplexDefaultPolicyHandler()
} else if (errors) { : PrintingEnumPolicyHandler<printing::DuplexModeRestriction>(
errors->AddError(key::kPrintingAllowedPinModes, key::kPrintingDuplexDefault,
IDS_POLICY_VALUE_FORMAT_ERROR); prefs::kPrintingDuplexDefault,
} {
} {"simplex", printing::DuplexModeRestriction::kSimplex},
return false; {"long-edge", printing::DuplexModeRestriction::kLongEdge},
} {"short-edge", printing::DuplexModeRestriction::kShortEdge},
}) {}
PrintingDuplexDefaultPolicyHandler::~PrintingDuplexDefaultPolicyHandler() =
default;
bool PrintingAllowedPinModesPolicyHandler::CheckPolicySettings( PrintingPinDefaultPolicyHandler::PrintingPinDefaultPolicyHandler()
const PolicyMap& policies, : PrintingEnumPolicyHandler<printing::PinModeRestriction>(
PolicyErrorMap* errors) { key::kPrintingPinDefault,
return GetValue(policies, errors, nullptr); prefs::kPrintingPinDefault,
} {
{"pin", printing::PinModeRestriction::kPin},
{"no_pin", printing::PinModeRestriction::kNoPin},
}) {}
void PrintingAllowedPinModesPolicyHandler::ApplyPolicySettings( PrintingPinDefaultPolicyHandler::~PrintingPinDefaultPolicyHandler() = default;
const PolicyMap& policies,
PrefValueMap* prefs) {
printing::PinModeRestriction value;
if (GetValue(policies, nullptr, &value))
prefs->SetInteger(prefs::kPrintingAllowedPinModes, static_cast<int>(value));
}
PrintingAllowedPageSizesPolicyHandler::PrintingAllowedPageSizesPolicyHandler() PrintingAllowedPageSizesPolicyHandler::PrintingAllowedPageSizesPolicyHandler()
: ListPolicyHandler(key::kPrintingAllowedPageSizes, : ListPolicyHandler(key::kPrintingAllowedPageSizes,
...@@ -166,133 +163,11 @@ void PrintingAllowedPageSizesPolicyHandler::ApplyList( ...@@ -166,133 +163,11 @@ void PrintingAllowedPageSizesPolicyHandler::ApplyList(
base::Value::FromUniquePtrValue(std::move(filtered_list))); base::Value::FromUniquePtrValue(std::move(filtered_list)));
} }
PrintingColorDefaultPolicyHandler::PrintingColorDefaultPolicyHandler()
: TypeCheckingPolicyHandler(key::kPrintingColorDefault,
base::Value::Type::STRING) {}
PrintingColorDefaultPolicyHandler::~PrintingColorDefaultPolicyHandler() {}
bool PrintingColorDefaultPolicyHandler::GetValue(
const PolicyMap& policies,
PolicyErrorMap* errors,
printing::ColorModeRestriction* result) {
const base::Value* value;
if (CheckAndGetValue(policies, errors, &value) && value) {
base::Optional<printing::ColorModeRestriction> mode =
printing::GetColorModeForName(value->GetString());
if (mode.has_value()) {
if (result)
*result = mode.value();
return true;
} else if (errors) {
errors->AddError(key::kPrintingColorDefault,
IDS_POLICY_VALUE_FORMAT_ERROR);
}
}
return false;
}
bool PrintingColorDefaultPolicyHandler::CheckPolicySettings(
const PolicyMap& policies,
PolicyErrorMap* errors) {
return GetValue(policies, errors, nullptr);
}
void PrintingColorDefaultPolicyHandler::ApplyPolicySettings(
const PolicyMap& policies,
PrefValueMap* prefs) {
printing::ColorModeRestriction value;
if (GetValue(policies, nullptr, &value))
prefs->SetInteger(prefs::kPrintingColorDefault, static_cast<int>(value));
}
PrintingDuplexDefaultPolicyHandler::PrintingDuplexDefaultPolicyHandler()
: TypeCheckingPolicyHandler(key::kPrintingDuplexDefault,
base::Value::Type::STRING) {}
PrintingDuplexDefaultPolicyHandler::~PrintingDuplexDefaultPolicyHandler() {}
bool PrintingDuplexDefaultPolicyHandler::GetValue(
const PolicyMap& policies,
PolicyErrorMap* errors,
printing::DuplexModeRestriction* result) {
const base::Value* value;
if (CheckAndGetValue(policies, errors, &value) && value) {
base::Optional<printing::DuplexModeRestriction> mode =
printing::GetDuplexModeForName(value->GetString());
if (mode.has_value()) {
if (result)
*result = mode.value();
return true;
} else if (errors) {
errors->AddError(key::kPrintingDuplexDefault,
IDS_POLICY_VALUE_FORMAT_ERROR);
}
}
return false;
}
bool PrintingDuplexDefaultPolicyHandler::CheckPolicySettings(
const PolicyMap& policies,
PolicyErrorMap* errors) {
return GetValue(policies, errors, nullptr);
}
void PrintingDuplexDefaultPolicyHandler::ApplyPolicySettings(
const PolicyMap& policies,
PrefValueMap* prefs) {
printing::DuplexModeRestriction value;
if (GetValue(policies, nullptr, &value))
prefs->SetInteger(prefs::kPrintingDuplexDefault, static_cast<int>(value));
}
PrintingPinDefaultPolicyHandler::PrintingPinDefaultPolicyHandler()
: TypeCheckingPolicyHandler(key::kPrintingPinDefault,
base::Value::Type::STRING) {}
PrintingPinDefaultPolicyHandler::~PrintingPinDefaultPolicyHandler() {}
bool PrintingPinDefaultPolicyHandler::GetValue(
const PolicyMap& policies,
PolicyErrorMap* errors,
printing::PinModeRestriction* result) {
const base::Value* value;
if (CheckAndGetValue(policies, errors, &value) && value) {
base::Optional<printing::PinModeRestriction> mode =
printing::GetPinModeForName(value->GetString());
if (mode.has_value()) {
if (result)
*result = mode.value();
return true;
} else if (errors) {
errors->AddError(key::kPrintingPinDefault, IDS_POLICY_VALUE_FORMAT_ERROR);
}
}
return false;
}
bool PrintingPinDefaultPolicyHandler::CheckPolicySettings(
const PolicyMap& policies,
PolicyErrorMap* errors) {
return GetValue(policies, errors, nullptr);
}
void PrintingPinDefaultPolicyHandler::ApplyPolicySettings(
const PolicyMap& policies,
PrefValueMap* prefs) {
printing::PinModeRestriction value;
if (GetValue(policies, nullptr, &value))
prefs->SetInteger(prefs::kPrintingPinDefault, static_cast<int>(value));
}
PrintingSizeDefaultPolicyHandler::PrintingSizeDefaultPolicyHandler() PrintingSizeDefaultPolicyHandler::PrintingSizeDefaultPolicyHandler()
: TypeCheckingPolicyHandler(key::kPrintingSizeDefault, : TypeCheckingPolicyHandler(key::kPrintingSizeDefault,
base::Value::Type::DICTIONARY) {} base::Value::Type::DICTIONARY) {}
PrintingSizeDefaultPolicyHandler::~PrintingSizeDefaultPolicyHandler() {} PrintingSizeDefaultPolicyHandler::~PrintingSizeDefaultPolicyHandler() = default;
bool PrintingSizeDefaultPolicyHandler::CheckIntSubkey(const base::Value* dict, bool PrintingSizeDefaultPolicyHandler::CheckIntSubkey(const base::Value* dict,
const std::string& key, const std::string& key,
......
chrome/browser/policy/printing_restrictions_policy_handler.h
View file @ 9c1601a7
...@@ -7,6 +7,7 @@ ...@@ -7,6 +7,7 @@
#include <memory> #include <memory>
#include "base/containers/flat_map.h"
#include "components/policy/core/browser/configuration_policy_handler.h" #include "components/policy/core/browser/configuration_policy_handler.h"
#include "printing/backend/printing_restrictions.h" #include "printing/backend/printing_restrictions.h"
...@@ -16,13 +17,19 @@ namespace policy { ...@@ -16,13 +17,19 @@ namespace policy {
class PolicyMap; class PolicyMap;
class PrintingAllowedColorModesPolicyHandler template <class Mode>
: public TypeCheckingPolicyHandler { class PrintingEnumPolicyHandler : public TypeCheckingPolicyHandler {
static_assert(std::is_enum<Mode>::value,
"PrintingEnumPolicyHandler can only be used with enums");
public: public:
PrintingAllowedColorModesPolicyHandler(); PrintingEnumPolicyHandler(
~PrintingAllowedColorModesPolicyHandler() override; 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, bool CheckPolicySettings(const PolicyMap& policies,
PolicyErrorMap* errors) override; PolicyErrorMap* errors) override;
void ApplyPolicySettings(const PolicyMap& policies, void ApplyPolicySettings(const PolicyMap& policies,
...@@ -31,104 +38,64 @@ class PrintingAllowedColorModesPolicyHandler ...@@ -31,104 +38,64 @@ class PrintingAllowedColorModesPolicyHandler
private: private:
bool GetValue(const PolicyMap& policies, bool GetValue(const PolicyMap& policies,
PolicyErrorMap* errors, 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 class PrintingAllowedDuplexModesPolicyHandler
: public TypeCheckingPolicyHandler { : public PrintingEnumPolicyHandler<printing::DuplexModeRestriction> {
public: public:
PrintingAllowedDuplexModesPolicyHandler(); PrintingAllowedDuplexModesPolicyHandler();
~PrintingAllowedDuplexModesPolicyHandler() override; ~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: public:
PrintingAllowedPinModesPolicyHandler(); PrintingAllowedPinModesPolicyHandler();
~PrintingAllowedPinModesPolicyHandler() override; ~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: public:
PrintingColorDefaultPolicyHandler(); PrintingColorDefaultPolicyHandler();
~PrintingColorDefaultPolicyHandler() override; ~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: public:
PrintingDuplexDefaultPolicyHandler(); PrintingDuplexDefaultPolicyHandler();
~PrintingDuplexDefaultPolicyHandler() override; ~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: public:
PrintingPinDefaultPolicyHandler(); PrintingPinDefaultPolicyHandler();
~PrintingPinDefaultPolicyHandler() override; ~PrintingPinDefaultPolicyHandler() override;
};
// ConfigurationPolicyHandler implementation: class PrintingAllowedPageSizesPolicyHandler : public ListPolicyHandler {
bool CheckPolicySettings(const PolicyMap& policies, public:
PolicyErrorMap* errors) override; PrintingAllowedPageSizesPolicyHandler();
void ApplyPolicySettings(const PolicyMap& policies, ~PrintingAllowedPageSizesPolicyHandler() override;
PrefValueMap* prefs) override;
private: // ListPolicyHandler implementation:
bool GetValue(const PolicyMap& policies, bool CheckListEntry(const base::Value& value) override;
PolicyErrorMap* errors, void ApplyList(std::unique_ptr<base::ListValue> filtered_list,
printing::PinModeRestriction* result); PrefValueMap* prefs) override;
}; };
class PrintingSizeDefaultPolicyHandler : public TypeCheckingPolicyHandler { class PrintingSizeDefaultPolicyHandler : public TypeCheckingPolicyHandler {
......
printing/backend/printing_restrictions.cc
View file @ 9c1601a7
...@@ -15,74 +15,4 @@ const char kDefaultPinMode[] = "defaultPinMode"; ...@@ -15,74 +15,4 @@ const char kDefaultPinMode[] = "defaultPinMode";
const char kPageWidthUm[] = "WidthUm"; const char kPageWidthUm[] = "WidthUm";
const char kPageHeightUm[] = "HeightUm"; 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 } // namespace printing
printing/backend/printing_restrictions.h
View file @ 9c1601a7
...@@ -5,11 +5,7 @@ ...@@ -5,11 +5,7 @@
#ifndef PRINTING_BACKEND_PRINTING_RESTRICTIONS_H_ #ifndef PRINTING_BACKEND_PRINTING_RESTRICTIONS_H_
#define PRINTING_BACKEND_PRINTING_RESTRICTIONS_H_ #define PRINTING_BACKEND_PRINTING_RESTRICTIONS_H_
#include <vector>
#include "base/optional.h"
#include "printing/printing_export.h" #include "printing/printing_export.h"
#include "ui/gfx/geometry/size.h"
namespace printing { namespace printing {
...@@ -39,23 +35,6 @@ enum class PinModeRestriction { ...@@ -39,23 +35,6 @@ enum class PinModeRestriction {
kNoPin = 2, 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. // Dictionary key for printing policies.
// Must coincide with the name of field in |print_preview.Policies| in // Must coincide with the name of field in |print_preview.Policies| in
// chrome/browser/resources/print_preview/data/destination.js // chrome/browser/resources/print_preview/data/destination.js
...@@ -71,36 +50,6 @@ PRINTING_EXPORT extern const char kDefaultPinMode[]; ...@@ -71,36 +50,6 @@ PRINTING_EXPORT extern const char kDefaultPinMode[];
PRINTING_EXPORT extern const char kPageWidthUm[]; PRINTING_EXPORT extern const char kPageWidthUm[];
PRINTING_EXPORT extern const char kPageHeightUm[]; 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 } // namespace printing
#endif // PRINTING_BACKEND_PRINTING_RESTRICTIONS_H_ #endif // PRINTING_BACKEND_PRINTING_RESTRICTIONS_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment