// Copyright 2023 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chromeos/ash/components/dbus/featured/featured_client.h"
#include <memory>
#include <string>
#include <string_view>
#include "base/check_is_test.h"
#include "base/files/dir_reader_posix.h"
#include "base/files/file_path.h"
#include "base/files/file_path_watcher.h"
#include "base/files/file_util.h"
#include "base/functional/callback.h"
#include "base/logging.h"
#include "base/memory/raw_ptr.h"
#include "base/metrics/field_trial.h"
#include "base/strings/escape.h"
#include "base/strings/string_split.h"
#include "base/task/thread_pool.h"
#include "chromeos/ash/components/dbus/featured/fake_featured_client.h"
#include "chromeos/ash/components/dbus/featured/featured.pb.h"
#include "dbus/bus.h"
#include "dbus/message.h"
#include "dbus/object_proxy.h"
#include "third_party/cros_system_api/constants/featured.h"
#include "third_party/cros_system_api/dbus/service_constants.h"
namespace ash::featured {
namespace {
FeaturedClient* g_instance = nullptr;
struct FileWatchOptions {
FeaturedClient::ListenForTrialCallback listen_callback;
const base::FilePath expected_dir;
};
void RecordEarlyBootTrialInUMA(const std::string& trial_name,
const std::string& group_name) {
base::FieldTrial* trial =
base::FieldTrialList::CreateFieldTrial(trial_name, group_name);
// This records the trial in UMA.
trial->Activate();
}
// Assumes |filename| is valid (that its directory name is correct).
bool RecordEarlyBootTrialInChrome(
FeaturedClient::ListenForTrialCallback listen_callback,
const base::FilePath& filename) {
base::FieldTrial::ActiveGroup active_group;
if (!FeaturedClient::ParseTrialFilename(filename, active_group)) {
return false;
}
listen_callback.Run(active_group.trial_name, active_group.group_name);
return true;
}
void RecordEarlyBootTrialAfterChromeStartup(
const FileWatchOptions& opts,
const base::FilePathWatcher::ChangeInfo& change_info,
const base::FilePath& path,
bool error) {
if (error || path.DirName() != opts.expected_dir) {
// TODO(b/296394808): Add UMA metric if we enter this code path since it
// is not expected.
return;
}
if (change_info.file_path_type !=
base::FilePathWatcher::FilePathType::kFile ||
change_info.change_type != base::FilePathWatcher::ChangeType::kCreated) {
// Only record field trial files that were just created. We do not want to
// record a field trial on any of the other change options like
// base::FilePathWatcher::ChangeType::kModified or
// base::FilePathWatcher::ChangeType::kDeleted.
return;
}
// TODO(b/296394808): Add UMA metric if unable to record trial due to parse
// error.
RecordEarlyBootTrialInChrome(opts.listen_callback, path);
}
void ListenForActiveEarlyBootTrials(base::FilePathWatcher* watcher,
const FileWatchOptions& opts) {
base::FilePathWatcher::WatchOptions options = {
// Watches for changes in a directory.
.type = base::FilePathWatcher::Type::kRecursive,
// Reports the path of modified files in the directory.
.report_modified_path = true};
watcher->WatchWithChangeInfo(
opts.expected_dir, options,
base::BindRepeating(&RecordEarlyBootTrialAfterChromeStartup, opts));
}
void ReadTrialsActivatedBeforeChromeStartup(const FileWatchOptions& opts) {
base::DirReaderPosix reader(opts.expected_dir.value().c_str());
if (!reader.IsValid()) {
// TODO(b/296394808): Add UMA metric if we are unable to enumerate trials
// activated before Chrome startup.
return;
}
while (reader.Next()) {
if (std::string(reader.name()) == "." ||
std::string(reader.name()) == "..") {
continue;
}
// TODO(b/296394808): Add UMA metric if unable to record trial due to
// parse error.
RecordEarlyBootTrialInChrome(opts.listen_callback,
base::FilePath(reader.name()));
}
}
// We need to delete the FilePathWatcher instance via a posted task since we
// call FilePathWatche::Watch() on a posted task. The documentation states the
// instance must be destroyed on the same sequence it watches from.
void DeleteWatcher(std::unique_ptr<base::FilePathWatcher> watcher) {
watcher.reset();
}
// Production implementation of FeaturedClient.
class FeaturedClientImpl : public FeaturedClient {
public:
FeaturedClientImpl() : watcher_(std::make_unique<base::FilePathWatcher>()) {}
FeaturedClientImpl(const FeaturedClient&) = delete;
FeaturedClientImpl operator=(const FeaturedClient&) = delete;
~FeaturedClientImpl() override {
file_listener_task_runner_->PostTask(
FROM_HERE, base::BindOnce(&DeleteWatcher, std::move(watcher_)));
}
void Init(dbus::Bus* const bus) {
InitWithCallback(bus, base::FilePath(feature::kActiveTrialFileDirectory),
base::BindRepeating(&RecordEarlyBootTrialInUMA));
}
void InitForTesting(dbus::Bus* const bus, // IN-TEST
const base::FilePath& expected_dir,
ListenForTrialCallback callback) {
CHECK_IS_TEST();
InitWithCallback(bus, expected_dir, callback);
}
void HandleSeedFetchedResponse(
base::OnceCallback<void(bool success)> callback,
dbus::Response* response) {
if (!response ||
response->GetMessageType() != dbus::Message::MESSAGE_METHOD_RETURN) {
LOG(WARNING) << "Received invalid response for HandleSeedFetched";
std::move(callback).Run(false);
return;
}
std::move(callback).Run(true);
}
void HandleSeedFetched(
const ::featured::SeedDetails& safe_seed,
base::OnceCallback<void(bool success)> callback) override {
dbus::MethodCall method_call(::featured::kFeaturedInterface,
"HandleSeedFetched");
dbus::MessageWriter writer(&method_call);
writer.AppendProtoAsArrayOfBytes(safe_seed);
featured_service_proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::BindOnce(&FeaturedClientImpl::HandleSeedFetchedResponse,
weak_ptr_factory_.GetWeakPtr(), std::move(callback)));
}
private:
void InitWithCallback(dbus::Bus* const bus,
const base::FilePath& expected_dir,
ListenForTrialCallback callback) {
featured_service_proxy_ =
bus->GetObjectProxy(::featured::kFeaturedServiceName,
dbus::ObjectPath(::featured::kFeaturedServicePath));
expected_dir_ = expected_dir;
listen_callback_ = callback;
FileWatchOptions opts = {.listen_callback = callback,
.expected_dir = expected_dir};
file_listener_task_runner_->PostTask(
FROM_HERE,
base::BindOnce(&ListenForActiveEarlyBootTrials, watcher_.get(), opts));
file_listener_task_runner_->PostTask(
FROM_HERE,
base::BindOnce(&ReadTrialsActivatedBeforeChromeStartup, opts));
}
// Callback used when early-boot trial files are written to `expected_dir_`.
FeaturedClient::ListenForTrialCallback listen_callback_;
// Directory where active trial files on platform are written to.
base::FilePath expected_dir_;
// Watches for early-boot trial files written to `expected_dir_`.
std::unique_ptr<base::FilePathWatcher> watcher_;
raw_ptr<dbus::ObjectProxy> featured_service_proxy_ = nullptr;
// Sequence runner that an post tasks that may block.
scoped_refptr<base::SequencedTaskRunner> file_listener_task_runner_ =
base::ThreadPool::CreateSequencedTaskRunner(
{base::MayBlock(), base::TaskPriority::BEST_EFFORT});
// 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<FeaturedClientImpl> weak_ptr_factory_{this};
};
} // namespace
FeaturedClient::FeaturedClient() {
DCHECK(!g_instance);
g_instance = this;
}
FeaturedClient::~FeaturedClient() {
DCHECK_EQ(this, g_instance);
g_instance = nullptr;
}
// static
void FeaturedClient::Initialize(dbus::Bus* bus) {
DCHECK(bus);
(new FeaturedClientImpl())->Init(bus);
}
// static
void FeaturedClient::InitializeFake() {
new FakeFeaturedClient();
}
// static
void FeaturedClient::InitializeForTesting(dbus::Bus* bus,
const base::FilePath& expected_dir,
ListenForTrialCallback callback) {
DCHECK(bus);
(new FeaturedClientImpl())
->InitForTesting(bus, expected_dir, callback); // IN-TEST
}
// static
void FeaturedClient::Shutdown() {
DCHECK(g_instance);
delete g_instance;
}
// static
FeaturedClient* FeaturedClient::Get() {
return g_instance;
}
// static
bool FeaturedClient::ParseTrialFilename(
const base::FilePath& path,
base::FieldTrial::ActiveGroup& active_group) {
std::string filename = path.BaseName().value();
std::vector<std::string_view> components =
base::SplitStringPiece(filename, feature::kTrialGroupSeparator,
base::KEEP_WHITESPACE, base::SPLIT_WANT_ALL);
if (components.size() != 2) {
LOG(ERROR) << "Active trial filename not of the form TrialName,GroupName: "
<< filename;
return false;
}
std::string trial_name = base::UnescapeURLComponent(
components[0],
base::UnescapeRule::SPACES | base::UnescapeRule::PATH_SEPARATORS |
base::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS);
std::string group_name = base::UnescapeURLComponent(
components[1],
base::UnescapeRule::SPACES | base::UnescapeRule::PATH_SEPARATORS |
base::UnescapeRule::URL_SPECIAL_CHARS_EXCEPT_PATH_SEPARATORS);
active_group.trial_name = trial_name;
active_group.group_name = group_name;
return true;
}
} // namespace ash::featured
Codebase Browser
chromium