[Offline pages] Add a builder and feature struct to policy

components/offline_pages/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/client_policy_controller.h"
 
 #include <utility>
 
 #include "base/time/time.h"
 #include "components/offline_pages/client_namespace_constants.h"
 
 using LifetimeType = offline_pages::LifetimePolicy::LifetimeType;
 
 namespace offline_pages {
 
 ClientPolicyController::ClientPolicyController() {
   policies_.clear();
   // Manually defining client policies for bookmark and last_n.
   policies_.insert(std::make_pair(
       kBookmarkNamespace,

[fgorski, 2016/09/07 03:25:04]

should be removed on cache reset.

[chili, 2016/09/12 17:39:00]

Changed so that the policy defaults to delete on cache reset

       MakePolicy(kBookmarkNamespace, LifetimeType::TEMPORARY,
                  base::TimeDelta::FromDays(7), kUnlimitedPages, 1)));
   policies_.insert(std::make_pair(
       kLastNNamespace, MakePolicy(kLastNNamespace, LifetimeType::TEMPORARY,

[fgorski, 2016/09/07 03:25:04]

should be removed on cache reset.

[chili, 2016/09/12 17:39:00]

Done.

                                   base::TimeDelta::FromDays(2), kUnlimitedPages,
                                   kUnlimitedPages)));
   policies_.insert(std::make_pair(
-      kAsyncNamespace, MakePolicy(kAsyncNamespace, LifetimeType::PERSISTENT,
-                                  base::TimeDelta::FromDays(2), kUnlimitedPages,
-                                  kUnlimitedPages)));
+      kAsyncNamespace,
+      OfflinePageClientPolicyBuilder(
+          kAsyncNamespace, LifetimeType::PERSISTENT,
+          kUnlimitedPages, kUnlimitedPages)
+          .SetIsSupportedByDownload(true)
+          .SetIsRemovedOnCacheReset(true)

[fgorski, 2016/09/07 03:25:04]

[This comment was added first, before I marked other places in file.]

Items that were requested by the user, like async and downloads are not supposed
to be removed by cache reset. Hence when the flag was renamed, we should reverse
the value of the flag. (Here and in other marked places.)

[chili, 2016/09/12 17:39:00]

Done.

+          .Build()));
   policies_.insert(std::make_pair(
       kCCTNamespace,

[fgorski, 2016/09/07 03:25:04]

discuss with dewittj@, but should probably not be removed on cache reset, as
this one is controlled externally.

[chili, 2016/09/12 17:39:00]

Acknowledged.  Will talk with dewittj@ when he gets in the office

       MakePolicy(kCCTNamespace, LifetimeType::TEMPORARY,
                  base::TimeDelta::FromDays(2), kUnlimitedPages, 1)));
-
   policies_.insert(std::make_pair(
-      kDownloadNamespace, MakePolicy(kDownloadNamespace,
+      kDownloadNamespace,
+      OfflinePageClientPolicyBuilder(
+          kDownloadNamespace,
+          LifetimeType::PERSISTENT,
+          kUnlimitedPages,
+          kUnlimitedPages)
+          .SetIsRemovedOnCacheReset(true)
+          .SetIsSupportedByDownload(true)

[fgorski, 2016/09/07 03:25:05]

should not be removed on cache reset.

[chili, 2016/09/12 17:39:00]

Done.

+          .Build()));
+  policies_.insert(std::make_pair(
+      kNTPSuggestionsNamespace,
+      OfflinePageClientPolicyBuilder(kNTPSuggestionsNamespace,
                                      LifetimeType::PERSISTENT,
-                                     base::TimeDelta::FromDays(0),
                                      kUnlimitedPages,
-                                     kUnlimitedPages)));
-  policies_.insert(std::make_pair(
-      kNTPSuggestionsNamespace, MakePolicy(kNTPSuggestionsNamespace,
-                                           LifetimeType::PERSISTENT,
-                                           base::TimeDelta::FromDays(0),
-                                           kUnlimitedPages,
-                                           kUnlimitedPages)));
+                                     kUnlimitedPages).Build()));
 
   // Fallback policy.
   policies_.insert(std::make_pair(
       kDefaultNamespace, MakePolicy(kDefaultNamespace, LifetimeType::TEMPORARY,

[fgorski, 2016/09/07 03:25:04]

should be removed on cache reset.

[chili, 2016/09/12 17:39:00]

Done.

                                     base::TimeDelta::FromDays(1), 10, 1)));
 }
 
 ClientPolicyController::~ClientPolicyController() {}
 
 // static
 const OfflinePageClientPolicy ClientPolicyController::MakePolicy(
     const std::string& name_space,
     LifetimeType lifetime_type,
     const base::TimeDelta& expire_period,
     size_t page_limit,
     size_t pages_allowed_per_url) {
-  OfflinePageClientPolicy policy({name_space,
-                                  {lifetime_type, expire_period, page_limit},
-                                  pages_allowed_per_url});
-  return policy;
+  return OfflinePageClientPolicyBuilder(
+      name_space, lifetime_type, page_limit, pages_allowed_per_url)
+      .SetExpirePeriod(expire_period)
+      .Build();
 }
 
 const OfflinePageClientPolicy& ClientPolicyController::GetPolicy(
     const std::string& name_space) const {
   const auto& iter = policies_.find(name_space);
   if (iter != policies_.end())
     return iter->second;
   // Fallback when the namespace isn't defined.
   return policies_.at(kDefaultNamespace);
 }
 
+bool ClientPolicyController::IsRemovedOnCacheReset(
+    const std::string& name_space) const {
+  return GetPolicy(name_space).feature_policy.is_removed_on_cache_reset;
+}
+
+bool ClientPolicyController::IsSupportedByDownload(
+    const std::string& name_space) const {
+  return GetPolicy(name_space).feature_policy.is_supported_by_download;
+}
+

[fgorski, 2016/09/07 03:25:04]

nit: remove extra empty line.

[chili, 2016/09/12 17:39:00]

Done.

+
 }  // namespace offline_pages