1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
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/printed_document.h"
6
7 #include <algorithm>
8 #include <set>
9 #include <string>
10 #include <vector>
11
12 #include "base/file_util.h"
13 #include "base/files/file_path.h"
14 #include "base/i18n/file_util_icu.h"
15 #include "base/i18n/time_formatting.h"
16 #include "base/lazy_instance.h"
17 #include "base/message_loop/message_loop.h"
18 #include "base/strings/string_util.h"
19 #include "base/strings/stringprintf.h"
20 #include "base/strings/utf_string_conversions.h"
21 #include "printing/page_number.h"
22 #include "printing/printed_page.h"
23 #include "printing/printed_pages_source.h"
24 #include "printing/units.h"
25 #include "skia/ext/platform_device.h"
26 #include "ui/gfx/font.h"
27 #include "ui/gfx/text_elider.h"
28
29 namespace {
30
31 struct PrintDebugDumpPath {
PrintDebugDumpPath__anonf95910d70111::PrintDebugDumpPath32 PrintDebugDumpPath()
33 : enabled(false) {
34 }
35
36 bool enabled;
37 base::FilePath debug_dump_path;
38 };
39
40 base::LazyInstance<PrintDebugDumpPath> g_debug_dump_info =
41 LAZY_INSTANCE_INITIALIZER;
42
43 } // namespace
44
45 namespace printing {
46
PrintedDocument(const PrintSettings & settings,PrintedPagesSource * source,int cookie)47 PrintedDocument::PrintedDocument(const PrintSettings& settings,
48 PrintedPagesSource* source,
49 int cookie)
50 : mutable_(source),
51 immutable_(settings, source, cookie) {
52
53 // Records the expected page count if a range is setup.
54 if (!settings.ranges().empty()) {
55 // If there is a range, set the number of page
56 for (unsigned i = 0; i < settings.ranges().size(); ++i) {
57 const PageRange& range = settings.ranges()[i];
58 mutable_.expected_page_count_ += range.to - range.from + 1;
59 }
60 }
61 }
62
~PrintedDocument()63 PrintedDocument::~PrintedDocument() {
64 }
65
SetPage(int page_number,Metafile * metafile,double shrink,const gfx::Size & paper_size,const gfx::Rect & page_rect)66 void PrintedDocument::SetPage(int page_number,
67 Metafile* metafile,
68 double shrink,
69 const gfx::Size& paper_size,
70 const gfx::Rect& page_rect) {
71 // Notice the page_number + 1, the reason is that this is the value that will
72 // be shown. Users dislike 0-based counting.
73 scoped_refptr<PrintedPage> page(
74 new PrintedPage(page_number + 1,
75 metafile,
76 paper_size,
77 page_rect,
78 shrink));
79 {
80 base::AutoLock lock(lock_);
81 mutable_.pages_[page_number] = page;
82
83 #if defined(OS_POSIX) && !defined(OS_MACOSX)
84 if (page_number < mutable_.first_page)
85 mutable_.first_page = page_number;
86 #endif
87 }
88 DebugDump(*page.get());
89 }
90
GetPage(int page_number,scoped_refptr<PrintedPage> * page)91 bool PrintedDocument::GetPage(int page_number,
92 scoped_refptr<PrintedPage>* page) {
93 base::AutoLock lock(lock_);
94 PrintedPages::const_iterator itr = mutable_.pages_.find(page_number);
95 if (itr != mutable_.pages_.end()) {
96 if (itr->second.get()) {
97 *page = itr->second;
98 return true;
99 }
100 }
101 return false;
102 }
103
IsComplete() const104 bool PrintedDocument::IsComplete() const {
105 base::AutoLock lock(lock_);
106 if (!mutable_.page_count_)
107 return false;
108 PageNumber page(immutable_.settings_, mutable_.page_count_);
109 if (page == PageNumber::npos())
110 return false;
111
112 for (; page != PageNumber::npos(); ++page) {
113 #if defined(OS_WIN) || defined(OS_MACOSX)
114 const bool metafile_must_be_valid = true;
115 #elif defined(OS_POSIX)
116 const bool metafile_must_be_valid = (page.ToInt() == mutable_.first_page);
117 #endif
118 PrintedPages::const_iterator itr = mutable_.pages_.find(page.ToInt());
119 if (itr == mutable_.pages_.end() || !itr->second.get())
120 return false;
121 if (metafile_must_be_valid && !itr->second->metafile())
122 return false;
123 }
124 return true;
125 }
126
DisconnectSource()127 void PrintedDocument::DisconnectSource() {
128 base::AutoLock lock(lock_);
129 mutable_.source_ = NULL;
130 }
131
MemoryUsage() const132 uint32 PrintedDocument::MemoryUsage() const {
133 std::vector< scoped_refptr<PrintedPage> > pages_copy;
134 {
135 base::AutoLock lock(lock_);
136 pages_copy.reserve(mutable_.pages_.size());
137 PrintedPages::const_iterator end = mutable_.pages_.end();
138 for (PrintedPages::const_iterator itr = mutable_.pages_.begin();
139 itr != end; ++itr) {
140 if (itr->second.get()) {
141 pages_copy.push_back(itr->second);
142 }
143 }
144 }
145 uint32 total = 0;
146 for (size_t i = 0; i < pages_copy.size(); ++i) {
147 total += pages_copy[i]->metafile()->GetDataSize();
148 }
149 return total;
150 }
151
set_page_count(int max_page)152 void PrintedDocument::set_page_count(int max_page) {
153 base::AutoLock lock(lock_);
154 DCHECK_EQ(0, mutable_.page_count_);
155 mutable_.page_count_ = max_page;
156 if (immutable_.settings_.ranges().empty()) {
157 mutable_.expected_page_count_ = max_page;
158 } else {
159 // If there is a range, don't bother since expected_page_count_ is already
160 // initialized.
161 DCHECK_NE(mutable_.expected_page_count_, 0);
162 }
163 }
164
page_count() const165 int PrintedDocument::page_count() const {
166 base::AutoLock lock(lock_);
167 return mutable_.page_count_;
168 }
169
expected_page_count() const170 int PrintedDocument::expected_page_count() const {
171 base::AutoLock lock(lock_);
172 return mutable_.expected_page_count_;
173 }
174
DebugDump(const PrintedPage & page)175 void PrintedDocument::DebugDump(const PrintedPage& page) {
176 if (!g_debug_dump_info.Get().enabled)
177 return;
178
179 base::string16 filename;
180 filename += name();
181 filename += base::ASCIIToUTF16("_");
182 filename += base::ASCIIToUTF16(
183 base::StringPrintf("%02d", page.page_number()));
184 #if defined(OS_WIN)
185 filename += base::ASCIIToUTF16("_.emf");
186 page.metafile()->SaveTo(
187 g_debug_dump_info.Get().debug_dump_path.Append(filename));
188 #else // OS_WIN
189 filename += base::ASCIIToUTF16("_.pdf");
190 page.metafile()->SaveTo(
191 g_debug_dump_info.Get().debug_dump_path.Append(
192 base::UTF16ToUTF8(filename)));
193 #endif // OS_WIN
194 }
195
set_debug_dump_path(const base::FilePath & debug_dump_path)196 void PrintedDocument::set_debug_dump_path(
197 const base::FilePath& debug_dump_path) {
198 g_debug_dump_info.Get().enabled = !debug_dump_path.empty();
199 g_debug_dump_info.Get().debug_dump_path = debug_dump_path;
200 }
201
debug_dump_path()202 const base::FilePath& PrintedDocument::debug_dump_path() {
203 return g_debug_dump_info.Get().debug_dump_path;
204 }
205
Mutable(PrintedPagesSource * source)206 PrintedDocument::Mutable::Mutable(PrintedPagesSource* source)
207 : source_(source),
208 expected_page_count_(0),
209 page_count_(0) {
210 #if defined(OS_POSIX) && !defined(OS_MACOSX)
211 first_page = INT_MAX;
212 #endif
213 }
214
~Mutable()215 PrintedDocument::Mutable::~Mutable() {
216 }
217
Immutable(const PrintSettings & settings,PrintedPagesSource * source,int cookie)218 PrintedDocument::Immutable::Immutable(const PrintSettings& settings,
219 PrintedPagesSource* source,
220 int cookie)
221 : settings_(settings),
222 source_message_loop_(base::MessageLoop::current()),
223 name_(source->RenderSourceName()),
224 cookie_(cookie) {
225 }
226
~Immutable()227 PrintedDocument::Immutable::~Immutable() {
228 }
229
230 #if (defined(OS_POSIX) && defined(USE_AURA)) || defined(OS_ANDROID)
231 // This function is not used on aura linux/chromeos or android.
RenderPrintedPage(const PrintedPage & page,PrintingContext * context) const232 void PrintedDocument::RenderPrintedPage(const PrintedPage& page,
233 PrintingContext* context) const {
234 }
235 #endif
236
237 } // namespace printing
238