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
|
// Copyright (c) 2009 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 CHROME_RENDERER_MOCK_PRINTER_H_
#define CHROME_RENDERER_MOCK_PRINTER_H_
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/ref_counted.h"
#include "base/scoped_ptr.h"
#if defined(OS_WIN)
#include "chrome/renderer/mock_printer_driver_win.h"
#endif
struct ViewMsg_Print_Params;
struct ViewMsg_PrintPages_Params;
struct ViewHostMsg_DidPrintPage_Params;
// A class which represents an output page used in the MockPrinter class.
// The MockPrinter class stores output pages in a vector, so, this class
// inherits the base::RefCounted<> class so that the MockPrinter class can use
// a smart pointer of this object (i.e. scoped_refptr<>).
class MockPrinterPage : public base::RefCounted<MockPrinterPage> {
public:
MockPrinterPage()
: width_(0),
height_(0),
source_size_(0),
bitmap_size_(0) {
}
MockPrinterPage(int width,
int height,
const void* source_data,
size_t source_size,
const void* bitmap_data,
size_t bitmap_size)
: width_(width),
height_(height),
source_size_(source_size),
bitmap_size_(bitmap_size) {
// Create copies of the source data and the bitmap data.
source_data_.reset(new uint8[source_size]);
if (source_data_.get())
memcpy(source_data_.get(), source_data, source_size);
bitmap_data_.reset(new uint8[bitmap_size]);
if (bitmap_data_.get())
memcpy(bitmap_data_.get(), bitmap_data, bitmap_size);
}
~MockPrinterPage() {
}
int width() { return width_; }
int height() { return height_; }
const uint8* source_data() { return source_data_.get(); }
const size_t source_size() { return source_size_; }
const uint8* bitmap_data() { return bitmap_data_.get(); }
const size_t bitmap_size() { return bitmap_size_; }
private:
int width_;
int height_;
size_t source_size_;
scoped_array<uint8> source_data_;
size_t bitmap_size_;
scoped_array<uint8> bitmap_data_;
DISALLOW_COPY_AND_ASSIGN(MockPrinterPage);
};
// A class which implements a pseudo-printer object used by the RenderViewTest
// class.
// This class consists of three parts:
// 1. An IPC-message hanlder sent from the RenderView class;
// 2. A renderer that creates a printing job into bitmaps, and;
// 3. A vector which saves the output pages of a printing job.
// A user who writes RenderViewTest cases only use the functions which
// retrieve output pages from this vector to verify them with expected results.
class MockPrinter {
public:
enum Status {
PRINTER_READY,
PRINTER_PRINTING,
PRINTER_ERROR,
};
MockPrinter();
~MockPrinter();
// Functions that changes settings of a pseudo printer.
void ResetPrinter();
void SetDefaultPrintSettings(const ViewMsg_Print_Params& params);
// Functions that handles IPC events.
void GetDefaultPrintSettings(ViewMsg_Print_Params* params);
void ScriptedPrint(int cookie,
int expected_pages_count,
bool has_selection,
ViewMsg_PrintPages_Params* settings);
void SetPrintedPagesCount(int cookie, int number_pages);
void PrintPage(const ViewHostMsg_DidPrintPage_Params& params);
// Functions that retrieve the output pages.
Status GetPrinterStatus() const { return printer_status_; }
int GetPrintedPages() const;
int GetWidth(size_t page) const;
int GetHeight(size_t page) const;
bool GetSourceChecksum(size_t page, std::string* checksum) const;
bool GetBitmapChecksum(size_t page, std::string* checksum) const;
bool GetSource(size_t page, const void** data, size_t* size) const;
bool GetBitmap(size_t page, const void** data, size_t* size) const;
bool SaveSource(size_t page, const std::wstring& filename) const;
bool SaveBitmap(size_t page, const std::wstring& filename) const;
protected:
int CreateDocumentCookie();
bool GetChecksum(const void* data, size_t size, std::string* checksum) const;
private:
// In pixels according to dpi_x and dpi_y.
int printable_width_;
int printable_height_;
// Specifies dots per inch.
double dpi_;
double max_shrink_;
double min_shrink_;
// Desired apparent dpi on paper.
int desired_dpi_;
// Print selection.
bool selection_only_;
// Cookie for the document to ensure correctness.
int document_cookie_;
int current_document_cookie_;
// The current status of this printer.
Status printer_status_;
// The output of a printing job.
int number_pages_;
int page_number_;
std::vector<scoped_refptr<MockPrinterPage> > pages_;
#if defined(OS_WIN)
MockPrinterDriverWin driver_;
#endif
DISALLOW_COPY_AND_ASSIGN(MockPrinter);
};
#endif // CHROME_RENDERER_MOCK_PRINTER_H_
|
