offline_page_client_policy.cc 5.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170
  1. // Copyright 2019 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/offline_pages/core/offline_page_client_policy.h"
  5. #include <map>
  6. #include <string>
  7. #include <utility>
  8. #include <vector>
  9. #include "base/no_destructor.h"
  10. #include "base/time/time.h"
  11. #include "components/offline_pages/core/client_namespace_constants.h"
  12. #include "components/offline_pages/core/offline_page_client_policy.h"
  13. namespace offline_pages {
  14. namespace {
  15. struct PolicyData {
  16. std::map<std::string, OfflinePageClientPolicy> policies;
  17. std::vector<std::string> temporary_namespaces;
  18. std::vector<std::string> persistent_namespaces;
  19. std::vector<std::string> all_namespaces;
  20. };
  21. PolicyData BuildPolicies() {
  22. std::vector<OfflinePageClientPolicy> all_policies;
  23. {
  24. auto policy = OfflinePageClientPolicy::CreateTemporary(kBookmarkNamespace,
  25. base::Days(7));
  26. policy.pages_allowed_per_url = 1;
  27. all_policies.push_back(policy);
  28. }
  29. {
  30. auto policy = OfflinePageClientPolicy::CreateTemporary(kLastNNamespace,
  31. base::Days(30));
  32. policy.is_restricted_to_tab_from_client_id = true;
  33. all_policies.push_back(policy);
  34. }
  35. {
  36. auto policy = OfflinePageClientPolicy::CreatePersistent(kAsyncNamespace);
  37. policy.is_supported_by_download = true;
  38. all_policies.push_back(policy);
  39. }
  40. {
  41. auto policy =
  42. OfflinePageClientPolicy::CreateTemporary(kCCTNamespace, base::Days(2));
  43. policy.pages_allowed_per_url = 1;
  44. policy.requires_specific_user_settings = true;
  45. all_policies.push_back(policy);
  46. }
  47. {
  48. auto policy = OfflinePageClientPolicy::CreatePersistent(kDownloadNamespace);
  49. policy.is_supported_by_download = true;
  50. all_policies.push_back(policy);
  51. }
  52. {
  53. auto policy =
  54. OfflinePageClientPolicy::CreatePersistent(kNTPSuggestionsNamespace);
  55. policy.is_supported_by_download = true;
  56. all_policies.push_back(policy);
  57. }
  58. {
  59. auto policy = OfflinePageClientPolicy::CreateTemporary(
  60. kSuggestedArticlesNamespace, base::Days(30));
  61. policy.is_supported_by_download = true;
  62. policy.is_suggested = true;
  63. all_policies.push_back(policy);
  64. }
  65. {
  66. auto policy =
  67. OfflinePageClientPolicy::CreatePersistent(kBrowserActionsNamespace);
  68. policy.is_supported_by_download = true;
  69. policy.allows_conversion_to_background_file_download = true;
  70. all_policies.push_back(policy);
  71. }
  72. {
  73. auto policy = OfflinePageClientPolicy::CreateTemporary(
  74. kLivePageSharingNamespace, base::Hours(1));
  75. policy.pages_allowed_per_url = 1;
  76. policy.is_restricted_to_tab_from_client_id = true;
  77. all_policies.push_back(policy);
  78. }
  79. {
  80. auto policy = OfflinePageClientPolicy::CreateTemporary(kAutoAsyncNamespace,
  81. base::Days(30));
  82. policy.pages_allowed_per_url = 1;
  83. policy.defer_background_fetch_while_page_is_active = true;
  84. all_policies.push_back(policy);
  85. }
  86. // Fallback policy.
  87. {
  88. OfflinePageClientPolicy policy = OfflinePageClientPolicy::CreateTemporary(
  89. kDefaultNamespace, base::Days(1));
  90. policy.page_limit = 10;
  91. policy.pages_allowed_per_url = 1;
  92. all_policies.push_back(policy);
  93. }
  94. PolicyData policy_data;
  95. for (const auto& policy : all_policies) {
  96. policy_data.all_namespaces.push_back(policy.name_space);
  97. switch (policy.lifetime_type) {
  98. case LifetimeType::TEMPORARY:
  99. policy_data.temporary_namespaces.push_back(policy.name_space);
  100. break;
  101. case LifetimeType::PERSISTENT:
  102. policy_data.persistent_namespaces.push_back(policy.name_space);
  103. break;
  104. }
  105. policy_data.policies.emplace(policy.name_space, policy);
  106. }
  107. return policy_data;
  108. }
  109. const PolicyData& GetPolicyData() {
  110. static base::NoDestructor<PolicyData> instance(BuildPolicies());
  111. return *instance;
  112. }
  113. } // namespace
  114. OfflinePageClientPolicy::OfflinePageClientPolicy(std::string namespace_val,
  115. LifetimeType lifetime_type_val)
  116. : name_space(namespace_val), lifetime_type(lifetime_type_val) {}
  117. // static
  118. OfflinePageClientPolicy OfflinePageClientPolicy::CreateTemporary(
  119. const std::string& name_space,
  120. const base::TimeDelta& expiration_period) {
  121. OfflinePageClientPolicy policy(name_space, LifetimeType::TEMPORARY);
  122. policy.expiration_period = expiration_period;
  123. return policy;
  124. }
  125. // static
  126. OfflinePageClientPolicy OfflinePageClientPolicy::CreatePersistent(
  127. const std::string& name_space) {
  128. return {name_space, LifetimeType::PERSISTENT};
  129. }
  130. OfflinePageClientPolicy::OfflinePageClientPolicy(
  131. const OfflinePageClientPolicy& other) = default;
  132. OfflinePageClientPolicy::~OfflinePageClientPolicy() = default;
  133. const OfflinePageClientPolicy& GetPolicy(const std::string& name) {
  134. const std::map<std::string, OfflinePageClientPolicy>& policies =
  135. GetPolicyData().policies;
  136. const auto& iter = policies.find(name);
  137. if (iter != policies.end())
  138. return iter->second;
  139. // Fallback when the namespace isn't defined.
  140. return policies.at(kDefaultNamespace);
  141. }
  142. const std::vector<std::string>& GetAllPolicyNamespaces() {
  143. return GetPolicyData().all_namespaces;
  144. }
  145. const std::vector<std::string>& GetTemporaryPolicyNamespaces() {
  146. return GetPolicyData().temporary_namespaces;
  147. }
  148. const std::vector<std::string>& GetPersistentPolicyNamespaces() {
  149. return GetPolicyData().persistent_namespaces;
  150. }
  151. } // namespace offline_pages