1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/printing/pdf_blob_data_flattener.h"
#include <utility>
#include "base/check_is_test.h"
#include "base/check_op.h"
#include "base/containers/span.h"
#include "base/memory/read_only_shared_memory_region.h"
#include "base/memory/shared_memory_mapping.h"
#include "chrome/browser/pdf/pdf_pref_names.h"
#include "chrome/browser/printing/printing_service.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/services/printing/public/mojom/printing_service.mojom.h"
#include "components/prefs/pref_service.h"
#include "extensions/browser/blob_reader.h"
#include "mojo/public/cpp/bindings/callback_helpers.h"
#include "printing/metafile_skia.h"
#include "printing/printing_utils.h"
namespace printing {
namespace {
bool g_disable_pdf_flattening_for_testing = false;
} // namespace
FlattenPdfResult::FlattenPdfResult(
std::unique_ptr<MetafileSkia> flattened_pdf_in,
uint32_t page_count)
: flattened_pdf(std::move(flattened_pdf_in)), page_count(page_count) {
CHECK_GT(page_count, 0U);
CHECK(flattened_pdf);
}
FlattenPdfResult::~FlattenPdfResult() = default;
PdfBlobDataFlattener::PdfBlobDataFlattener(Profile* profile)
: profile_(*profile) {}
PdfBlobDataFlattener::~PdfBlobDataFlattener() = default;
// static
base::AutoReset<bool> PdfBlobDataFlattener::DisablePdfFlatteningForTesting() {
return base::AutoReset<bool>(&g_disable_pdf_flattening_for_testing, true);
}
void PdfBlobDataFlattener::ReadAndFlattenPdf(
mojo::PendingRemote<blink::mojom::Blob> blob,
ReadAndFlattenPdfCallback callback) {
BlobReader::Read(
std::move(blob),
base::BindOnce(&PdfBlobDataFlattener::OnPdfRead,
weak_factory_.GetWeakPtr(), std::move(callback)));
}
void PdfBlobDataFlattener::OnPdfRead(ReadAndFlattenPdfCallback callback,
std::string data,
int64_t /*blob_total_size*/) {
if (!LooksLikePdf(base::as_byte_span(data))) {
std::move(callback).Run(/*result=*/nullptr);
return;
}
base::MappedReadOnlyRegion memory =
base::ReadOnlySharedMemoryRegion::Create(data.size());
if (!memory.IsValid()) {
std::move(callback).Run(/*result=*/nullptr);
return;
}
memory.mapping.GetMemoryAsSpan<char>().copy_prefix_from(data);
if (g_disable_pdf_flattening_for_testing) {
CHECK_IS_TEST();
OnPdfFlattened(std::move(callback),
mojom::FlattenPdfResult::New(std::move(memory.region),
/*page_count=*/1));
return;
}
if (!flattener_.is_bound()) {
GetPrintingService()->BindPdfFlattener(
flattener_.BindNewPipeAndPassReceiver());
auto* prefs = profile_->GetPrefs();
if (prefs &&
prefs->IsManagedPreference(prefs::kPdfUseSkiaRendererEnabled)) {
flattener_->SetUseSkiaRendererPolicy(
prefs->GetBoolean(prefs::kPdfUseSkiaRendererEnabled));
}
}
auto flatten_callback =
base::BindOnce(&PdfBlobDataFlattener::OnPdfFlattened,
weak_factory_.GetWeakPtr(), std::move(callback));
flattener_->FlattenPdf(std::move(memory.region),
mojo::WrapCallbackWithDefaultInvokeIfNotRun(
std::move(flatten_callback), nullptr));
}
void PdfBlobDataFlattener::OnPdfFlattened(ReadAndFlattenPdfCallback callback,
mojom::FlattenPdfResultPtr result) {
if (!result) {
std::move(callback).Run(nullptr);
return;
}
auto mapping = result->flattened_pdf_region.Map();
if (!mapping.IsValid()) {
std::move(callback).Run(nullptr);
return;
}
auto metafile = std::make_unique<MetafileSkia>();
CHECK(metafile->InitFromData(mapping.GetMemoryAsSpan<const uint8_t>()));
std::move(callback).Run(std::make_unique<FlattenPdfResult>(
std::move(metafile), result->page_count));
}
} // namespace printing
|
