// 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 "ash/webui/help_app_ui/search/search_concept.h"
#include <cstddef>
#include <iostream>
#include <memory>
#include "base/files/file_path.h"
#include "base/files/file_util.h"
#include "base/files/important_file_writer.h"
#include "base/functional/bind.h"
#include "base/metrics/histogram_functions.h"
#include "base/strings/utf_string_conversions.h"
#include "base/task/bind_post_task.h"
#include "base/task/thread_pool.h"
#include "base/threading/scoped_blocking_call.h"
namespace ash::help_app {
namespace {
using Concept = SearchConceptProto::Concept;
constexpr char kReadHistogram[] =
"Discover.SearchConcept.PersistenceReadStatus";
constexpr char kWriteHistogram[] =
"Discover.SearchConcept.PersistenceWriteStatus";
// The result of reading a backing file from disk. These values persist to logs.
// Entries should not be renumbered and numeric values should never be reused.
enum class ReadStatus {
kOk = 0,
kMissing = 1,
kReadError = 2,
kParseError = 3,
kMaxValue = kParseError,
};
// The result of writing a backing file to disk. These values persist to logs.
// Entries should not be renumbered and numeric values should never be reused.
enum class WriteStatus {
kOk = 0,
kWriteError = 1,
kSerializationError = 2,
kReplaceError = 3,
kMaxValue = kReplaceError,
};
// This should be incremented whenever a change to the search concept is made
// that is incompatible with on-disk state. On reading, any state is wiped if
// its version doesn't match.
constexpr int32_t kVersion = 1;
// Read proto from the disk.
std::unique_ptr<SearchConceptProto> ProtoRead(const base::FilePath& file_path) {
base::ScopedBlockingCall scoped_blocking_call(FROM_HERE,
base::BlockingType::MAY_BLOCK);
if (!base::PathExists(file_path)) {
base::UmaHistogramEnumeration(kReadHistogram, ReadStatus::kMissing);
return nullptr;
}
std::string proto_str;
if (!base::ReadFileToString(file_path, &proto_str)) {
base::UmaHistogramEnumeration(kReadHistogram, ReadStatus::kReadError);
return nullptr;
}
auto proto = std::make_unique<SearchConceptProto>();
if (!proto->ParseFromString(proto_str)) {
base::UmaHistogramEnumeration(kReadHistogram, ReadStatus::kParseError);
return nullptr;
}
base::UmaHistogramEnumeration(kReadHistogram, ReadStatus::kOk);
// Discard the proto if the version does not match.
if (!proto->has_version() || proto->version() != kVersion) {
base::DeleteFile(file_path);
return nullptr;
}
return proto;
}
// Write proto to the disk.
void ProtoWrite(std::unique_ptr<SearchConceptProto> proto,
const base::FilePath& file_path,
const base::FilePath& temp_file_path) {
std::string proto_str;
if (!proto->SerializeToString(&proto_str)) {
base::UmaHistogramEnumeration(kWriteHistogram,
WriteStatus::kSerializationError);
return;
}
const auto directory = temp_file_path.DirName();
if (!base::DirectoryExists(directory)) {
base::CreateDirectory(directory);
}
// Write temporary proto to `temp_file_path_`.
bool write_succeed;
{
base::ScopedBlockingCall scoped_blocking_call(
FROM_HERE, base::BlockingType::MAY_BLOCK);
write_succeed = base::ImportantFileWriter::WriteFileAtomically(
temp_file_path, proto_str, "HelpAppPersistentProto");
}
if (!write_succeed) {
base::UmaHistogramEnumeration(kWriteHistogram, WriteStatus::kWriteError);
return;
}
// Replace the proto in `file_path_` by the temporary proto if the write is
// succeed.
const bool replace_succeed =
base::ReplaceFile(temp_file_path, file_path, nullptr);
base::UmaHistogramEnumeration(
kWriteHistogram,
replace_succeed ? WriteStatus::kOk : WriteStatus::kReplaceError);
}
} // namespace
SearchConcept::SearchConcept(const base::FilePath& file_path)
: file_path_(file_path),
temp_file_path_(file_path.DirName().AppendASCII("tmp.pb")),
task_runner_(base::ThreadPool::CreateSequencedTaskRunner(
{base::TaskPriority::BEST_EFFORT, base::MayBlock(),
base::TaskShutdownBehavior::SKIP_ON_SHUTDOWN})) {}
SearchConcept::~SearchConcept() = default;
void SearchConcept::GetSearchConcepts(ReadCallback on_read) {
task_runner_->PostTaskAndReplyWithResult(
FROM_HERE, base::BindOnce(&ProtoRead, file_path_),
base::BindOnce(&SearchConcept::OnProtoRead, weak_factory_.GetWeakPtr(),
base::BindPostTaskToCurrentDefault(std::move(on_read))));
}
void SearchConcept::UpdateSearchConcepts(
const std::vector<mojom::SearchConceptPtr>& search_concepts) {
// Ignore the request if the SearchConcepts is empty.
if (search_concepts.empty()) {
return;
}
std::unique_ptr<SearchConceptProto> proto =
std::make_unique<SearchConceptProto>();
proto->set_version(kVersion);
auto& proto_concepts = *proto->mutable_concepts();
for (const auto& search_concept : search_concepts) {
Concept& proto_concept = *proto_concepts.Add();
proto_concept.set_id(search_concept->id);
proto_concept.set_title(base::UTF16ToUTF8(search_concept->title));
proto_concept.set_main_category(
base::UTF16ToUTF8(search_concept->main_category));
auto& proto_tags = *proto_concept.mutable_tags();
for (const auto& search_tag : search_concept->tags) {
proto_tags.Add(base::UTF16ToUTF8(search_tag));
}
proto_concept.set_tag_locale(search_concept->tag_locale);
proto_concept.set_url_path_with_parameters(
search_concept->url_path_with_parameters);
proto_concept.set_locale(search_concept->locale);
}
task_runner_->PostTask(
FROM_HERE, base::BindOnce(&ProtoWrite, std::move(proto), file_path_,
temp_file_path_));
}
void SearchConcept::OnProtoRead(ReadCallback on_read,
std::unique_ptr<SearchConceptProto> proto) {
std::vector<mojom::SearchConceptPtr> search_concepts;
if (!proto) {
std::move(on_read).Run(std::move(search_concepts));
return;
}
const auto proto_concepts = proto->concepts();
if (proto_concepts.empty()) {
std::move(on_read).Run(std::move(search_concepts));
return;
}
// convert the concepts of proto into
// `std::vector<mojom::SearchConceptPtr>`.
for (const auto& proto_concept : proto_concepts) {
mojom::SearchConceptPtr search_concept = mojom::SearchConcept::New();
search_concept->id = proto_concept.id();
search_concept->title = base::UTF8ToUTF16(proto_concept.title());
search_concept->main_category =
base::UTF8ToUTF16(proto_concept.main_category());
std::vector<::std::u16string> search_tags;
for (const auto& tag : proto_concept.tags()) {
search_tags.push_back(base::UTF8ToUTF16(tag));
}
search_concept->tags = search_tags;
search_concept->tag_locale = proto_concept.tag_locale();
search_concept->url_path_with_parameters =
proto_concept.url_path_with_parameters();
search_concept->locale = proto_concept.locale();
search_concepts.push_back(std::move(search_concept));
}
std::move(on_read).Run(std::move(search_concepts));
}
} // namespace ash::help_app
Codebase Browser
chromium