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
|
// Copyright 2016 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/ash/printing/synced_printers_manager.h"
#include <optional>
#include <unordered_map>
#include <utility>
#include "base/observer_list_threadsafe.h"
#include "base/synchronization/lock.h"
#include "base/uuid.h"
#include "base/values.h"
#include "chrome/browser/ash/printing/printers_sync_bridge.h"
#include "chrome/browser/ash/printing/specifics_translation.h"
#include "chrome/common/pref_names.h"
#include "chromeos/ash/components/settings/cros_settings_names.h"
#include "chromeos/printing/printer_configuration.h"
#include "chromeos/printing/printer_translator.h"
#include "components/policy/policy_constants.h"
#include "components/pref_registry/pref_registry_syncable.h"
#include "components/prefs/pref_service.h"
namespace ash {
namespace {
class SyncedPrintersManagerImpl : public SyncedPrintersManager,
public PrintersSyncBridge::Observer {
public:
explicit SyncedPrintersManagerImpl(
std::unique_ptr<PrintersSyncBridge> sync_bridge)
: sync_bridge_(std::move(sync_bridge)),
observers_(new base::ObserverListThreadSafe<
SyncedPrintersManager::Observer>()) {
sync_bridge_->AddObserver(this);
}
~SyncedPrintersManagerImpl() override {
sync_bridge_->RemoveObserver(this);
}
std::vector<chromeos::Printer> GetSavedPrinters() const override {
// No need to lock here, since sync_bridge_ is thread safe and we don't
// touch anything else.
std::vector<chromeos::Printer> printers;
std::vector<sync_pb::PrinterSpecifics> values =
sync_bridge_->GetAllPrinters();
for (const auto& value : values) {
printers.push_back(*SpecificsToPrinter(value));
}
return printers;
}
std::unique_ptr<chromeos::Printer> GetPrinter(
const std::string& printer_id) const override {
base::AutoLock l(lock_);
return GetPrinterLocked(printer_id);
}
void UpdateSavedPrinter(const chromeos::Printer& printer) override {
base::AutoLock l(lock_);
UpdateSavedPrinterLocked(printer);
}
bool RemoveSavedPrinter(const std::string& printer_id) override {
return sync_bridge_->RemovePrinter(printer_id);
}
void AddObserver(SyncedPrintersManager::Observer* observer) override {
observers_->AddObserver(observer);
}
void RemoveObserver(SyncedPrintersManager::Observer* observer) override {
observers_->RemoveObserver(observer);
}
PrintersSyncBridge* GetSyncBridge() override { return sync_bridge_.get(); }
// PrintersSyncBridge::Observer override.
void OnPrintersUpdated() override {
observers_->Notify(
FROM_HERE, &SyncedPrintersManager::Observer::OnSavedPrintersChanged);
}
private:
std::unique_ptr<chromeos::Printer> GetPrinterLocked(
const std::string& printer_id) const {
lock_.AssertAcquired();
std::optional<sync_pb::PrinterSpecifics> printer =
sync_bridge_->GetPrinter(printer_id);
return printer.has_value() ? SpecificsToPrinter(*printer) : nullptr;
}
void UpdateSavedPrinterLocked(const chromeos::Printer& printer_arg) {
lock_.AssertAcquired();
DCHECK_EQ(chromeos::Printer::SRC_USER_PREFS, printer_arg.source());
// Need a local copy since we may set the id.
chromeos::Printer printer = printer_arg;
if (printer.id().empty()) {
printer.set_id(base::Uuid::GenerateRandomV4().AsLowercaseString());
}
sync_bridge_->UpdatePrinter(PrinterToSpecifics(printer));
}
mutable base::Lock lock_;
// The backend for profile printers.
std::unique_ptr<PrintersSyncBridge> sync_bridge_;
scoped_refptr<base::ObserverListThreadSafe<SyncedPrintersManager::Observer>>
observers_;
base::WeakPtrFactory<SyncedPrintersManagerImpl> weak_factory_{this};
};
} // namespace
// static
std::unique_ptr<SyncedPrintersManager> SyncedPrintersManager::Create(
std::unique_ptr<PrintersSyncBridge> sync_bridge) {
return std::make_unique<SyncedPrintersManagerImpl>(std::move(sync_bridge));
}
} // namespace ash
|
