| // Copyright 2012 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "printing/backend/print_backend.h" |
| |
| #include <string> |
| #include <utility> |
| |
| #include "base/memory/scoped_refptr.h" |
| #include "build/build_config.h" |
| |
| namespace { |
| |
| // PrintBackend override for testing. |
| printing::PrintBackend* g_print_backend_for_test = nullptr; |
| |
| } // namespace |
| |
| namespace printing { |
| |
| PrinterBasicInfo::PrinterBasicInfo() = default; |
| |
| PrinterBasicInfo::PrinterBasicInfo(const std::string& printer_name, |
| const std::string& display_name, |
| const std::string& printer_description, |
| int printer_status, |
| bool is_default, |
| const PrinterBasicInfoOptions& options) |
| : printer_name(printer_name), |
| display_name(display_name), |
| printer_description(printer_description), |
| printer_status(printer_status), |
| is_default(is_default), |
| options(options) {} |
| |
| PrinterBasicInfo::PrinterBasicInfo(const PrinterBasicInfo& other) = default; |
| |
| PrinterBasicInfo::~PrinterBasicInfo() = default; |
| |
| bool PrinterBasicInfo::operator==(const PrinterBasicInfo& other) const { |
| return printer_name == other.printer_name && |
| display_name == other.display_name && |
| printer_description == other.printer_description && |
| printer_status == other.printer_status && |
| is_default == other.is_default && options == other.options; |
| } |
| |
| #if BUILDFLAG(IS_CHROMEOS) |
| |
| AdvancedCapabilityValue::AdvancedCapabilityValue() = default; |
| |
| AdvancedCapabilityValue::AdvancedCapabilityValue( |
| const std::string& name, |
| const std::string& display_name) |
| : name(name), display_name(display_name) {} |
| |
| AdvancedCapabilityValue::AdvancedCapabilityValue( |
| const AdvancedCapabilityValue& other) = default; |
| |
| AdvancedCapabilityValue::~AdvancedCapabilityValue() = default; |
| |
| bool AdvancedCapabilityValue::operator==( |
| const AdvancedCapabilityValue& other) const { |
| return name == other.name && display_name == other.display_name; |
| } |
| |
| AdvancedCapability::AdvancedCapability() = default; |
| |
| AdvancedCapability::AdvancedCapability(const std::string& name, |
| AdvancedCapability::Type type) |
| : name(name), type(type) {} |
| |
| AdvancedCapability::AdvancedCapability( |
| const std::string& name, |
| const std::string& display_name, |
| AdvancedCapability::Type type, |
| const std::string& default_value, |
| const std::vector<AdvancedCapabilityValue>& values) |
| : name(name), |
| display_name(display_name), |
| type(type), |
| default_value(default_value), |
| values(values) {} |
| |
| AdvancedCapability::AdvancedCapability(const AdvancedCapability& other) = |
| default; |
| |
| AdvancedCapability::~AdvancedCapability() = default; |
| |
| bool AdvancedCapability::operator==(const AdvancedCapability& other) const { |
| return name == other.name && display_name == other.display_name && |
| type == other.type && default_value == other.default_value && |
| values == other.values; |
| } |
| |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| |
| #if BUILDFLAG(IS_WIN) |
| |
| PageOutputQualityAttribute::PageOutputQualityAttribute() = default; |
| |
| PageOutputQualityAttribute::PageOutputQualityAttribute( |
| const std::string& display_name, |
| const std::string& name) |
| : display_name(display_name), name(name) {} |
| |
| PageOutputQualityAttribute::~PageOutputQualityAttribute() = default; |
| |
| bool PageOutputQualityAttribute::operator==( |
| const PageOutputQualityAttribute& other) const { |
| return display_name == other.display_name && name == other.name; |
| } |
| |
| bool PageOutputQualityAttribute::operator<( |
| const ::printing::PageOutputQualityAttribute& other) const { |
| return std::tie(name, display_name) < |
| std::tie(other.name, other.display_name); |
| } |
| |
| PageOutputQuality::PageOutputQuality() = default; |
| |
| PageOutputQuality::PageOutputQuality( |
| PageOutputQualityAttributes qualities, |
| absl::optional<std::string> default_quality) |
| : qualities(std::move(qualities)), |
| default_quality(std::move(default_quality)) {} |
| |
| PageOutputQuality::PageOutputQuality(const PageOutputQuality& other) = default; |
| |
| PageOutputQuality::~PageOutputQuality() = default; |
| |
| // This function is only supposed to be used in tests. The declaration in the |
| // header file is guarded by "#if defined(UNIT_TEST)" so that they can be used |
| // by tests but not non-test code. However, this .cc file is compiled as part of |
| // "backend" where "UNIT_TEST" is not defined. So we need to specify |
| // "COMPONENT_EXPORT(PRINT_BACKEND)" here again so that they are visible to |
| // tests. |
| COMPONENT_EXPORT(PRINT_BACKEND) |
| bool operator==(const PageOutputQuality& quality1, |
| const PageOutputQuality& quality2) { |
| return quality1.qualities == quality2.qualities && |
| quality1.default_quality == quality2.default_quality; |
| } |
| |
| XpsCapabilities::XpsCapabilities() = default; |
| |
| XpsCapabilities::XpsCapabilities(XpsCapabilities&& other) noexcept = default; |
| |
| XpsCapabilities& XpsCapabilities::operator=(XpsCapabilities&& other) noexcept = |
| default; |
| |
| XpsCapabilities::~XpsCapabilities() = default; |
| |
| #endif // BUILDFLAG(IS_WIN) |
| |
| PrinterSemanticCapsAndDefaults::Paper::Paper() = default; |
| |
| PrinterSemanticCapsAndDefaults::Paper::Paper(const std::string& display_name, |
| const std::string& vendor_id, |
| const gfx::Size& size_um) |
| : Paper(display_name, vendor_id, size_um, gfx::Rect(size_um)) {} |
| |
| PrinterSemanticCapsAndDefaults::Paper::Paper(const std::string& display_name, |
| const std::string& vendor_id, |
| const gfx::Size& size_um, |
| const gfx::Rect& printable_area_um) |
| : Paper(display_name, vendor_id, size_um, printable_area_um, 0) {} |
| |
| PrinterSemanticCapsAndDefaults::Paper::Paper(const std::string& display_name, |
| const std::string& vendor_id, |
| const gfx::Size& size_um, |
| const gfx::Rect& printable_area_um, |
| int max_height_um) |
| : Paper(display_name, |
| vendor_id, |
| size_um, |
| printable_area_um, |
| max_height_um, |
| false) {} |
| |
| PrinterSemanticCapsAndDefaults::Paper::Paper(const std::string& display_name, |
| const std::string& vendor_id, |
| const gfx::Size& size_um, |
| const gfx::Rect& printable_area_um, |
| int max_height_um, |
| bool has_borderless_variant) |
| : display_name_(display_name), |
| vendor_id_(vendor_id), |
| size_um_(size_um), |
| printable_area_um_(printable_area_um), |
| max_height_um_(max_height_um), |
| has_borderless_variant_(has_borderless_variant) {} |
| |
| PrinterSemanticCapsAndDefaults::Paper::Paper(const Paper& other) = default; |
| |
| PrinterSemanticCapsAndDefaults::Paper& |
| PrinterSemanticCapsAndDefaults::Paper::operator=(const Paper& other) = default; |
| |
| bool PrinterSemanticCapsAndDefaults::Paper::operator==( |
| const PrinterSemanticCapsAndDefaults::Paper& other) const { |
| return display_name_ == other.display_name_ && |
| vendor_id_ == other.vendor_id_ && size_um_ == other.size_um_ && |
| printable_area_um_ == other.printable_area_um_ && |
| max_height_um_ == other.max_height_um_ && |
| has_borderless_variant_ == other.has_borderless_variant_; |
| } |
| |
| bool PrinterSemanticCapsAndDefaults::Paper::SupportsCustomSize() const { |
| return max_height_um_ > 0; |
| } |
| |
| bool PrinterSemanticCapsAndDefaults::Paper::IsSizeWithinBounds( |
| const gfx::Size& other_um) const { |
| if (other_um == size_um_) { |
| return true; |
| } |
| |
| if (!SupportsCustomSize()) { |
| return false; |
| } |
| |
| return size_um_.width() == other_um.width() && |
| size_um_.height() <= other_um.height() && |
| other_um.height() <= max_height_um_; |
| } |
| |
| bool PrinterSemanticCapsAndDefaults::MediaType::operator==( |
| const PrinterSemanticCapsAndDefaults::MediaType& other) const { |
| return display_name == other.display_name && vendor_id == other.vendor_id; |
| } |
| |
| PrinterSemanticCapsAndDefaults::PrinterSemanticCapsAndDefaults() = default; |
| |
| PrinterSemanticCapsAndDefaults::PrinterSemanticCapsAndDefaults( |
| const PrinterSemanticCapsAndDefaults& other) = default; |
| |
| PrinterSemanticCapsAndDefaults::~PrinterSemanticCapsAndDefaults() = default; |
| |
| // This function is only supposed to be used in tests. The declaration in the |
| // header file is guarded by "#if defined(UNIT_TEST)" so that they can be used |
| // by tests but not non-test code. However, this .cc file is compiled as part of |
| // "backend" where "UNIT_TEST" is not defined. So we need to specify |
| // "COMPONENT_EXPORT(PRINT_BACKEND)" here again so that they are visible to |
| // tests. |
| COMPONENT_EXPORT(PRINT_BACKEND) |
| bool operator==(const PrinterSemanticCapsAndDefaults& caps1, |
| const PrinterSemanticCapsAndDefaults& caps2) { |
| return caps1.collate_capable == caps2.collate_capable && |
| caps1.collate_default == caps2.collate_default && |
| caps1.copies_max == caps2.copies_max && |
| caps1.duplex_modes == caps2.duplex_modes && |
| caps1.duplex_default == caps2.duplex_default && |
| caps1.color_changeable == caps2.color_changeable && |
| caps1.color_default == caps2.color_default && |
| caps1.color_model == caps2.color_model && |
| caps1.bw_model == caps2.bw_model && caps1.papers == caps2.papers && |
| caps1.user_defined_papers == caps2.user_defined_papers && |
| caps1.default_paper == caps2.default_paper && |
| caps1.dpis == caps2.dpis && caps1.default_dpi == caps2.default_dpi |
| #if BUILDFLAG(IS_CHROMEOS) |
| && caps1.pin_supported == caps2.pin_supported && |
| caps1.advanced_capabilities == caps2.advanced_capabilities |
| #endif // BUILDFLAG(IS_CHROMEOS) |
| #if BUILDFLAG(IS_WIN) |
| && caps1.page_output_quality == caps2.page_output_quality |
| #endif // BUILDFLAG(IS_WIN) |
| ; |
| } |
| |
| PrinterCapsAndDefaults::PrinterCapsAndDefaults() = default; |
| |
| PrinterCapsAndDefaults::PrinterCapsAndDefaults( |
| const PrinterCapsAndDefaults& other) = default; |
| |
| PrinterCapsAndDefaults::~PrinterCapsAndDefaults() = default; |
| |
| PrintBackend::PrintBackend() = default; |
| |
| PrintBackend::~PrintBackend() = default; |
| |
| // static |
| scoped_refptr<PrintBackend> PrintBackend::CreateInstance( |
| const std::string& locale) { |
| return g_print_backend_for_test ? g_print_backend_for_test |
| : PrintBackend::CreateInstanceImpl(locale); |
| } |
| |
| // static |
| void PrintBackend::SetPrintBackendForTesting(PrintBackend* backend) { |
| g_print_backend_for_test = backend; |
| } |
| |
| } // namespace printing |