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
|
// Copyright (c) 2010 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/printing/printer_query.h"
#include "base/message_loop.h"
#include "base/threading/thread_restrictions.h"
#include "chrome/browser/printing/print_job_worker.h"
namespace printing {
PrinterQuery::PrinterQuery()
: io_message_loop_(MessageLoop::current()),
ALLOW_THIS_IN_INITIALIZER_LIST(worker_(new PrintJobWorker(this))),
is_print_dialog_box_shown_(false),
cookie_(PrintSettings::NewCookie()),
last_status_(PrintingContext::FAILED) {
DCHECK_EQ(io_message_loop_->type(), MessageLoop::TYPE_IO);
}
PrinterQuery::~PrinterQuery() {
// The job should be finished (or at least canceled) when it is destroyed.
DCHECK(!is_print_dialog_box_shown_);
// If this fires, it is that this pending printer context has leaked.
DCHECK(!worker_.get());
if (callback_.get()) {
// Be sure to cancel it.
callback_->Cancel();
}
// It may get deleted in a different thread that the one that created it.
}
void PrinterQuery::GetSettingsDone(const PrintSettings& new_settings,
PrintingContext::Result result) {
is_print_dialog_box_shown_ = false;
last_status_ = result;
if (result != PrintingContext::FAILED) {
settings_ = new_settings;
cookie_ = PrintSettings::NewCookie();
} else {
// Failure.
cookie_ = 0;
}
if (callback_.get()) {
// This may cause reentrancy like to call StopWorker().
callback_->Run();
callback_.reset(NULL);
}
}
PrintJobWorker* PrinterQuery::DetachWorker(PrintJobWorkerOwner* new_owner) {
DCHECK(!callback_.get());
DCHECK(worker_.get());
if (!worker_.get())
return NULL;
worker_->SetNewOwner(new_owner);
return worker_.release();
}
MessageLoop* PrinterQuery::message_loop() {
return io_message_loop_;
}
const PrintSettings& PrinterQuery::settings() const {
return settings_;
}
int PrinterQuery::cookie() const {
return cookie_;
}
void PrinterQuery::GetSettings(GetSettingsAskParam ask_user_for_settings,
gfx::NativeView parent_view,
int expected_page_count,
bool has_selection,
bool use_overlays,
CancelableTask* callback) {
DCHECK_EQ(io_message_loop_, MessageLoop::current());
DCHECK(!is_print_dialog_box_shown_);
DCHECK(!callback_.get());
DCHECK(worker_.get());
if (!worker_.get())
return;
// Lazy create the worker thread. There is one worker thread per print job.
if (!worker_->message_loop()) {
if (!worker_->Start()) {
if (callback) {
callback->Cancel();
delete callback;
}
NOTREACHED();
return;
}
}
callback_.reset(callback);
// Real work is done in PrintJobWorker::Init().
is_print_dialog_box_shown_ = ask_user_for_settings == ASK_USER;
worker_->message_loop()->PostTask(FROM_HERE, NewRunnableMethod(
worker_.get(),
&PrintJobWorker::GetSettings,
is_print_dialog_box_shown_,
parent_view,
expected_page_count,
has_selection,
use_overlays));
}
void PrinterQuery::StopWorker() {
if (worker_.get()) {
// http://crbug.com/66082: We're blocking on the PrinterQuery's worker
// thread. It's not clear to me if this may result in blocking the current
// thread for an unacceptable time. We should probably fix it.
base::ThreadRestrictions::ScopedAllowIO allow_io;
worker_->Stop();
worker_.reset();
}
}
bool PrinterQuery::is_print_dialog_box_shown() const {
return is_print_dialog_box_shown_;
}
bool PrinterQuery::is_callback_pending() const {
return callback_.get() != NULL;
}
bool PrinterQuery::is_valid() const {
return worker_.get() != NULL;
}
} // namespace printing
|
