Google Git
Sign in
chromium / chromium / src / 02833e653c9b1f071d9b216d35d445a89d65d0fd / . / chrome / browser / ui / webui / print_preview / print_preview_handler.cc
blob: 9686cf252baf60ef70b56d1dce84c4ea9b846884 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ui/webui/print_preview/print_preview_handler.h"
#include <ctype.h>
#include <stddef.h>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include "base/base64.h"
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/command_line.h"
#include "base/containers/flat_map.h"
#include "base/feature_list.h"
#include "base/i18n/number_formatting.h"
#include "base/json/json_reader.h"
#include "base/lazy_instance.h"
#include "base/macros.h"
#include "base/memory/ref_counted_memory.h"
#include "base/metrics/histogram_macros.h"
#include "base/values.h"
#include "build/build_config.h"
#include "chrome/browser/app_mode/app_mode_utils.h"
#include "chrome/browser/bad_message.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/printing/background_printing_manager.h"
#include "chrome/browser/printing/print_dialog_cloud.h"
#include "chrome/browser/printing/print_error_dialog.h"
#include "chrome/browser/printing/print_job_manager.h"
#include "chrome/browser/printing/print_preview_dialog_controller.h"
#include "chrome/browser/printing/print_view_manager.h"
#include "chrome/browser/printing/printer_manager_dialog.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/signin/account_consistency_mode_manager.h"
#include "chrome/browser/signin/identity_manager_factory.h"
#include "chrome/browser/ui/browser_finder.h"
#include "chrome/browser/ui/browser_tabstrip.h"
#include "chrome/browser/ui/chrome_pages.h"
#include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
#include "chrome/browser/ui/webui/print_preview/pdf_printer_handler.h"
#include "chrome/browser/ui/webui/print_preview/policy_settings.h"
#include "chrome/browser/ui/webui/print_preview/print_preview_ui.h"
#include "chrome/browser/ui/webui/print_preview/printer_handler.h"
#include "chrome/browser/ui/webui/print_preview/sticky_settings.h"
#include "chrome/common/buildflags.h"
#include "chrome/common/chrome_features.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/cloud_print/cloud_print_constants.h"
#include "chrome/common/crash_keys.h"
#include "chrome/common/pref_names.h"
#include "chrome/common/webui_url_constants.h"
#include "components/cloud_devices/common/cloud_device_description.h"
#include "components/cloud_devices/common/cloud_devices_urls.h"
#include "components/cloud_devices/common/printer_description.h"
#include "components/prefs/pref_service.h"
#include "components/printing/browser/printer_capabilities.h"
#include "components/printing/common/cloud_print_cdd_conversion.h"
#include "components/printing/common/print_messages.h"
#include "components/signin/public/identity_manager/accounts_in_cookie_jar_info.h"
#include "components/signin/public/identity_manager/primary_account_access_token_fetcher.h"
#include "components/url_formatter/url_formatter.h"
#include "content/public/browser/browser_context.h"
#include "content/public/browser/render_frame_host.h"
#include "content/public/browser/render_process_host.h"
#include "content/public/browser/web_contents.h"
#include "content/public/browser/web_ui.h"
#include "google_apis/gaia/gaia_auth_util.h"
#include "net/base/url_util.h"
#include "printing/backend/print_backend.h"
#include "printing/backend/print_backend_consts.h"
#include "printing/buildflags/buildflags.h"
#include "printing/print_settings.h"
#include "third_party/icu/source/i18n/unicode/ulocdata.h"
#if defined(OS_CHROMEOS)
#include "chrome/browser/chromeos/account_manager/account_manager_util.h"
#include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
#include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
#include "chrome/browser/ui/settings_window_manager_chromeos.h"
#include "chrome/browser/ui/webui/signin/inline_login_handler_dialog_chromeos.h"
#include "chromeos/printing/printer_configuration.h"
#include "services/identity/public/cpp/scope_set.h"
#endif
using content::RenderFrameHost;
using content::WebContents;
namespace printing {
namespace {
// Max size for PDFs sent to Cloud Print. Server side limit is currently 80MB
// but PDF will double in size when sent to JS. See crbug.com/793506 and
// crbug.com/372240.
constexpr size_t kMaxCloudPrintPdfDataSizeInBytes = 80 * 1024 * 1024 / 2;
// This enum is used to back an UMA histogram, and should therefore be treated
// as append only.
enum UserActionBuckets {
PRINT_TO_PRINTER,
PRINT_TO_PDF,
CANCEL,
FALLBACK_TO_ADVANCED_SETTINGS_DIALOG,
PREVIEW_FAILED,
PREVIEW_STARTED,
INITIATOR_CRASHED_UNUSED,
INITIATOR_CLOSED,
PRINT_WITH_CLOUD_PRINT,
PRINT_WITH_PRIVET,
PRINT_WITH_EXTENSION,
OPEN_IN_MAC_PREVIEW,
PRINT_TO_GOOGLE_DRIVE,
USERACTION_BUCKET_BOUNDARY
};
// This enum is used to back an UMA histogram, and should therefore be treated
// as append only.
enum PrintSettingsBuckets {
LANDSCAPE = 0,
PORTRAIT,
COLOR,
BLACK_AND_WHITE,
COLLATE,
SIMPLEX,
DUPLEX,
TOTAL,
HEADERS_AND_FOOTERS,
CSS_BACKGROUND,
SELECTION_ONLY,
EXTERNAL_PDF_PREVIEW_UNUSED,
PAGE_RANGE,
DEFAULT_MEDIA,
NON_DEFAULT_MEDIA,
COPIES,
NON_DEFAULT_MARGINS,
DISTILL_PAGE_UNUSED,
SCALING,
PRINT_AS_IMAGE,
PAGES_PER_SHEET,
FIT_TO_PAGE,
DEFAULT_DPI,
NON_DEFAULT_DPI,
PIN,
PRINT_SETTINGS_BUCKET_BOUNDARY
};
// This enum is used to back an UMA histogram, and should therefore be treated
// as append only.
enum PrintDocumentTypeBuckets {
HTML_DOCUMENT = 0,
PDF_DOCUMENT,
PRINT_DOCUMENT_TYPE_BUCKET_BOUNDARY
};
void ReportUserActionHistogram(UserActionBuckets event) {
UMA_HISTOGRAM_ENUMERATION("PrintPreview.UserAction", event,
USERACTION_BUCKET_BOUNDARY);
}
void ReportPrintSettingHistogram(PrintSettingsBuckets setting) {
UMA_HISTOGRAM_ENUMERATION("PrintPreview.PrintSettings", setting,
PRINT_SETTINGS_BUCKET_BOUNDARY);
}
void ReportPrintDocumentTypeAndSizeHistograms(PrintDocumentTypeBuckets doctype,
size_t average_page_size_in_kb) {
UMA_HISTOGRAM_ENUMERATION("PrintPreview.PrintDocumentType", doctype,
PRINT_DOCUMENT_TYPE_BUCKET_BOUNDARY);
switch (doctype) {
case HTML_DOCUMENT:
UMA_HISTOGRAM_MEMORY_KB("PrintPreview.PrintDocumentSize.HTML",
average_page_size_in_kb);
break;
case PDF_DOCUMENT:
UMA_HISTOGRAM_MEMORY_KB("PrintPreview.PrintDocumentSize.PDF",
average_page_size_in_kb);
break;
default:
NOTREACHED();
break;
}
}
PrinterType GetPrinterTypeForUserAction(UserActionBuckets user_action) {
switch (user_action) {
case PRINT_WITH_PRIVET:
return PrinterType::kPrivetPrinter;
case PRINT_WITH_EXTENSION:
return PrinterType::kExtensionPrinter;
case PRINT_TO_PDF:
return PrinterType::kPdfPrinter;
case PRINT_TO_PRINTER:
case FALLBACK_TO_ADVANCED_SETTINGS_DIALOG:
case OPEN_IN_MAC_PREVIEW:
return PrinterType::kLocalPrinter;
default:
NOTREACHED();
return PrinterType::kLocalPrinter;
}
}
base::Value GetErrorValue(UserActionBuckets user_action,
base::StringPiece description) {
return user_action == PRINT_WITH_PRIVET ? base::Value(-1)
: base::Value(description);
}
// Dictionary Fields for Print Preview initial settings. Keep in sync with
// field names for print_preview.NativeInitialSettings in
// chrome/browser/resources/print_preview/native_layer.js
//
// Name of a dictionary field specifying whether to print automatically in
// kiosk mode. See http://crbug.com/31395.
const char kIsInKioskAutoPrintMode[] = "isInKioskAutoPrintMode";
// Dictionary field to indicate whether Chrome is running in forced app (app
// kiosk) mode. It's not the same as desktop Chrome kiosk (the one above).
const char kIsInAppKioskMode[] = "isInAppKioskMode";
// Name of a dictionary field holding the UI locale.
const char kUiLocale[] = "uiLocale";
// Name of a dictionary field holding the thousands delimiter according to the
// locale.
const char kThousandsDelimiter[] = "thousandsDelimiter";
// Name of a dictionary field holding the decimal delimiter according to the
// locale.
const char kDecimalDelimiter[] = "decimalDelimiter";
// Name of a dictionary field holding the measurement system according to the
// locale.
const char kUnitType[] = "unitType";
// Name of a dictionary field holding the initiator title.
const char kDocumentTitle[] = "documentTitle";
// Name of a dictionary field holding the state of selection for document.
const char kDocumentHasSelection[] = "documentHasSelection";
// Name of a dictionary field holding saved print preview state
const char kAppState[] = "serializedAppStateStr";
// Name of a dictionary field holding the default destination selection rules.
const char kDefaultDestinationSelectionRules[] =
"serializedDefaultDestinationSelectionRulesStr";
// Name of a dictionary pref holding the default value for the header/footer
// checkbox. If set, takes priority over sticky settings.
const char kHeaderFooter[] = "headerFooter";
// Name of a dictionary field telling us whether the kPrintHeaderFooter pref is
// managed by an enterprise policy.
const char kIsHeaderFooterManaged[] = "isHeaderFooterManaged";
// Name of a dictionary field holding the cloud print URL.
const char kCloudPrintURL[] = "cloudPrintURL";
// Name of a dictionary field holding the signed in user accounts.
const char kUserAccounts[] = "userAccounts";
// Name of a dictionary field indicating whether sync is available. If false,
// Print Preview will always send a request to the Google Cloud Print server on
// load, to check the user's sign in state.
const char kSyncAvailable[] = "syncAvailable";
// Get the print job settings dictionary from |json_str|.
// Returns |base::Value()| on failure.
base::Value GetSettingsDictionary(const std::string& json_str) {
base::Optional<base::Value> settings = base::JSONReader::Read(json_str);
if (!settings || !settings->is_dict()) {
NOTREACHED() << "Print job settings must be a dictionary.";
return base::Value();
}
if (settings->DictEmpty()) {
NOTREACHED() << "Print job settings dictionary is empty";
return base::Value();
}
return std::move(*settings);
}
// Track the popularity of print settings and report the stats.
void ReportPrintSettingsStats(const base::Value& print_settings,
const base::Value& preview_settings,
bool is_pdf) {
ReportPrintSettingHistogram(TOTAL);
// Print settings can be categorized into 2 groups: settings that are applied
// via preview generation (page range, selection, headers/footers, background
// graphics, scaling, layout, page size, pages per sheet, fit to page,
// margins, rasterize), and settings that are applied at the printer (color,
// duplex, copies, collate, dpi). The former should be captured from the most
// recent preview request, as some of them are set to dummy values in the
// print ticket. Similarly, settings applied at the printer should be pulled
// from the print ticket, as they may have dummy values in the preview
// request.
const base::Value* page_range_array =
preview_settings.FindKey(kSettingPageRange);
if (page_range_array && page_range_array->is_list() &&
!page_range_array->GetList().empty()) {
ReportPrintSettingHistogram(PAGE_RANGE);
}
const base::Value* media_size_value =
preview_settings.FindKey(kSettingMediaSize);
if (media_size_value && media_size_value->is_dict() &&
!media_size_value->DictEmpty()) {
if (media_size_value->FindBoolKey(kSettingMediaSizeIsDefault)
.value_or(false)) {
ReportPrintSettingHistogram(DEFAULT_MEDIA);
} else {
ReportPrintSettingHistogram(NON_DEFAULT_MEDIA);
}
}
base::Optional<bool> landscape_opt =
preview_settings.FindBoolKey(kSettingLandscape);
if (landscape_opt)
ReportPrintSettingHistogram(landscape_opt.value() ? LANDSCAPE : PORTRAIT);
if (print_settings.FindIntKey(kSettingCopies).value_or(1) > 1)
ReportPrintSettingHistogram(COPIES);
if (preview_settings.FindIntKey(kSettingScaleFactor).value_or(100) != 100)
ReportPrintSettingHistogram(SCALING);
if (preview_settings.FindIntKey(kSettingPagesPerSheet).value_or(1) != 1)
ReportPrintSettingHistogram(PAGES_PER_SHEET);
if (print_settings.FindBoolKey(kSettingCollate).value_or(false))
ReportPrintSettingHistogram(COLLATE);
base::Optional<int> duplex_mode_opt =
print_settings.FindIntKey(kSettingDuplexMode);
if (duplex_mode_opt)
ReportPrintSettingHistogram(duplex_mode_opt.value() ? DUPLEX : SIMPLEX);
base::Optional<int> color_mode_opt = print_settings.FindIntKey(kSettingColor);
if (color_mode_opt) {
ReportPrintSettingHistogram(
IsColorModelSelected(color_mode_opt.value()) ? COLOR : BLACK_AND_WHITE);
}
if (preview_settings.FindIntKey(kSettingMarginsType).value_or(0) != 0)
ReportPrintSettingHistogram(NON_DEFAULT_MARGINS);
if (preview_settings.FindBoolKey(kSettingHeaderFooterEnabled).value_or(false))
ReportPrintSettingHistogram(HEADERS_AND_FOOTERS);
if (preview_settings.FindBoolKey(kSettingShouldPrintBackgrounds)
.value_or(false)) {
ReportPrintSettingHistogram(CSS_BACKGROUND);
}
if (preview_settings.FindBoolKey(kSettingShouldPrintSelectionOnly)
.value_or(false)) {
ReportPrintSettingHistogram(SELECTION_ONLY);
}
if (preview_settings.FindBoolKey(kSettingRasterizePdf).value_or(false))
ReportPrintSettingHistogram(PRINT_AS_IMAGE);
if (is_pdf &&
preview_settings.FindBoolKey(kSettingFitToPageEnabled).value_or(false)) {
ReportPrintSettingHistogram(FIT_TO_PAGE);
}
if (print_settings.FindIntKey(kSettingDpiHorizontal).value_or(0) > 0 &&
print_settings.FindIntKey(kSettingDpiVertical).value_or(0) > 0) {
base::Optional<bool> is_default_opt =
print_settings.FindBoolKey(kSettingDpiDefault);
if (is_default_opt) {
ReportPrintSettingHistogram(is_default_opt.value() ? DEFAULT_DPI
: NON_DEFAULT_DPI);
}
}
#if defined(OS_CHROMEOS)
if (print_settings.FindStringKey(kSettingPinValue))
ReportPrintSettingHistogram(PIN);
#endif // defined(OS_CHROMEOS)
}
UserActionBuckets DetermineUserAction(const base::Value& settings) {
#if defined(OS_MACOSX)
if (settings.FindKey(kSettingOpenPDFInPreview))
return OPEN_IN_MAC_PREVIEW;
#endif
// This needs to be checked before checking for a cloud print ID, since a
// print ticket for printing to Drive will also contain a cloud print ID.
if (settings.FindBoolKey(kSettingPrintToGoogleDrive).value_or(false))
return PRINT_TO_GOOGLE_DRIVE;
if (settings.FindKey(kSettingCloudPrintId))
return PRINT_WITH_CLOUD_PRINT;
PrinterType type = static_cast<PrinterType>(
settings.FindIntKey(kSettingPrinterType).value());
switch (type) {
case kPrivetPrinter:
return PRINT_WITH_PRIVET;
case kExtensionPrinter:
return PRINT_WITH_EXTENSION;
case kPdfPrinter:
return PRINT_TO_PDF;
case kLocalPrinter:
break;
default:
NOTREACHED();
break;
}
if (settings.FindBoolKey(kSettingShowSystemDialog).value_or(false))
return FALLBACK_TO_ADVANCED_SETTINGS_DIALOG;
return PRINT_TO_PRINTER;
}
base::LazyInstance<StickySettings>::DestructorAtExit g_sticky_settings =
LAZY_INSTANCE_INITIALIZER;
StickySettings* GetStickySettings() {
return g_sticky_settings.Pointer();
}
} // namespace
#if defined(OS_CHROMEOS)
class PrintPreviewHandler::AccessTokenService
: public OAuth2AccessTokenManager::Consumer {
public:
AccessTokenService() : OAuth2AccessTokenManager::Consumer("print_preview") {}
void RequestToken(base::OnceCallback<void(const std::string&)> callback) {
// There can only be one pending request at a time. See
// cloud_print_interface_js.js.
const identity::ScopeSet scopes{cloud_devices::kCloudPrintAuthScope};
DCHECK(!device_request_callback_);
chromeos::DeviceOAuth2TokenService* token_service =
chromeos::DeviceOAuth2TokenServiceFactory::Get();
std::string account_id = token_service->GetRobotAccountId();
device_request_ =
token_service->StartAccessTokenRequest(account_id, scopes, this);
device_request_callback_ = std::move(callback);
}
void OnGetTokenSuccess(
const OAuth2AccessTokenManager::Request* request,
const OAuth2AccessTokenConsumer::TokenResponse& token_response) override {
OnServiceResponse(request, token_response.access_token);
}
void OnGetTokenFailure(const OAuth2AccessTokenManager::Request* request,
const GoogleServiceAuthError& error) override {
OnServiceResponse(request, std::string());
}
private:
void OnServiceResponse(const OAuth2AccessTokenManager::Request* request,
const std::string& access_token) {
DCHECK_EQ(request, device_request_.get());
std::move(device_request_callback_).Run(access_token);
device_request_.reset();
}
std::unique_ptr<OAuth2AccessTokenManager::Request> device_request_;
base::OnceCallback<void(const std::string&)> device_request_callback_;
DISALLOW_COPY_AND_ASSIGN(AccessTokenService);
};
#endif // defined(OS_CHROMEOS)
PrintPreviewHandler::PrintPreviewHandler()
: regenerate_preview_request_count_(0),
manage_printers_dialog_request_count_(0),
reported_failed_preview_(false),
has_logged_printers_count_(false),
identity_manager_(nullptr) {
ReportUserActionHistogram(PREVIEW_STARTED);
}
PrintPreviewHandler::~PrintPreviewHandler() {
UMA_HISTOGRAM_COUNTS_1M("PrintPreview.ManagePrinters",
manage_printers_dialog_request_count_);
UnregisterForGaiaCookieChanges();
}
void PrintPreviewHandler::RegisterMessages() {
web_ui()->RegisterMessageCallback(
"getPrinters",
base::BindRepeating(&PrintPreviewHandler::HandleGetPrinters,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"getPreview", base::BindRepeating(&PrintPreviewHandler::HandleGetPreview,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"print", base::BindRepeating(&PrintPreviewHandler::HandlePrint,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"getPrinterCapabilities",
base::BindRepeating(&PrintPreviewHandler::HandleGetPrinterCapabilities,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"setupPrinter",
base::BindRepeating(&PrintPreviewHandler::HandlePrinterSetup,
base::Unretained(this)));
#if BUILDFLAG(ENABLE_BASIC_PRINT_DIALOG)
web_ui()->RegisterMessageCallback(
"showSystemDialog",
base::BindRepeating(&PrintPreviewHandler::HandleShowSystemDialog,
base::Unretained(this)));
#endif
web_ui()->RegisterMessageCallback(
"signIn", base::BindRepeating(&PrintPreviewHandler::HandleSignin,
base::Unretained(this)));
#if defined(OS_CHROMEOS)
web_ui()->RegisterMessageCallback(
"getAccessToken",
base::BindRepeating(&PrintPreviewHandler::HandleGetAccessToken,
base::Unretained(this)));
#endif
web_ui()->RegisterMessageCallback(
"closePrintPreviewDialog",
base::BindRepeating(&PrintPreviewHandler::HandleClosePreviewDialog,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"hidePreview",
base::BindRepeating(&PrintPreviewHandler::HandleHidePreview,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"cancelPendingPrintRequest",
base::BindRepeating(&PrintPreviewHandler::HandleCancelPendingPrintRequest,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"saveAppState",
base::BindRepeating(&PrintPreviewHandler::HandleSaveAppState,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"getInitialSettings",
base::BindRepeating(&PrintPreviewHandler::HandleGetInitialSettings,
base::Unretained(this)));
web_ui()->RegisterMessageCallback(
"grantExtensionPrinterAccess",
base::BindRepeating(
&PrintPreviewHandler::HandleGrantExtensionPrinterAccess,
base::Unretained(this)));
#if defined(OS_CHROMEOS)
web_ui()->RegisterMessageCallback(
"openPrinterSettings",
base::BindRepeating(&PrintPreviewHandler::HandleOpenPrinterSettings,
base::Unretained(this)));
#endif
}
void PrintPreviewHandler::OnJavascriptAllowed() {
print_preview_ui()->SetPreviewUIId();
// Now that the UI is initialized, any future account changes will require
// a printer list refresh.
RegisterForGaiaCookieChanges();
}
void PrintPreviewHandler::OnJavascriptDisallowed() {
// Normally the handler and print preview will be destroyed together, but
// this is necessary for refresh or navigation from the chrome://print page.
weak_factory_.InvalidateWeakPtrs();
print_preview_ui()->ClearPreviewUIId();
preview_callbacks_.clear();
preview_failures_.clear();
UnregisterForGaiaCookieChanges();
}
WebContents* PrintPreviewHandler::preview_web_contents() const {
return web_ui()->GetWebContents();
}
PrefService* PrintPreviewHandler::GetPrefs() const {
auto* prefs = Profile::FromWebUI(web_ui())->GetPrefs();
DCHECK(prefs);
return prefs;
}
PrintPreviewUI* PrintPreviewHandler::print_preview_ui() const {
return static_cast<PrintPreviewUI*>(web_ui()->GetController());
}
bool PrintPreviewHandler::ShouldReceiveRendererMessage(int request_id) {
if (!IsJavascriptAllowed()) {
BadMessageReceived();
return false;
}
if (!base::Contains(preview_callbacks_, request_id)) {
BadMessageReceived();
return false;
}
return true;
}
std::string PrintPreviewHandler::GetCallbackId(int request_id) {
std::string result;
if (!IsJavascriptAllowed()) {
BadMessageReceived();
return result;
}
auto it = preview_callbacks_.find(request_id);
if (it == preview_callbacks_.end()) {
BadMessageReceived();
return result;
}
result = it->second;
preview_callbacks_.erase(it);
return result;
}
void PrintPreviewHandler::HandleGetPrinters(const base::ListValue* args) {
std::string callback_id;
CHECK(args->GetString(0, &callback_id));
CHECK(!callback_id.empty());
int type;
CHECK(args->GetInteger(1, &type));
PrinterType printer_type = static_cast<PrinterType>(type);
PrinterHandler* handler = GetPrinterHandler(printer_type);
if (!handler) {
RejectJavascriptCallback(base::Value(callback_id), base::Value());
return;
}
// Make sure all in progress requests are canceled before new printer search
// starts.
handler->Reset();
handler->StartGetPrinters(
base::BindRepeating(&PrintPreviewHandler::OnAddedPrinters,
weak_factory_.GetWeakPtr(), printer_type),
base::BindOnce(&PrintPreviewHandler::OnGetPrintersDone,
weak_factory_.GetWeakPtr(), callback_id));
}
void PrintPreviewHandler::HandleGrantExtensionPrinterAccess(
const base::ListValue* args) {
std::string callback_id;
std::string printer_id;
bool ok = args->GetString(0, &callback_id) &&
args->GetString(1, &printer_id) && !callback_id.empty();
DCHECK(ok);
GetPrinterHandler(PrinterType::kExtensionPrinter)
->StartGrantPrinterAccess(
printer_id,
base::BindOnce(&PrintPreviewHandler::OnGotExtensionPrinterInfo,
weak_factory_.GetWeakPtr(), callback_id));
}
void PrintPreviewHandler::HandleGetPrinterCapabilities(
const base::ListValue* args) {
std::string callback_id;
std::string printer_name;
int type;
if (!args->GetString(0, &callback_id) || !args->GetString(1, &printer_name) ||
!args->GetInteger(2, &type) || callback_id.empty() ||
printer_name.empty()) {
RejectJavascriptCallback(base::Value(callback_id), base::Value());
return;
}
PrinterType printer_type = static_cast<PrinterType>(type);
PrinterHandler* handler = GetPrinterHandler(printer_type);
if (!handler) {
RejectJavascriptCallback(base::Value(callback_id), base::Value());
return;
}
handler->StartGetCapability(
printer_name,
base::BindOnce(&PrintPreviewHandler::SendPrinterCapabilities,
weak_factory_.GetWeakPtr(), callback_id));
}
void PrintPreviewHandler::HandleGetPreview(const base::ListValue* args) {
DCHECK_EQ(2U, args->GetSize());
std::string callback_id;
std::string json_str;
// All of the conditions below should be guaranteed by the print preview
// javascript.
args->GetString(0, &callback_id);
CHECK(!callback_id.empty());
args->GetString(1, &json_str);
base::Value settings = GetSettingsDictionary(json_str);
CHECK(settings.is_dict());
int request_id = settings.FindIntKey(kPreviewRequestID).value();
CHECK_GT(request_id, -1);
CHECK(!base::Contains(preview_callbacks_, request_id));
preview_callbacks_[request_id] = callback_id;
print_preview_ui()->OnPrintPreviewRequest(request_id);
// Add an additional key in order to identify |print_preview_ui| later on
// when calling PrintPreviewUI::ShouldCancelRequest() on the IO thread.
settings.SetKey(
kPreviewUIID,
base::Value(print_preview_ui()->GetIDForPrintPreviewUI().value()));
// Increment request count.
++regenerate_preview_request_count_;
WebContents* initiator = GetInitiator();
RenderFrameHost* rfh =
initiator
? PrintViewManager::FromWebContents(initiator)->print_preview_rfh()
: nullptr;
if (!rfh) {
ReportUserActionHistogram(INITIATOR_CLOSED);
print_preview_ui()->OnClosePrintPreviewDialog();
return;
}
// Retrieve the page title and url and send it to the renderer process if
// headers and footers are to be displayed.
base::Optional<bool> display_header_footer_opt =
settings.FindBoolKey(kSettingHeaderFooterEnabled);
DCHECK(display_header_footer_opt);
if (display_header_footer_opt.value_or(false)) {
settings.SetKey(kSettingHeaderFooterTitle,
base::Value(initiator->GetTitle()));
url::Replacements<char> url_sanitizer;
url_sanitizer.ClearUsername();
url_sanitizer.ClearPassword();
const GURL& initiator_url = initiator->GetLastCommittedURL();
settings.SetKey(kSettingHeaderFooterURL,
base::Value(url_formatter::FormatUrl(
initiator_url.ReplaceComponents(url_sanitizer))));
}
VLOG(1) << "Print preview request start";
rfh->Send(new PrintMsg_PrintPreview(
rfh->GetRoutingID(), static_cast<base::DictionaryValue&>(settings)));
last_preview_settings_ = std::move(settings);
}
void PrintPreviewHandler::HandlePrint(const base::ListValue* args) {
// Record the number of times the user requests to regenerate preview data
// before printing.
UMA_HISTOGRAM_COUNTS_1M("PrintPreview.RegeneratePreviewRequest.BeforePrint",
regenerate_preview_request_count_);
std::string callback_id;
CHECK(args->GetString(0, &callback_id));
CHECK(!callback_id.empty());
std::string json_str;
CHECK(args->GetString(1, &json_str));
base::Value settings = GetSettingsDictionary(json_str);
if (!settings.is_dict()) {
RejectJavascriptCallback(base::Value(callback_id), base::Value(-1));
return;
}
const UserActionBuckets user_action = DetermineUserAction(settings);
int page_count = settings.FindIntKey(kSettingPreviewPageCount).value_or(-1);
if (page_count <= 0) {
RejectJavascriptCallback(base::Value(callback_id),
GetErrorValue(user_action, "NO_PAGE_COUNT"));
return;
}
scoped_refptr<base::RefCountedMemory> data;
print_preview_ui()->GetPrintPreviewDataForIndex(
COMPLETE_PREVIEW_DOCUMENT_INDEX, &data);
if (!data) {
// Nothing to print, no preview available.
RejectJavascriptCallback(base::Value(callback_id),
GetErrorValue(user_action, "NO_DATA"));
return;
}
DCHECK(data->size());
DCHECK(data->front());
// After validating |settings|, record metrics.
bool is_pdf = !print_preview_ui()->source_is_modifiable();
if (last_preview_settings_.is_dict())
ReportPrintSettingsStats(settings, last_preview_settings_, is_pdf);
{
PrintDocumentTypeBuckets doc_type = is_pdf ? PDF_DOCUMENT : HTML_DOCUMENT;
size_t average_page_size_in_kb = data->size() / page_count;
average_page_size_in_kb /= 1024;
ReportPrintDocumentTypeAndSizeHistograms(doc_type, average_page_size_in_kb);
}
ReportUserActionHistogram(user_action);
if (user_action == PRINT_WITH_CLOUD_PRINT ||
user_action == PRINT_TO_GOOGLE_DRIVE) {
// Does not send the title like the other printer handler types below,
// because JS already has the document title from the initial settings.
SendCloudPrintJob(callback_id, data.get());
return;
}
PrinterHandler* handler =
GetPrinterHandler(GetPrinterTypeForUserAction(user_action));
handler->StartPrint(print_preview_ui()->initiator_title(),
std::move(settings), data,
base::BindOnce(&PrintPreviewHandler::OnPrintResult,
weak_factory_.GetWeakPtr(), callback_id));
}
void PrintPreviewHandler::HandleHidePreview(const base::ListValue* /*args*/) {
print_preview_ui()->OnHidePreviewDialog();
}
void PrintPreviewHandler::HandleCancelPendingPrintRequest(
const base::ListValue* /*args*/) {
WebContents* initiator = GetInitiator();
if (initiator)
ClearInitiatorDetails();
ShowPrintErrorDialog();
}
void PrintPreviewHandler::HandleSaveAppState(const base::ListValue* args) {
std::string data_to_save;
StickySettings* sticky_settings = GetStickySettings();
if (args->GetString(0, &data_to_save) && !data_to_save.empty())
sticky_settings->StoreAppState(data_to_save);
sticky_settings->SaveInPrefs(GetPrefs());
}
// |args| is expected to contain a string with representing the callback id
// followed by a list of arguments the first of which should be the printer id.
void PrintPreviewHandler::HandlePrinterSetup(const base::ListValue* args) {
std::string callback_id;
std::string printer_name;
if (!args->GetString(0, &callback_id) || !args->GetString(1, &printer_name) ||
callback_id.empty() || printer_name.empty()) {
RejectJavascriptCallback(base::Value(callback_id),
base::Value(printer_name));
return;
}
GetPrinterHandler(PrinterType::kLocalPrinter)
->StartGetCapability(
printer_name, base::BindOnce(&PrintPreviewHandler::SendPrinterSetup,
weak_factory_.GetWeakPtr(), callback_id,
printer_name));
}
void PrintPreviewHandler::HandleSignin(const base::ListValue* args) {
bool add_account = false;
CHECK(args->GetBoolean(0, &add_account));
Profile* profile = Profile::FromWebUI(web_ui());
DCHECK(profile);
#if defined(OS_CHROMEOS)
if (chromeos::IsAccountManagerAvailable(profile)) {
// Chrome OS Account Manager is enabled on this Profile and hence, all
// account management flows will go through native UIs and not through a
// tabbed browser window.
if (add_account) {
chromeos::InlineLoginHandlerDialogChromeOS::Show();
} else {
chrome::SettingsWindowManager::GetInstance()->ShowOSSettings(
profile, chrome::kAccountManagerSubPage);
}
return;
}
#endif
chrome::ScopedTabbedBrowserDisplayer displayer(profile);
print_dialog_cloud::CreateCloudPrintSigninTab(
displayer.browser(), add_account,
base::BindOnce(&PrintPreviewHandler::OnSignInTabClosed,
weak_factory_.GetWeakPtr()));
}
void PrintPreviewHandler::OnSignInTabClosed() {
if (identity_manager_) {
// Sign in state will be reported in OnAccountsInCookieJarUpdated, so no
// need to do anything here.
return;
}
FireWebUIListener("check-for-account-update");
}
#if defined(OS_CHROMEOS)
void PrintPreviewHandler::HandleGetAccessToken(const base::ListValue* args) {
std::string callback_id;
bool ok = args->GetString(0, &callback_id) && !callback_id.empty();
DCHECK(ok);
if (!token_service_)
token_service_ = std::make_unique<AccessTokenService>();
token_service_->RequestToken(
base::BindOnce(&PrintPreviewHandler::SendAccessToken,
weak_factory_.GetWeakPtr(), callback_id));
}
#endif
#if BUILDFLAG(ENABLE_BASIC_PRINT_DIALOG)
void PrintPreviewHandler::HandleShowSystemDialog(
const base::ListValue* /*args*/) {
manage_printers_dialog_request_count_++;
ReportUserActionHistogram(FALLBACK_TO_ADVANCED_SETTINGS_DIALOG);
WebContents* initiator = GetInitiator();
if (!initiator)
return;
auto* print_view_manager = PrintViewManager::FromWebContents(initiator);
print_view_manager->PrintForSystemDialogNow(base::BindOnce(
&PrintPreviewHandler::ClosePreviewDialog, weak_factory_.GetWeakPtr()));
// Cancel the pending preview request if exists.
print_preview_ui()->OnCancelPendingPreviewRequest();
}
#endif
void PrintPreviewHandler::HandleClosePreviewDialog(
const base::ListValue* /*args*/) {
ReportUserActionHistogram(CANCEL);
// Record the number of times the user requests to regenerate preview data
// before cancelling.
UMA_HISTOGRAM_COUNTS_1M("PrintPreview.RegeneratePreviewRequest.BeforeCancel",
regenerate_preview_request_count_);
}
#if defined(OS_CHROMEOS)
void PrintPreviewHandler::HandleOpenPrinterSettings(
const base::ListValue* args) {
chrome::SettingsWindowManager::GetInstance()->ShowOSSettings(
Profile::FromWebUI(web_ui()), chrome::kNativePrintingSettingsSubPage);
}
#endif
void PrintPreviewHandler::GetLocaleInformation(base::Value* settings) {
// Getting the measurement system based on the locale.
UErrorCode errorCode = U_ZERO_ERROR;
const char* locale = g_browser_process->GetApplicationLocale().c_str();
settings->SetStringKey(kUiLocale, std::string(locale));
UMeasurementSystem system = ulocdata_getMeasurementSystem(locale, &errorCode);
// On error, assume the units are SI.
// Since the only measurement units print preview's WebUI cares about are
// those for measuring distance, assume anything non-US is SI.
if (errorCode > U_ZERO_ERROR || system != UMS_US)
system = UMS_SI;
// Getting the number formatting based on the locale and writing to
// dictionary.
base::string16 number_format = base::FormatDouble(123456.78, 2);
size_t thousands_pos = number_format.find('3') + 1;
base::string16 thousands_delimiter = number_format.substr(thousands_pos, 1);
if (number_format[thousands_pos] == '4')
thousands_delimiter.clear();
size_t decimal_pos = number_format.find('6') + 1;
DCHECK_NE(number_format[decimal_pos], '7');
base::string16 decimal_delimiter = number_format.substr(decimal_pos, 1);
settings->SetStringKey(kDecimalDelimiter, decimal_delimiter);
settings->SetStringKey(kThousandsDelimiter, thousands_delimiter);
settings->SetIntKey(kUnitType, system);
}
void PrintPreviewHandler::HandleGetInitialSettings(
const base::ListValue* args) {
std::string callback_id;
CHECK(args->GetString(0, &callback_id));
CHECK(!callback_id.empty());
AllowJavascript();
GetPrinterHandler(PrinterType::kLocalPrinter)
->GetDefaultPrinter(
base::BindOnce(&PrintPreviewHandler::SendInitialSettings,
weak_factory_.GetWeakPtr(), callback_id));
}
void PrintPreviewHandler::GetUserAccountList(base::Value* settings) {
base::Value account_list(base::Value::Type::LIST);
if (identity_manager_) {
const std::vector<gaia::ListedAccount>& accounts =
identity_manager_->GetAccountsInCookieJar().signed_in_accounts;
for (const gaia::ListedAccount& account : accounts) {
account_list.Append(account.email);
}
settings->SetKey(kSyncAvailable, base::Value(true));
} else {
settings->SetKey(kSyncAvailable, base::Value(false));
}
settings->SetKey(kUserAccounts, std::move(account_list));
}
void PrintPreviewHandler::SendInitialSettings(
const std::string& callback_id,
const std::string& default_printer) {
base::Value initial_settings(base::Value::Type::DICTIONARY);
initial_settings.SetStringKey(kDocumentTitle,
print_preview_ui()->initiator_title());
initial_settings.SetBoolKey(kSettingPreviewModifiable,
print_preview_ui()->source_is_modifiable());
initial_settings.SetBoolKey(kSettingPreviewIsPdf,
print_preview_ui()->source_is_pdf());
initial_settings.SetStringKey(kSettingPrinterName, default_printer);
initial_settings.SetBoolKey(kDocumentHasSelection,
print_preview_ui()->source_has_selection());
initial_settings.SetBoolKey(kSettingShouldPrintSelectionOnly,
print_preview_ui()->print_selection_only());
PrefService* prefs = GetPrefs();
StickySettings* sticky_settings = GetStickySettings();
sticky_settings->RestoreFromPrefs(prefs);
if (sticky_settings->printer_app_state()) {
initial_settings.SetStringKey(kAppState,
*sticky_settings->printer_app_state());
} else {
initial_settings.SetKey(kAppState, base::Value());
}
if (prefs->HasPrefPath(prefs::kPrintHeaderFooter)) {
// Don't override sticky settings, unless kPrintHeaderFooter is actually
// customized.
initial_settings.SetBoolKey(kHeaderFooter,
prefs->GetBoolean(prefs::kPrintHeaderFooter));
}
if (IsCloudPrintEnabled() &&
!base::FeatureList::IsEnabled(features::kCloudPrinterHandler)) {
initial_settings.SetStringKey(
kCloudPrintURL, GURL(cloud_devices::GetCloudPrintURL()).spec());
}
initial_settings.SetBoolKey(
kIsHeaderFooterManaged,
prefs->IsManagedPreference(prefs::kPrintHeaderFooter));
base::CommandLine* cmdline = base::CommandLine::ForCurrentProcess();
initial_settings.SetBoolKey(kIsInKioskAutoPrintMode,
cmdline->HasSwitch(switches::kKioskModePrinting));
initial_settings.SetBoolKey(kIsInAppKioskMode,
chrome::IsRunningInForcedAppMode());
const std::string rules_str =
prefs->GetString(prefs::kPrintPreviewDefaultDestinationSelectionRules);
if (rules_str.empty()) {
initial_settings.SetKey(kDefaultDestinationSelectionRules, base::Value());
} else {
initial_settings.SetStringKey(kDefaultDestinationSelectionRules, rules_str);
}
GetLocaleInformation(&initial_settings);
if (IsCloudPrintEnabled()) {
GetUserAccountList(&initial_settings);
}
ResolveJavascriptCallback(base::Value(callback_id), initial_settings);
}
void PrintPreviewHandler::ClosePreviewDialog() {
print_preview_ui()->OnClosePrintPreviewDialog();
}
#if defined(OS_CHROMEOS)
void PrintPreviewHandler::SendAccessToken(const std::string& callback_id,
const std::string& access_token) {
VLOG(1) << "Get getAccessToken finished";
ResolveJavascriptCallback(base::Value(callback_id),
base::Value(access_token));
}
#endif
void PrintPreviewHandler::SendPrinterCapabilities(
const std::string& callback_id,
base::Value settings_info) {
// Check that |settings_info| is valid.
if (settings_info.is_dict() &&
settings_info.FindKeyOfType(kSettingCapabilities,
base::Value::Type::DICTIONARY)) {
VLOG(1) << "Get printer capabilities finished";
ResolveJavascriptCallback(base::Value(callback_id), settings_info);
return;
}
VLOG(1) << "Get printer capabilities failed";
RejectJavascriptCallback(base::Value(callback_id), base::Value());
}
void PrintPreviewHandler::SendPrinterSetup(const std::string& callback_id,
const std::string& printer_name,
base::Value destination_info) {
base::Value response(base::Value::Type::DICTIONARY);
base::Value* caps_value =
destination_info.is_dict()
? destination_info.FindKeyOfType(kSettingCapabilities,
base::Value::Type::DICTIONARY)
: nullptr;
response.SetKey("printerId", base::Value(printer_name));
response.SetKey("success", base::Value(!!caps_value));
response.SetKey("capabilities",
caps_value ? std::move(*caps_value)
: base::Value(base::Value::Type::DICTIONARY));
if (caps_value) {
base::Value* printer =
destination_info.FindKeyOfType(kPrinter, base::Value::Type::DICTIONARY);
if (printer) {
base::Value* policies_value = printer->FindKeyOfType(
kSettingPolicies, base::Value::Type::DICTIONARY);
if (policies_value)
response.SetKey("policies", std::move(*policies_value));
}
} else {
LOG(WARNING) << "Printer setup failed";
}
ResolveJavascriptCallback(base::Value(callback_id), response);
}
void PrintPreviewHandler::SendCloudPrintJob(
const std::string& callback_id,
const base::RefCountedMemory* data) {
// BASE64 encode the job data.
const base::StringPiece raw_data(data->front_as<char>(), data->size());
std::string base64_data;
base::Base64Encode(raw_data, &base64_data);
if (base64_data.size() >= kMaxCloudPrintPdfDataSizeInBytes) {
RejectJavascriptCallback(base::Value(callback_id),
base::Value("OVERSIZED_PDF"));
return;
}
ResolveJavascriptCallback(base::Value(callback_id), base::Value(base64_data));
}
WebContents* PrintPreviewHandler::GetInitiator() const {
PrintPreviewDialogController* dialog_controller =
PrintPreviewDialogController::GetInstance();
if (!dialog_controller)
return NULL;
return dialog_controller->GetInitiator(preview_web_contents());
}
void PrintPreviewHandler::OnAccountsInCookieUpdated(
const signin::AccountsInCookieJarInfo& accounts_in_cookie_jar_info,
const GoogleServiceAuthError& error) {
base::Value account_list(base::Value::Type::LIST);
const std::vector<gaia::ListedAccount>& accounts =
accounts_in_cookie_jar_info.signed_in_accounts;
for (const auto account : accounts) {
account_list.Append(account.email);
}
FireWebUIListener("user-accounts-updated", std::move(account_list));
}
void PrintPreviewHandler::OnPrintPreviewReady(int preview_uid, int request_id) {
std::string callback_id = GetCallbackId(request_id);
if (callback_id.empty())
return;
ResolveJavascriptCallback(base::Value(callback_id), base::Value(preview_uid));
}
void PrintPreviewHandler::OnPrintPreviewFailed(int request_id) {
WebContents* initiator = GetInitiator();
if (!initiator || initiator->IsBeingDestroyed())
return; // Drop notification if fired during destruction sequence.
std::string callback_id = GetCallbackId(request_id);
if (callback_id.empty())
return;
if (!reported_failed_preview_) {
reported_failed_preview_ = true;
ReportUserActionHistogram(PREVIEW_FAILED);
}
// Keep track of failures.
bool inserted = preview_failures_.insert(request_id).second;
DCHECK(inserted);
RejectJavascriptCallback(base::Value(callback_id),
base::Value("PREVIEW_FAILED"));
}
void PrintPreviewHandler::OnInvalidPrinterSettings(int request_id) {
std::string callback_id = GetCallbackId(request_id);
if (callback_id.empty())
return;
RejectJavascriptCallback(base::Value(callback_id),
base::Value("SETTINGS_INVALID"));
}
void PrintPreviewHandler::SendPrintPresetOptions(bool disable_scaling,
int copies,
int duplex,
int request_id) {
if (!ShouldReceiveRendererMessage(request_id))
return;
FireWebUIListener("print-preset-options", base::Value(disable_scaling),
base::Value(copies), base::Value(duplex));
}
void PrintPreviewHandler::SendPageCountReady(int page_count,
int fit_to_page_scaling,
int request_id) {
if (!ShouldReceiveRendererMessage(request_id))
return;
FireWebUIListener("page-count-ready", base::Value(page_count),
base::Value(request_id), base::Value(fit_to_page_scaling));
}
void PrintPreviewHandler::SendPageLayoutReady(
const base::DictionaryValue& layout,
bool has_custom_page_size_style,
int request_id) {
if (!ShouldReceiveRendererMessage(request_id))
return;
FireWebUIListener("page-layout-ready", layout,
base::Value(has_custom_page_size_style));
}
void PrintPreviewHandler::SendPagePreviewReady(int page_index,
int preview_uid,
int preview_request_id) {
// With print compositing, by the time compositing finishes and this method
// gets called, the print preview may have failed. Since the failure message
// may have arrived first, check for this case and bail out instead of
// thinking this may be a bad IPC message.
if (base::Contains(preview_failures_, preview_request_id))
return;
if (!ShouldReceiveRendererMessage(preview_request_id))
return;
FireWebUIListener("page-preview-ready", base::Value(page_index),
base::Value(preview_uid), base::Value(preview_request_id));
}
void PrintPreviewHandler::OnPrintPreviewCancelled(int request_id) {
std::string callback_id = GetCallbackId(request_id);
if (callback_id.empty())
return;
RejectJavascriptCallback(base::Value(callback_id), base::Value("CANCELLED"));
}
void PrintPreviewHandler::OnPrintRequestCancelled() {
HandleCancelPendingPrintRequest(nullptr);
}
void PrintPreviewHandler::ClearInitiatorDetails() {
WebContents* initiator = GetInitiator();
if (!initiator)
return;
// We no longer require the initiator details. Remove those details associated
// with the preview dialog to allow the initiator to create another preview
// dialog.
PrintPreviewDialogController* dialog_controller =
PrintPreviewDialogController::GetInstance();
if (dialog_controller)
dialog_controller->EraseInitiatorInfo(preview_web_contents());
}
PrinterHandler* PrintPreviewHandler::GetPrinterHandler(
PrinterType printer_type) {
if (printer_type == PrinterType::kExtensionPrinter) {
if (!extension_printer_handler_) {
extension_printer_handler_ = PrinterHandler::CreateForExtensionPrinters(
Profile::FromWebUI(web_ui()));
}
return extension_printer_handler_.get();
}
#if BUILDFLAG(ENABLE_SERVICE_DISCOVERY)
if (printer_type == PrinterType::kPrivetPrinter) {
if (!privet_printer_handler_) {
privet_printer_handler_ =
PrinterHandler::CreateForPrivetPrinters(Profile::FromWebUI(web_ui()));
}
return privet_printer_handler_.get();
}
#endif
if (printer_type == PrinterType::kPdfPrinter) {
if (!pdf_printer_handler_) {
pdf_printer_handler_ = PrinterHandler::CreateForPdfPrinter(
Profile::FromWebUI(web_ui()), preview_web_contents(),
GetStickySettings());
}
return pdf_printer_handler_.get();
}
if (printer_type == PrinterType::kLocalPrinter) {
if (!local_printer_handler_) {
local_printer_handler_ = PrinterHandler::CreateForLocalPrinters(
preview_web_contents(), Profile::FromWebUI(web_ui()));
}
return local_printer_handler_.get();
}
if (printer_type == PrinterType::kCloudPrinter) {
// This printer handler is currently experimental. Ensure it is never
// created unless the flag is enabled.
CHECK(base::FeatureList::IsEnabled(features::kCloudPrinterHandler));
if (!cloud_printer_handler_)
cloud_printer_handler_ = PrinterHandler::CreateForCloudPrinters();
return cloud_printer_handler_.get();
}
NOTREACHED();
return nullptr;
}
PdfPrinterHandler* PrintPreviewHandler::GetPdfPrinterHandler() {
return static_cast<PdfPrinterHandler*>(
GetPrinterHandler(PrinterType::kPdfPrinter));
}
void PrintPreviewHandler::OnAddedPrinters(PrinterType printer_type,
const base::ListValue& printers) {
DCHECK(printer_type == PrinterType::kExtensionPrinter ||
printer_type == PrinterType::kPrivetPrinter ||
printer_type == PrinterType::kLocalPrinter);
DCHECK(!printers.empty());
FireWebUIListener("printers-added", base::Value(printer_type), printers);
if (printer_type == PrinterType::kLocalPrinter &&
!has_logged_printers_count_) {
UMA_HISTOGRAM_COUNTS_1M("PrintPreview.NumberOfPrinters",
printers.GetSize());
has_logged_printers_count_ = true;
}
}
void PrintPreviewHandler::OnGetPrintersDone(const std::string& callback_id) {
ResolveJavascriptCallback(base::Value(callback_id), base::Value());
}
void PrintPreviewHandler::OnGotExtensionPrinterInfo(
const std::string& callback_id,
const base::DictionaryValue& printer_info) {
if (printer_info.empty()) {
RejectJavascriptCallback(base::Value(callback_id), base::Value());
return;
}
ResolveJavascriptCallback(base::Value(callback_id), printer_info);
}
void PrintPreviewHandler::OnPrintResult(const std::string& callback_id,
const base::Value& error) {
if (error.is_none())
ResolveJavascriptCallback(base::Value(callback_id), error);
else
RejectJavascriptCallback(base::Value(callback_id), error);
// Remove the preview dialog from the background printing manager if it is
// being stored there. Since the PDF has been sent and the callback is
// resolved or rejected, it is no longer needed and can be destroyed.
BackgroundPrintingManager* background_printing_manager =
g_browser_process->background_printing_manager();
if (background_printing_manager->HasPrintPreviewDialog(
preview_web_contents())) {
background_printing_manager->OnPrintRequestCancelled(
preview_web_contents());
}
}
void PrintPreviewHandler::RegisterForGaiaCookieChanges() {
DCHECK(!identity_manager_);
cloud_print_enabled_ =
GetPrefs()->GetBoolean(prefs::kCloudPrintSubmitEnabled);
if (!cloud_print_enabled_)
return;
Profile* profile = Profile::FromWebUI(web_ui());
if (!AccountConsistencyModeManager::IsMirrorEnabledForProfile(profile) &&
!AccountConsistencyModeManager::IsDiceEnabledForProfile(profile)) {
return;
}
identity_manager_ = IdentityManagerFactory::GetForProfile(profile);
identity_manager_->AddObserver(this);
}
void PrintPreviewHandler::UnregisterForGaiaCookieChanges() {
if (!identity_manager_)
return;
identity_manager_->RemoveObserver(this);
identity_manager_ = nullptr;
cloud_print_enabled_ = false;
}
bool PrintPreviewHandler::IsCloudPrintEnabled() {
return cloud_print_enabled_;
}
void PrintPreviewHandler::BadMessageReceived() {
bad_message::ReceivedBadMessage(
GetInitiator()->GetMainFrame()->GetProcess(),
bad_message::BadMessageReason::PPH_EXTRA_PREVIEW_MESSAGE);
}
void PrintPreviewHandler::FileSelectedForTesting(const base::FilePath& path,
int index,
void* params) {
GetPdfPrinterHandler()->FileSelected(path, index, params);
}
void PrintPreviewHandler::SetPdfSavedClosureForTesting(
base::OnceClosure closure) {
GetPdfPrinterHandler()->SetPdfSavedClosureForTesting(std::move(closure));
}
void PrintPreviewHandler::SendEnableManipulateSettingsForTest() {
FireWebUIListener("enable-manipulate-settings-for-test", base::Value());
}
void PrintPreviewHandler::SendManipulateSettingsForTest(
const base::DictionaryValue& settings) {
FireWebUIListener("manipulate-settings-for-test", settings);
}
} // namespace printing