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
|
// Copyright 2017 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/sync/test/integration/printers_helper.h"
#include <algorithm>
#include <ostream>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
#include "base/functional/bind.h"
#include "base/strings/stringprintf.h"
#include "chrome/browser/ash/printing/synced_printers_manager.h"
#include "chrome/browser/ash/printing/synced_printers_manager_factory.h"
#include "chrome/browser/sync/test/integration/sync_datatype_helper.h"
#include "chrome/browser/sync/test/integration/sync_test.h"
#include "content/public/test/test_utils.h"
using sync_datatype_helper::test;
namespace printers_helper {
namespace {
using PrinterList = std::vector<chromeos::Printer>;
// Returns true if Printer#id, Printer#description, and Printer#uri all match.
bool PrintersAreMostlyEqual(const chromeos::Printer& left,
const chromeos::Printer& right) {
return left.id() == right.id() && left.description() == right.description() &&
left.uri() == right.uri();
}
// Returns true if both lists have the same elements irrespective of order.
bool ListsContainTheSamePrinters(const PrinterList& list_a,
const PrinterList& list_b) {
std::unordered_multimap<std::string, const chromeos::Printer*> map_b;
for (const chromeos::Printer& b : list_b) {
map_b.insert({b.id(), &b});
}
for (const chromeos::Printer& a : list_a) {
auto [begin, end] = map_b.equal_range(a.id());
auto it = std::find_if(
begin, end,
[&a](const std::pair<std::string, const chromeos::Printer*>& entry) {
return PrintersAreMostlyEqual(a, *(entry.second));
});
if (it == end) {
// Element in a does not match an element in b. Lists do not contain the
// same elements.
return false;
}
map_b.erase(it);
}
return map_b.empty();
}
std::string PrinterId(int index) {
return base::StringPrintf("printer%d", index);
}
ash::SyncedPrintersManager* GetPrinterStore(content::BrowserContext* context) {
return ash::SyncedPrintersManagerFactory::GetForBrowserContext(context);
}
} // namespace
void AddPrinter(ash::SyncedPrintersManager* manager,
const chromeos::Printer& printer) {
manager->UpdateSavedPrinter(printer);
}
void RemovePrinter(ash::SyncedPrintersManager* manager, int index) {
chromeos::Printer testPrinter(CreateTestPrinter(index));
manager->RemoveSavedPrinter(testPrinter.id());
}
bool EditPrinterDescription(ash::SyncedPrintersManager* manager,
int index,
const std::string& description) {
PrinterList printers = manager->GetSavedPrinters();
std::string printer_id = PrinterId(index);
auto found = std::ranges::find(printers, printer_id, &chromeos::Printer::id);
if (found == printers.end()) {
return false;
}
found->set_description(description);
manager->UpdateSavedPrinter(*found);
return true;
}
chromeos::Printer CreateTestPrinter(int index) {
chromeos::Printer printer(PrinterId(index));
printer.set_description("Description");
printer.SetUri(base::StringPrintf("ipp://192.168.1.%d", index));
return printer;
}
std::unique_ptr<sync_pb::PrinterSpecifics> CreateTestPrinterSpecifics(
int index) {
auto specifics = std::make_unique<sync_pb::PrinterSpecifics>();
specifics->set_id(PrinterId(index));
specifics->set_description("Description");
specifics->set_uri(base::StringPrintf("ipp://192.168.1.%d", index));
return specifics;
}
void WaitForPrinterStoreToLoad(content::BrowserContext* context) {
GetPrinterStore(context);
// Run tasks to allow a DataTypeStore to be associated with the
// SyncedPrinterManager.
//
// TODO(sync): Remove this forced initialization once there is a mechanism
// to queue writes/reads before the DataTypeStore is associated with the
// SyncedPrinterManager. https://crbug.com/709094.
content::RunAllTasksUntilIdle();
}
ash::SyncedPrintersManager* GetVerifierPrinterStore() {
ash::SyncedPrintersManager* manager =
GetPrinterStore(sync_datatype_helper::test()->verifier());
return manager;
}
ash::SyncedPrintersManager* GetPrinterStore(int index) {
ash::SyncedPrintersManager* manager =
GetPrinterStore(sync_datatype_helper::test()->GetProfile(index));
return manager;
}
int GetVerifierPrinterCount() {
return GetVerifierPrinterStore()->GetSavedPrinters().size();
}
int GetPrinterCount(int index) {
return GetPrinterStore(index)->GetSavedPrinters().size();
}
bool AllProfilesContainSamePrinters(std::ostream* os) {
std::vector<chromeos::Printer> reference_printers =
GetPrinterStore(0)->GetSavedPrinters();
for (int i = 1; i < test()->num_clients(); ++i) {
std::vector<chromeos::Printer> printers =
GetPrinterStore(i)->GetSavedPrinters();
if (!ListsContainTheSamePrinters(reference_printers, printers)) {
if (os) {
*os << "Printers in client [" << i << "] don't match client 0";
}
return false;
}
}
return true;
}
bool ProfileContainsSamePrintersAsVerifier(int index) {
return ListsContainTheSamePrinters(
GetVerifierPrinterStore()->GetSavedPrinters(),
GetPrinterStore(index)->GetSavedPrinters());
}
PrintersMatchChecker::PrintersMatchChecker()
: AwaitMatchStatusChangeChecker(base::BindRepeating(
&printers_helper::AllProfilesContainSamePrinters)) {}
PrintersMatchChecker::~PrintersMatchChecker() = default;
} // namespace printers_helper
|
