Offline Pages - Policy cleanup

components/offline_pages/core/client_policy_controller.cc

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/offline_pages/core/client_policy_controller.h"
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
@@ skipping 20 matching lines @@
           .Build()));
   policies_.insert(std::make_pair(
       kAsyncNamespace,
       OfflinePageClientPolicyBuilder(kAsyncNamespace, LifetimeType::PERSISTENT,
                                      kUnlimitedPages, kUnlimitedPages)
           .SetIsSupportedByDownload(true)
           .SetIsRemovedOnCacheReset(false)
           .Build()));
   policies_.insert(std::make_pair(
       kCCTNamespace,
-      MakePolicy(kCCTNamespace, LifetimeType::TEMPORARY,
-                 base::TimeDelta::FromDays(2), kUnlimitedPages, 1)));
+      OfflinePageClientPolicyBuilder(kCCTNamespace, LifetimeType::TEMPORARY,
+                                     kUnlimitedPages, 1)
+          .SetExpirePeriod(base::TimeDelta::FromDays(2))
+          .SetIsDisabledWhenPrefetchDisabled(true)
+          .Build()));
   policies_.insert(std::make_pair(
       kDownloadNamespace, OfflinePageClientPolicyBuilder(
                               kDownloadNamespace, LifetimeType::PERSISTENT,
                               kUnlimitedPages, kUnlimitedPages)
                               .SetIsRemovedOnCacheReset(false)
                               .SetIsSupportedByDownload(true)
                               .Build()));
   policies_.insert(std::make_pair(
       kNTPSuggestionsNamespace,
       OfflinePageClientPolicyBuilder(kNTPSuggestionsNamespace,
                                      LifetimeType::PERSISTENT, kUnlimitedPages,
                                      kUnlimitedPages)
           .SetIsSupportedByDownload(true)
+          .SetIsRemovedOnCacheReset(false)
           .Build()));
   policies_.insert(std::make_pair(
       kSuggestedArticlesNamespace,
       OfflinePageClientPolicyBuilder(kSuggestedArticlesNamespace,
                                      LifetimeType::TEMPORARY, kUnlimitedPages,
                                      kUnlimitedPages)
           .SetIsRemovedOnCacheReset(true)
+          .SetIsDisabledWhenPrefetchDisabled(true)
           .SetExpirePeriod(base::TimeDelta::FromDays(30))
           .Build()));
 
   // Fallback policy.
   policies_.insert(std::make_pair(
       kDefaultNamespace, MakePolicy(kDefaultNamespace, LifetimeType::TEMPORARY,
                                     base::TimeDelta::FromDays(1), 10, 1)));
 }
 
 ClientPolicyController::~ClientPolicyController() {}
@@ skipping 82 matching lines @@
 
   show_in_original_tab_cache_ = base::MakeUnique<std::vector<std::string>>();
   for (const auto& policy_item : policies_) {
     if (policy_item.second.feature_policy.only_shown_in_original_tab)
       show_in_original_tab_cache_->emplace_back(policy_item.first);
   }
 
   return *show_in_original_tab_cache_;
 }
 
+bool ClientPolicyController::IsDisabledWhenPrefetchDisabled(
+    const std::string& name_space) const {
+  return GetPolicy(name_space).feature_policy.disabled_when_prefetch_disabled;
+}
+
+const std::vector<std::string>&
+ClientPolicyController::GetNamespacesDisabledWhenPrefetchDisabled() const {
+  if (disabled_when_prefetch_disabled_cache_)
+    return *disabled_when_prefetch_disabled_cache_;
+
+  disabled_when_prefetch_disabled_cache_ =
+      base::MakeUnique<std::vector<std::string>>();
+  for (const auto& policy_item : policies_) {
+    if (policy_item.second.feature_policy.disabled_when_prefetch_disabled)
+      disabled_when_prefetch_disabled_cache_->emplace_back(policy_item.first);
+  }
+
+  return *disabled_when_prefetch_disabled_cache_;
+}
+
 void ClientPolicyController::AddPolicyForTest(
     const std::string& name_space,
     const OfflinePageClientPolicyBuilder& builder) {
   policies_.insert(std::make_pair(name_space, builder.Build()));
 }
 
 }  // namespace offline_pages