tile_service_impl.cc 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159
  1. // Copyright 2020 The Chromium Authors. All rights reserved.
  2. // Use of this source code is governed by a BSD-style license that can be
  3. // found in the LICENSE file.
  4. #include "components/query_tiles/internal/tile_service_impl.h"
  5. #include <string>
  6. #include <utility>
  7. #include "base/bind.h"
  8. #include "base/callback_helpers.h"
  9. #include "base/guid.h"
  10. #include "base/rand_util.h"
  11. #include "base/threading/thread_task_runner_handle.h"
  12. #include "components/query_tiles/internal/proto_conversion.h"
  13. #include "components/query_tiles/internal/tile_config.h"
  14. namespace query_tiles {
  15. TileServiceImpl::TileServiceImpl(
  16. std::unique_ptr<ImagePrefetcher> image_prefetcher,
  17. std::unique_ptr<TileManager> tile_manager,
  18. std::unique_ptr<TileServiceScheduler> scheduler,
  19. std::unique_ptr<TileFetcher> tile_fetcher,
  20. base::Clock* clock,
  21. std::unique_ptr<Logger> logger)
  22. : image_prefetcher_(std::move(image_prefetcher)),
  23. tile_manager_(std::move(tile_manager)),
  24. scheduler_(std::move(scheduler)),
  25. tile_fetcher_(std::move(tile_fetcher)),
  26. clock_(clock),
  27. logger_(std::move(logger)) {}
  28. TileServiceImpl::~TileServiceImpl() = default;
  29. void TileServiceImpl::Initialize(SuccessCallback callback) {
  30. tile_manager_->Init(base::BindOnce(&TileServiceImpl::OnTileManagerInitialized,
  31. weak_ptr_factory_.GetWeakPtr(),
  32. std::move(callback)));
  33. }
  34. void TileServiceImpl::OnTileManagerInitialized(SuccessCallback callback,
  35. TileGroupStatus status) {
  36. bool success = (status == TileGroupStatus::kSuccess ||
  37. status == TileGroupStatus::kNoTiles);
  38. DCHECK(callback);
  39. scheduler_->SetDelegate(this);
  40. scheduler_->OnTileManagerInitialized(status);
  41. std::move(callback).Run(success);
  42. }
  43. void TileServiceImpl::GetQueryTiles(GetTilesCallback callback) {
  44. tile_manager_->GetTiles(true /*shuffle_tiles*/, std::move(callback));
  45. }
  46. void TileServiceImpl::GetTile(const std::string& tile_id,
  47. TileCallback callback) {
  48. tile_manager_->GetTile(tile_id, true /*shuffle_tiles*/, std::move(callback));
  49. }
  50. void TileServiceImpl::StartFetchForTiles(
  51. bool is_from_reduced_mode,
  52. BackgroundTaskFinishedCallback task_finished_callback) {
  53. DCHECK(tile_fetcher_);
  54. tile_fetcher_->StartFetchForTiles(base::BindOnce(
  55. &TileServiceImpl::OnFetchFinished, weak_ptr_factory_.GetWeakPtr(),
  56. is_from_reduced_mode, std::move(task_finished_callback)));
  57. scheduler_->OnFetchStarted();
  58. }
  59. void TileServiceImpl::CancelTask() {
  60. scheduler_->CancelTask();
  61. }
  62. void TileServiceImpl::PurgeDb() {
  63. auto status = tile_manager_->PurgeDb();
  64. scheduler_->OnDbPurged(status);
  65. }
  66. void TileServiceImpl::SetServerUrl(const std::string& base_url) {
  67. if (base_url.empty())
  68. return;
  69. tile_fetcher_->SetServerUrl(
  70. TileConfig::GetQueryTilesServerUrl(base_url, true));
  71. }
  72. void TileServiceImpl::OnFetchFinished(
  73. bool is_from_reduced_mode,
  74. BackgroundTaskFinishedCallback task_finished_callback,
  75. TileInfoRequestStatus status,
  76. const std::unique_ptr<std::string> response_body) {
  77. query_tiles::proto::ServerResponse response_proto;
  78. if (status == TileInfoRequestStatus::kSuccess) {
  79. bool parse_success = response_proto.ParseFromString(*response_body.get());
  80. if (parse_success) {
  81. TileGroup group;
  82. TileGroupFromResponse(response_proto, &group);
  83. group.id = base::GenerateGUID();
  84. group.last_updated_ts = clock_->Now();
  85. auto group_copy = std::make_unique<TileGroup>(group);
  86. tile_manager_->SaveTiles(
  87. std::move(group_copy),
  88. base::BindOnce(&TileServiceImpl::OnTilesSaved,
  89. weak_ptr_factory_.GetWeakPtr(), std::move(group),
  90. is_from_reduced_mode,
  91. std::move(task_finished_callback)));
  92. } else {
  93. status = TileInfoRequestStatus::kShouldSuspend;
  94. }
  95. } else {
  96. std::move(task_finished_callback).Run(false /*reschedule*/);
  97. }
  98. scheduler_->OnFetchCompleted(status);
  99. }
  100. void TileServiceImpl::OnTilesSaved(
  101. TileGroup tile_group,
  102. bool is_from_reduced_mode,
  103. BackgroundTaskFinishedCallback task_finished_callback,
  104. TileGroupStatus status) {
  105. scheduler_->OnGroupDataSaved(status);
  106. if (status != TileGroupStatus::kSuccess) {
  107. std::move(task_finished_callback).Run(false /*reschedule*/);
  108. return;
  109. }
  110. image_prefetcher_->Prefetch(
  111. std::move(tile_group), is_from_reduced_mode,
  112. base::BindOnce(&TileServiceImpl::OnPrefetchImagesDone,
  113. weak_ptr_factory_.GetWeakPtr(),
  114. std::move(task_finished_callback)));
  115. }
  116. void TileServiceImpl::OnPrefetchImagesDone(
  117. BackgroundTaskFinishedCallback task_finished_callback) {
  118. DCHECK(task_finished_callback);
  119. std::move(task_finished_callback).Run(false /*reschedule*/);
  120. }
  121. TileGroup* TileServiceImpl::GetTileGroup() {
  122. return tile_manager_->GetTileGroup();
  123. }
  124. void TileServiceImpl::OnTileClicked(const std::string& tile_id) {
  125. tile_manager_->OnTileClicked(tile_id);
  126. }
  127. void TileServiceImpl::OnQuerySelected(
  128. const absl::optional<std::string>& parent_tile_id,
  129. const std::u16string& query_text) {
  130. tile_manager_->OnQuerySelected(std::move(parent_tile_id), query_text);
  131. }
  132. Logger* TileServiceImpl::GetLogger() {
  133. return logger_.get();
  134. }
  135. } // namespace query_tiles