[Offline Pages] Removes two-step expiration related.

components/offline_pages/offline_page_model_query_unittest.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 "base/time/time.h"
 #include "components/offline_pages/client_namespace_constants.h"
 #include "components/offline_pages/client_policy_controller.h"
 #include "components/offline_pages/offline_page_client_policy.h"
 #include "components/offline_pages/offline_page_item.h"
 #include "components/offline_pages/offline_page_model_query.h"
@@ skipping 19 matching lines @@
 
 class OfflinePageModelQueryTest : public testing::Test {
  public:
   OfflinePageModelQueryTest();
   ~OfflinePageModelQueryTest() override;
 
  protected:
   ClientPolicyController policy_;
   OfflinePageModelQueryBuilder builder_;
 
-  const OfflinePageItem expired_page() {
-    OfflinePageItem expiredTestItem(GURL("https://ktestitem1.com"), 3,
-                                    kClientId1, base::FilePath(), 3);
-    expiredTestItem.expiration_time = base::Time::Now();
-
-    return expiredTestItem;
-  }
-
   const OfflinePageItem download_page() {
     return OfflinePageItem(GURL("https://download.com"), 4,
                            {kDownloadNamespace, "id1"}, base::FilePath(), 4);
   }
 
   const OfflinePageItem original_tab_page() {
     return OfflinePageItem(GURL("https://download.com"), 5,
                            {kLastNNamespace, "id1"}, base::FilePath(), 5);
   }
 
@@ skipping 16 matching lines @@
                                      kUnlimitedPages, kUnlimitedPages)
           .SetIsOnlyShownInOriginalTab(true));
 }
 
 OfflinePageModelQueryTest::~OfflinePageModelQueryTest() {}
 
 TEST_F(OfflinePageModelQueryTest, DefaultValues) {
   std::unique_ptr<OfflinePageModelQuery> query = builder_.Build(&policy_);
 
   EXPECT_NE(nullptr, query.get());
-  EXPECT_FALSE(query->GetAllowExpired());
   EXPECT_EQ(Requirement::UNSET, query->GetRestrictedToOfflineIds().first);
   EXPECT_FALSE(query->GetRestrictedToNamespaces().first);
 
   EXPECT_TRUE(query->Matches(kTestItem1));
   EXPECT_TRUE(query->Matches(kTestItem2));
-  EXPECT_FALSE(query->Matches(expired_page()));
 }
 
 TEST_F(OfflinePageModelQueryTest, OfflinePageIdsSet_Exclude) {
   std::vector<int64_t> ids = {1, 4, 9, 16};
   builder_.SetOfflinePageIds(Requirement::EXCLUDE_MATCHING, ids);
 
   std::unique_ptr<OfflinePageModelQuery> query = builder_.Build(&policy_);
   std::pair<Requirement, std::set<int64_t>> offline_id_restriction =
       query->GetRestrictedToOfflineIds();
   EXPECT_EQ(Requirement::EXCLUDE_MATCHING, offline_id_restriction.first);
@@ skipping 180 matching lines @@
   ASSERT_EQ(urls2.size(), urls_out.size());
   for (auto url : urls2) {
     EXPECT_EQ(1U, urls_out.count(url)) << "Did not find " << url
                                        << "in query restrictions.";
   }
 
   EXPECT_FALSE(query->Matches(kTestItem1));
   EXPECT_TRUE(query->Matches(kTestItem2));
 }
 
-TEST_F(OfflinePageModelQueryTest, AllowExpired) {
-  std::unique_ptr<OfflinePageModelQuery> query =
-      builder_.AllowExpiredPages(true).Build(&policy_);
-
-  EXPECT_NE(nullptr, query.get());
-  EXPECT_TRUE(query->GetAllowExpired());
-
-  EXPECT_TRUE(query->Matches(kTestItem1));
-  EXPECT_TRUE(query->Matches(kTestItem2));
-  EXPECT_TRUE(query->Matches(expired_page()));
-}
-
 TEST_F(OfflinePageModelQueryTest, RequireSupportedByDownload_Only) {
   builder_.RequireSupportedByDownload(Requirement::INCLUDE_MATCHING);
   std::unique_ptr<OfflinePageModelQuery> query = builder_.Build(&policy_);
 
   auto restriction = query->GetRestrictedToNamespaces();
   std::set<std::string> namespaces_allowed = restriction.second;
   bool restricted_to_namespaces = restriction.first;
   EXPECT_TRUE(restricted_to_namespaces);
 
   for (const std::string& name_space : namespaces_allowed) {
@@ skipping 99 matching lines @@
   auto restriction = query->GetRestrictedToNamespaces();
   std::set<std::string> namespaces_allowed = restriction.second;
   bool restricted_to_namespaces = restriction.first;
   EXPECT_TRUE(restricted_to_namespaces);
 
   EXPECT_TRUE(namespaces_allowed.count(kTestNamespace) == 1);
   EXPECT_FALSE(query->Matches(recent_page()));
 }
 
 }  // namespace offline_pages