printing/test_printing_context.cc

   1 // Copyright 2021 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "printing/test_printing_context.h"
   6
   7 #include <memory>
   8 #include <utility>
   9
  10 #include "base/check.h"
  11 #include "base/containers/flat_map.h"
  12 #include "base/notreached.h"
  13 #include "base/strings/utf_string_conversions.h"
  14 #include "build/build_config.h"
  15 #include "printing/backend/print_backend.h"
  16 #include "printing/buildflags/buildflags.h"
  17 #include "printing/mojom/print.mojom.h"
  18 #include "printing/print_settings.h"
  19 #include "printing/printing_context.h"
  20 #include "printing/units.h"
  21 #include "ui/gfx/geometry/size.h"
  22
  23 #if BUILDFLAG(IS_WIN)
  24 #include "printing/printed_page_win.h"
  25 #endif
  26
  27 namespace printing {
  28
  29 TestPrintingContextDelegate::TestPrintingContextDelegate() = default;
  30
  31 TestPrintingContextDelegate::~TestPrintingContextDelegate() = default;
  32
  33 gfx::NativeView TestPrintingContextDelegate::GetParentView() {
  34   return nullptr;
  35 }
  36
  37 std::string TestPrintingContextDelegate::GetAppLocale() {
  38   return std::string();
  39 }
  40
  41 TestPrintingContext::TestPrintingContext(Delegate* delegate,
  42                                          bool skip_system_calls)
  43     : PrintingContext(delegate) {
  44 #if BUILDFLAG(ENABLE_OOP_PRINTING)
  45   if (skip_system_calls)
  46     set_skip_system_calls();
  47 #endif
  48 }
  49
  50 TestPrintingContext::~TestPrintingContext() = default;
  51
  52 void TestPrintingContext::SetDeviceSettings(
  53     const std::string& device_name,
  54     std::unique_ptr<PrintSettings> settings) {
  55   device_settings_.emplace(device_name, std::move(settings));
  56 }
  57
  58 void TestPrintingContext::AskUserForSettings(int max_pages,
  59                                              bool has_selection,
  60                                              bool is_scripted,
  61                                              PrintSettingsCallback callback) {
  62   // Do not actually ask the user with a dialog, just pretend like user
  63   // made some kind of interaction.
  64   if (ask_user_for_settings_cancel_) {
  65     // Pretend the user hit the Cancel button.
  66     std::move(callback).Run(mojom::ResultCode::kCanceled);
  67     return;
  68   }
  69
  70   // Pretend the user selected the default printer and used the default
  71   // settings for it.
  72   scoped_refptr<PrintBackend> print_backend =
  73       PrintBackend::CreateInstance(/*locale=*/std::string());
  74   std::string printer_name;
  75   if (print_backend->GetDefaultPrinterName(printer_name) !=
  76       mojom::ResultCode::kSuccess) {
  77     std::move(callback).Run(mojom::ResultCode::kFailed);
  78     return;
  79   }
  80   auto found = device_settings_.find(printer_name);
  81   if (found == device_settings_.end()) {
  82     std::move(callback).Run(mojom::ResultCode::kFailed);
  83     return;
  84   }
  85   settings_ = std::make_unique<PrintSettings>(*found->second);
  86   std::move(callback).Run(mojom::ResultCode::kSuccess);
  87 }
  88
  89 mojom::ResultCode TestPrintingContext::UseDefaultSettings() {
  90   scoped_refptr<PrintBackend> print_backend =
  91       PrintBackend::CreateInstance(/*locale=*/std::string());
  92   if (use_default_settings_fails_)
  93     return mojom::ResultCode::kFailed;
  94
  95   std::string printer_name;
  96   mojom::ResultCode result = print_backend->GetDefaultPrinterName(printer_name);
  97   if (result != mojom::ResultCode::kSuccess)
  98     return result;
  99   auto found = device_settings_.find(printer_name);
 100   if (found == device_settings_.end())
 101     return mojom::ResultCode::kFailed;
 102   settings_ = std::make_unique<PrintSettings>(*found->second);
 103   return mojom::ResultCode::kSuccess;
 104 }
 105
 106 gfx::Size TestPrintingContext::GetPdfPaperSizeDeviceUnits() {
 107   // Default to A4 paper size, which is an alternative to Letter size that is
 108   // often used as the fallback size for some platform-specific
 109   // implementations.
 110   return gfx::Size(kA4WidthInch * settings_->device_units_per_inch(),
 111                    kA4HeightInch * settings_->device_units_per_inch());
 112 }
 113
 114 mojom::ResultCode TestPrintingContext::UpdatePrinterSettings(
 115     const PrinterSettings& printer_settings) {
 116   DCHECK(!in_print_job_);
 117 #if BUILDFLAG(IS_MAC)
 118   DCHECK(!printer_settings.external_preview) << "Not implemented";
 119 #endif
 120   DCHECK(!printer_settings.show_system_dialog) << "Not implemented";
 121
 122   // The printer name is to be embedded in the printing context's existing
 123   // settings.
 124   const std::string& device_name = base::UTF16ToUTF8(settings_->device_name());
 125   auto found = device_settings_.find(device_name);
 126   if (found == device_settings_.end()) {
 127     DLOG(ERROR) << "No such device found in test printing context: `"
 128                 << device_name << "`";
 129     return mojom::ResultCode::kFailed;
 130   }
 131
 132   // Perform some initialization, akin to various platform-specific actions in
 133   // `InitPrintSettings()`.
 134   DVLOG(1) << "Updating context settings for device `" << device_name << "`";
 135   std::unique_ptr<PrintSettings> existing_settings = std::move(settings_);
 136   settings_ = std::make_unique<PrintSettings>(*found->second);
 137   settings_->set_dpi(existing_settings->dpi());
 138 #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)
 139   for (const auto& item : existing_settings->advanced_settings())
 140     settings_->advanced_settings().emplace(item.first, item.second.Clone());
 141 #endif
 142
 143   return mojom::ResultCode::kSuccess;
 144 }
 145
 146 mojom::ResultCode TestPrintingContext::NewDocument(
 147     const std::u16string& document_name) {
 148   DCHECK(!in_print_job_);
 149
 150   if (!new_document_called_.is_null())
 151     new_document_called_.Run();
 152
 153   abort_printing_ = false;
 154   in_print_job_ = true;
 155
 156   if (!skip_system_calls() && new_document_blocked_by_permissions_)
 157     return mojom::ResultCode::kAccessDenied;
 158
 159   // No-op.
 160   return mojom::ResultCode::kSuccess;
 161 }
 162
 163 #if BUILDFLAG(IS_WIN)
 164 mojom::ResultCode TestPrintingContext::RenderPage(const PrintedPage& page,
 165                                                   const PageSetup& page_setup) {
 166   if (abort_printing_)
 167     return mojom::ResultCode::kCanceled;
 168   DCHECK(in_print_job_);
 169   DVLOG(1) << "Render page " << page.page_number();
 170
 171   if (render_page_blocked_by_permissions_)
 172     return mojom::ResultCode::kAccessDenied;
 173
 174   if (render_page_fail_for_page_number_.has_value() &&
 175       *render_page_fail_for_page_number_ == page.page_number()) {
 176     return mojom::ResultCode::kFailed;
 177   }
 178
 179   // No-op.
 180   return mojom::ResultCode::kSuccess;
 181 }
 182 #endif  // BUILDFLAG(IS_WIN)
 183
 184 mojom::ResultCode TestPrintingContext::PrintDocument(
 185     const MetafilePlayer& metafile,
 186     const PrintSettings& settings,
 187     uint32_t num_pages) {
 188   if (abort_printing_)
 189     return mojom::ResultCode::kCanceled;
 190   DCHECK(in_print_job_);
 191   DVLOG(1) << "Print document";
 192
 193   if (render_document_blocked_by_permissions_)
 194     return mojom::ResultCode::kAccessDenied;
 195
 196   // No-op.
 197   return mojom::ResultCode::kSuccess;
 198 }
 199
 200 mojom::ResultCode TestPrintingContext::DocumentDone() {
 201   DCHECK(in_print_job_);
 202   DVLOG(1) << "Document done";
 203
 204   if (document_done_blocked_by_permissions_)
 205     return mojom::ResultCode::kAccessDenied;
 206
 207   ResetSettings();
 208   return mojom::ResultCode::kSuccess;
 209 }
 210
 211 void TestPrintingContext::Cancel() {
 212   abort_printing_ = true;
 213   in_print_job_ = false;
 214   DVLOG(1) << "Canceling print job";
 215 }
 216 void TestPrintingContext::ReleaseContext() {}
 217
 218 printing::NativeDrawingContext TestPrintingContext::context() const {
 219   // No native context for test.
 220   return nullptr;
 221 }
 222
 223 #if BUILDFLAG(IS_WIN)
 224 mojom::ResultCode TestPrintingContext::InitWithSettingsForTest(
 225     std::unique_ptr<PrintSettings> settings) {
 226   NOTIMPLEMENTED();
 227   return mojom::ResultCode::kFailed;
 228 }
 229 #endif  // BUILDFLAG(IS_WIN)
 230
 231 }  // namespace printing