[Offline Pages] Adds new policy bits and reverse lookup.

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/memory/ptr_util.h"
 #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,
       MakePolicy(kBookmarkNamespace, LifetimeType::TEMPORARY,
                  base::TimeDelta::FromDays(7), kUnlimitedPages, 1)));
   policies_.insert(std::make_pair(
-      kLastNNamespace, MakePolicy(kLastNNamespace, LifetimeType::TEMPORARY,
-                                  base::TimeDelta::FromDays(2), kUnlimitedPages,
-                                  kUnlimitedPages)));
+      kLastNNamespace,
+      OfflinePageClientPolicyBuilder(kLastNNamespace, LifetimeType::TEMPORARY,
+                                     kUnlimitedPages, kUnlimitedPages)
+          .SetExpirePeriod(base::TimeDelta::FromDays(2))
+          .SetIsSupportedByRecentTabs(true)

[Dmitry Titov, 2016/09/24 00:09:29]

This set of bits looks conflicting? If we only can show the page in original
tab, it makes less sense to show it in some list of recently visited sites,
because it implies that user cna click on items in that list to re-open the
snapshots, and we can't do that once the tab is navigated/closed...

[dewittj, 2016/09/26 23:00:31]

These are not strictly conflicting.  Imagine if we ship last-n = n; then that
would be supported by recent tabs, but not shown in original tab.

I think NTP plans to get the wiring set up for switching to a tab that has an
offline copy.  Something like iterating the current list of tabs and
intersecting with the recent tabs list by tab ID

+          .SetIsOnlyShownInOriginalTab(true)
+          .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,
@@ skipping 45 matching lines @@
 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;
 }
 
+const std::vector<std::string>&
+ClientPolicyController::GetNamespacesWithDownloadSupport() {
+  if (download_namespace_cache_)
+    return *download_namespace_cache_;
+
+  download_namespace_cache_ = base::MakeUnique<std::vector<std::string>>();
+  for (const auto& policy_item : policies_) {
+    if (policy_item.second.feature_policy.is_supported_by_download)
+      download_namespace_cache_->emplace_back(policy_item.first);
+  }
+  return *download_namespace_cache_;
+}
+
+bool ClientPolicyController::IsRecentTab(const std::string& name_space) const {
+  return GetPolicy(name_space).feature_policy.is_supported_by_recent_tabs;
+}
+
+const std::vector<std::string>&
+ClientPolicyController::GetNamespacesForRecentTabs() {
+  if (recent_tab_namespace_cache_)
+    return *recent_tab_namespace_cache_;
+
+  recent_tab_namespace_cache_ = base::MakeUnique<std::vector<std::string>>();
+  for (const auto& policy_item : policies_) {
+    if (policy_item.second.feature_policy.is_supported_by_recent_tabs)
+      recent_tab_namespace_cache_->emplace_back(policy_item.first);
+  }
+
+  return *recent_tab_namespace_cache_;
+}
+
+bool ClientPolicyController::ShouldOnlyBeShownInOriginalTab(
+    const std::string& name_space) const {
+  return GetPolicy(name_space).feature_policy.only_shown_in_original_tab;
+}
+
+const std::vector<std::string>&
+ClientPolicyController::GetNamespacesToShowInOriginalTab() {
+  if (show_in_original_tab_cache_)
+    return *show_in_original_tab_cache_;
+
+  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_;
+}
+
 }  // namespace offline_pages