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
|
// Copyright 2020 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/chromebox_for_meetings/logger/cfm_logger_service.h"
#include "base/functional/bind.h"
#include "chrome/browser/ash/chromebox_for_meetings/logger/reporting_pipeline.h"
#include "chromeos/ash/components/chromebox_for_meetings/features.h"
#include "chromeos/ash/components/dbus/chromebox_for_meetings/cfm_hotline_client.h"
#include "chromeos/services/chromebox_for_meetings/public/mojom/meet_devices_logger.mojom-shared.h"
#include "mojo/public/cpp/bindings/receiver_set.h"
namespace ash::cfm {
namespace {
// TODO(https://crbug.com/1403174): Remove when namespace of mojoms for CfM are
// migarted to ash.
namespace mojom = ::chromeos::cfm::mojom;
// Implementation of the CfmLoggerService which uses the Chrome Encrypted
// Reporting Pipeline APIs to define the delegate's functionality
class CfmERPLoggerService : public CfmLoggerService {
public:
CfmERPLoggerService() : CfmLoggerService(nullptr) {
reporting_pipeline_ = std::make_unique<ReportingPipeline>(
base::BindRepeating(&CfmERPLoggerService::NotifyStateObserver,
weak_ptr_factory_.GetWeakPtr()));
SetDelegate(reporting_pipeline_.get());
}
CfmERPLoggerService(const CfmERPLoggerService&) = delete;
CfmERPLoggerService& operator=(const CfmERPLoggerService&) = delete;
~CfmERPLoggerService() override = default;
private:
std::unique_ptr<Delegate> reporting_pipeline_;
// Note: This should remain the last member so it'll be destroyed and
// invalidate its weak pointers before any other members are destroyed.
base::WeakPtrFactory<CfmERPLoggerService> weak_ptr_factory_{this};
};
static CfmLoggerService* g_logger_service = nullptr;
mojom::LoggerStatusPtr LoggerDisabledStatus() {
// The operation is not implemented or is not supported/enabled in this
// service.
return mojom::LoggerStatus::New(mojom::LoggerErrorCode::kUnimplemented,
"Meet logger service is disabled");
}
} // namespace
// static
void CfmLoggerService::Initialize() {
CHECK(!g_logger_service);
g_logger_service = new CfmERPLoggerService();
}
// static
void CfmLoggerService::InitializeForTesting(Delegate* delegate) {
CHECK(!g_logger_service);
g_logger_service = new CfmLoggerService(delegate);
}
// static
void CfmLoggerService::Shutdown() {
CHECK(g_logger_service);
delete g_logger_service;
g_logger_service = nullptr;
}
// static
CfmLoggerService* CfmLoggerService::Get() {
CHECK(g_logger_service)
<< "CfmLoggerService::Get() called before Initialize()";
return g_logger_service;
}
// static
bool CfmLoggerService::IsInitialized() {
return g_logger_service;
}
bool CfmLoggerService::ServiceRequestReceived(
const std::string& interface_name) {
// If Disabled should not be discoverable
if (interface_name != mojom::MeetDevicesLogger::Name_) {
return false;
}
service_adaptor_.BindServiceAdaptor();
return true;
}
void CfmLoggerService::OnBindService(
mojo::ScopedMessagePipeHandle receiver_pipe) {
receivers_.Add(this, mojo::PendingReceiver<mojom::MeetDevicesLogger>(
std::move(receiver_pipe)));
}
void CfmLoggerService::OnAdaptorConnect(bool success) {
if (!success) {
LOG(ERROR) << "Adaptor connection failed.";
return;
}
VLOG(3) << "Adaptor is connected.";
delegate_->Init();
}
void CfmLoggerService::OnAdaptorDisconnect() {
LOG(ERROR)
<< "mojom::MeetDevicesLogger Service Adaptor has been disconnected";
// CleanUp to follow the lifecycle of the primary CfmServiceContext
receivers_.Clear();
delegate_->Reset();
}
void CfmLoggerService::Enqueue(const std::string& record,
mojom::EnqueuePriority priority,
EnqueueCallback callback) {
if (current_logger_state_ == mojom::LoggerState::kDisabled) {
std::move(callback).Run(LoggerDisabledStatus());
return;
}
delegate_->Enqueue(std::move(record), std::move(priority),
std::move(callback));
}
void CfmLoggerService::AddStateObserver(
mojo::PendingRemote<mojom::LoggerStateObserver> pending_observer) {
mojo::Remote<mojom::LoggerStateObserver> observer(
std::move(pending_observer));
observer->OnNotifyState(current_logger_state_);
observer_list_.Add(std::move(observer));
}
void CfmLoggerService::NotifyStateObserver(mojom::LoggerState state) {
current_logger_state_ = state;
for (auto& observer : observer_list_) {
observer->OnNotifyState(current_logger_state_);
}
}
void CfmLoggerService::SetDelegate(Delegate* delegate) {
delegate_ = delegate;
}
// private
CfmLoggerService::CfmLoggerService(Delegate* delegate)
: delegate_(delegate),
service_adaptor_(mojom::MeetDevicesLogger::Name_, this),
current_logger_state_(mojom::LoggerState::kUninitialized) {
CfmHotlineClient::Get()->AddObserver(this);
if (!base::FeatureList::IsEnabled(features::kCloudLogger)) {
current_logger_state_ = mojom::LoggerState::kDisabled;
}
}
CfmLoggerService::~CfmLoggerService() {
CfmHotlineClient::Get()->RemoveObserver(this);
}
} // namespace ash::cfm
|
