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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
|
// Copyright (c) 2006-2008 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.
#ifndef PRINTING_PRINTED_DOCUMENT_H_
#define PRINTING_PRINTED_DOCUMENT_H_
#include <map>
#include "app/gfx/native_widget_types.h"
#include "base/lock.h"
#include "base/ref_counted.h"
#include "base/scoped_ptr.h"
#include "googleurl/src/gurl.h"
#include "printing/print_settings.h"
#include "printing/native_metafile.h"
class MessageLoop;
namespace gfx {
class Font;
}
namespace printing {
class PrintedPage;
class PrintedPagesSource;
// A collection of rendered pages. The settings are immutable. If the print
// settings are changed, a new PrintedDocument must be created.
// Warning: May be accessed from many threads at the same time. Only one thread
// will have write access. Sensible functions are protected by a lock.
// Warning: Once a page is loaded, it cannot be replaced. Pages may be discarded
// under low memory conditions.
class PrintedDocument : public base::RefCountedThreadSafe<PrintedDocument> {
public:
// The cookie shall be unique and has a specific relationship with its
// originating source and settings.
PrintedDocument(const PrintSettings& settings,
PrintedPagesSource* source,
int cookie);
// Sets a page's data. 0-based. Takes metafile ownership.
// Note: locks for a short amount of time.
void SetPage(int page_number, NativeMetafile* metafile, double shrink);
// Retrieves a page. If the page is not available right now, it
// requests to have this page be rendered and returns false.
// Note: locks for a short amount of time.
bool GetPage(int page_number, scoped_refptr<PrintedPage>* page);
// Draws the page in the context.
// Note: locks for a short amount of time in debug only.
void RenderPrintedPage(const PrintedPage& page,
gfx::NativeDrawingContext context) const;
// Draws the page in the context. If the page is not available right now, it
// requests to have this page be rendered and returns false.
// Note: locks for a short amount of time.
bool RenderPrintedPageNumber(int page_number,
gfx::NativeDrawingContext context);
// Returns true if all the necessary pages for the settings are already
// rendered.
// Note: locks while parsing the whole tree.
bool IsComplete() const;
// Disconnects the PrintedPage source (PrintedPagesSource). It is done when
// the source is being destroyed.
void DisconnectSource();
// Retrieves the current memory usage of the renderer pages.
// Note: locks for a short amount of time.
size_t MemoryUsage() const;
// Sets the number of pages in the document to be rendered. Can only be set
// once.
// Note: locks for a short amount of time.
void set_page_count(int max_page);
// Number of pages in the document. Used for headers/footers.
// Note: locks for a short amount of time.
int page_count() const;
// Returns the number of expected pages to be rendered. It is a non-linear
// series if settings().ranges is not empty. It is the same value as
// document_page_count() otherwise.
// Note: locks for a short amount of time.
int expected_page_count() const;
// Getters. All these items are immutable hence thread-safe.
const PrintSettings& settings() const { return immutable_.settings_; }
const std::wstring& name() const {
return immutable_.name_;
}
const GURL& url() const { return immutable_.url_; }
const std::wstring& date() const { return immutable_.date_; }
const std::wstring& time() const { return immutable_.time_; }
const int cookie() const { return immutable_.cookie_; }
// Sets a path where to dump printing output files for debugging. If never set
// no files are generated.
static void set_debug_dump_path(const std::wstring& debug_dump_path);
static const std::wstring& debug_dump_path();
private:
friend class base::RefCountedThreadSafe<PrintedDocument>;
~PrintedDocument();
// Array of data for each print previewed page.
typedef std::map<int, scoped_refptr<PrintedPage> > PrintedPages;
// Contains all the mutable stuff. All this stuff MUST be accessed with the
// lock held.
struct Mutable {
Mutable(PrintedPagesSource* source);
// Source that generates the PrintedPage's (i.e. a TabContents). It will be
// set back to NULL if the source is deleted before this object.
PrintedPagesSource* source_;
// Contains the pages' representation. This is a collection of PrintedPage.
// Warning: Lock must be held when accessing this member.
PrintedPages pages_;
// Number of expected pages to be rendered.
// Warning: Lock must be held when accessing this member.
int expected_page_count_;
// The total number of pages in the document.
int page_count_;
// Shrink done in comparison to desired_dpi.
double shrink_factor;
};
// Contains all the immutable stuff. All this stuff can be accessed without
// any lock held. This is because it can't be changed after the object's
// construction.
struct Immutable {
Immutable(const PrintSettings& settings, PrintedPagesSource* source,
int cookie);
// Print settings used to generate this document. Immutable.
PrintSettings settings_;
// Native thread for the render source.
MessageLoop* source_message_loop_;
// Document name. Immutable.
std::wstring name_;
// URL that generated this document. Immutable.
GURL url_;
// The date on which this job started. Immutable.
std::wstring date_;
// The time at which this job started. Immutable.
std::wstring time_;
// Cookie to uniquely identify this document. It is used to make sure that a
// PrintedPage is correctly belonging to the PrintedDocument. Since
// PrintedPage generation is completely asynchronous, it could be easy to
// mess up and send the page to the wrong document. It can be viewed as a
// simpler hash of PrintSettings since a new document is made each time the
// print settings change.
int cookie_;
};
// Prints the headers and footers for one page in the specified context
// according to the current settings.
void PrintHeaderFooter(gfx::NativeDrawingContext context,
const PrintedPage& page,
PageOverlays::HorizontalPosition x,
PageOverlays::VerticalPosition y,
const gfx::Font& font) const;
void DebugDump(const PrintedPage& page);
// All writable data member access must be guarded by this lock. Needs to be
// mutable since it can be acquired from const member functions.
mutable Lock lock_;
// All the mutable members.
Mutable mutable_;
// All the immutable members.
const Immutable immutable_;
DISALLOW_EVIL_CONSTRUCTORS(PrintedDocument);
};
} // namespace printing
#endif // PRINTING_PRINTED_DOCUMENT_H_
|
