init_aware_tile_service.cc 5.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157
  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/init_aware_tile_service.h"
  5. #include "base/bind.h"
  6. #include "base/callback_helpers.h"
  7. #include "base/threading/thread_task_runner_handle.h"
  8. namespace query_tiles {
  9. InitAwareTileService::InitAwareTileService(
  10. std::unique_ptr<InitializableTileService> tile_service)
  11. : tile_service_(std::move(tile_service)) {
  12. tile_service_->Initialize(
  13. base::BindOnce(&InitAwareTileService::OnTileServiceInitialized,
  14. weak_ptr_factory_.GetWeakPtr()));
  15. }
  16. void InitAwareTileService::OnTileServiceInitialized(bool success) {
  17. DCHECK(!init_success_.has_value());
  18. init_success_ = success;
  19. // Flush all cached calls in FIFO sequence.
  20. while (!cached_api_calls_.empty()) {
  21. auto api_call = std::move(cached_api_calls_.front());
  22. cached_api_calls_.pop_front();
  23. std::move(api_call).Run();
  24. }
  25. }
  26. void InitAwareTileService::GetQueryTiles(GetTilesCallback callback) {
  27. if (IsReady()) {
  28. tile_service_->GetQueryTiles(std::move(callback));
  29. return;
  30. }
  31. if (IsFailed()) {
  32. base::ThreadTaskRunnerHandle::Get()->PostTask(
  33. FROM_HERE, base::BindOnce(std::move(callback), TileList()));
  34. return;
  35. }
  36. MaybeCacheApiCall(base::BindOnce(&InitAwareTileService::GetQueryTiles,
  37. weak_ptr_factory_.GetWeakPtr(),
  38. std::move(callback)));
  39. }
  40. void InitAwareTileService::GetTile(const std::string& tile_id,
  41. TileCallback callback) {
  42. if (IsReady()) {
  43. tile_service_->GetTile(tile_id, std::move(callback));
  44. return;
  45. }
  46. if (IsFailed()) {
  47. base::ThreadTaskRunnerHandle::Get()->PostTask(
  48. FROM_HERE, base::BindOnce(std::move(callback), absl::nullopt));
  49. return;
  50. }
  51. MaybeCacheApiCall(base::BindOnce(&InitAwareTileService::GetTile,
  52. weak_ptr_factory_.GetWeakPtr(), tile_id,
  53. std::move(callback)));
  54. }
  55. void InitAwareTileService::StartFetchForTiles(
  56. bool is_from_reduced_mode,
  57. BackgroundTaskFinishedCallback callback) {
  58. if (IsReady()) {
  59. tile_service_->StartFetchForTiles(is_from_reduced_mode,
  60. std::move(callback));
  61. return;
  62. }
  63. if (IsFailed()) {
  64. base::ThreadTaskRunnerHandle::Get()->PostTask(
  65. FROM_HERE,
  66. base::BindOnce(std::move(callback), false /*need_reschedule*/));
  67. return;
  68. }
  69. MaybeCacheApiCall(base::BindOnce(&InitAwareTileService::StartFetchForTiles,
  70. weak_ptr_factory_.GetWeakPtr(),
  71. is_from_reduced_mode, std::move(callback)));
  72. }
  73. void InitAwareTileService::CancelTask() {
  74. if (IsReady()) {
  75. tile_service_->CancelTask();
  76. } else if (!IsFailed()) {
  77. MaybeCacheApiCall(base::BindOnce(&InitAwareTileService::CancelTask,
  78. weak_ptr_factory_.GetWeakPtr()));
  79. }
  80. }
  81. void InitAwareTileService::PurgeDb() {
  82. if (IsReady()) {
  83. tile_service_->PurgeDb();
  84. } else if (!IsFailed()) {
  85. MaybeCacheApiCall(base::BindOnce(&InitAwareTileService::PurgeDb,
  86. weak_ptr_factory_.GetWeakPtr()));
  87. }
  88. }
  89. void InitAwareTileService::SetServerUrl(const std::string& base_url) {
  90. if (IsReady()) {
  91. tile_service_->SetServerUrl(base_url);
  92. } else if (!IsFailed()) {
  93. MaybeCacheApiCall(base::BindOnce(&InitAwareTileService::SetServerUrl,
  94. weak_ptr_factory_.GetWeakPtr(), base_url));
  95. }
  96. }
  97. void InitAwareTileService::OnTileClicked(const std::string& tile_id) {
  98. if (IsReady()) {
  99. tile_service_->OnTileClicked(tile_id);
  100. } else if (!IsFailed()) {
  101. MaybeCacheApiCall(base::BindOnce(&InitAwareTileService::OnTileClicked,
  102. weak_ptr_factory_.GetWeakPtr(), tile_id));
  103. }
  104. }
  105. void InitAwareTileService::OnQuerySelected(
  106. const absl::optional<std::string>& parent_tile_id,
  107. const std::u16string& query_text) {
  108. if (IsReady()) {
  109. tile_service_->OnQuerySelected(std::move(parent_tile_id), query_text);
  110. } else if (!IsFailed()) {
  111. MaybeCacheApiCall(base::BindOnce(&InitAwareTileService::OnQuerySelected,
  112. weak_ptr_factory_.GetWeakPtr(),
  113. std::move(parent_tile_id), query_text));
  114. }
  115. }
  116. Logger* InitAwareTileService::GetLogger() {
  117. return tile_service_->GetLogger();
  118. }
  119. void InitAwareTileService::MaybeCacheApiCall(base::OnceClosure api_call) {
  120. DCHECK(!init_success_.has_value())
  121. << "Only cache API calls before initialization.";
  122. cached_api_calls_.emplace_back(std::move(api_call));
  123. }
  124. bool InitAwareTileService::IsReady() const {
  125. return init_success_.has_value() && init_success_.value();
  126. }
  127. bool InitAwareTileService::IsFailed() const {
  128. return init_success_.has_value() && !init_success_.value();
  129. }
  130. InitAwareTileService::~InitAwareTileService() = default;
  131. } // namespace query_tiles