Fix precache issue with cancel and resume

components/precache/core/precache_database_unittest.cc

 // Copyright 2013 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/precache/core/precache_database.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <memory>
@@ skipping 20 matching lines @@
 using base::Bucket;
 using net::HttpResponseInfo;
 
 const GURL kURL("http://url.com");
 const int kReferrerID = 1;
 const base::TimeDelta kLatency = base::TimeDelta::FromMilliseconds(5);
 const base::Time kFetchTime = base::Time() + base::TimeDelta::FromHours(1000);
 const base::Time kOldFetchTime = kFetchTime - base::TimeDelta::FromDays(1);
 const base::Time kNewFetchTime =
     base::Time() + base::TimeDelta::FromHours(2000);
+const base::Time kPrecacheTime =
+    base::Time() + base::TimeDelta::FromHours(3000);
 const int64_t kSize = 5000;
 const int64_t kFreshnessBucket10K = 9089;
 // One of the possible CacheEntryStatus for when the fetch was served from the
 // network.
 const HttpResponseInfo::CacheEntryStatus kFromNetwork =
     HttpResponseInfo::CacheEntryStatus::ENTRY_UPDATED;
 
 std::map<GURL, base::Time> BuildURLTableMap(const GURL& url,
                                             const base::Time& precache_time) {
   std::map<GURL, base::Time> url_table_map;
@@ skipping 467 matching lines @@
 
 TEST_F(PrecacheDatabaseTest, GetURLListForReferrerHost) {
   precache_database_->UpdatePrecacheReferrerHost("foo.com", 1, kFetchTime);
   precache_database_->UpdatePrecacheReferrerHost("bar.com", 2, kNewFetchTime);
   precache_database_->UpdatePrecacheReferrerHost("foobar.com", 3,
                                                  kNewFetchTime);
   precache_database_->UpdatePrecacheReferrerHost("empty.com", 3, kNewFetchTime);
 
   struct test_resource_info {
     std::string url;
+    bool is_user_browsed;
     bool is_network_fetched;
     bool is_cellular_fetched;
     bool expected_in_used;
   };
 
   const struct {
     std::string hostname;
     std::vector<test_resource_info> resource_info;
   } tests[] = {
       {
           "foo.com",
           {
-              {"http://foo.com/from-cache.js", false, false, true},
-              {"http://some-cdn.com/from-network.js", true, false, false},
-              {"http://foo.com/from-cache-cellular.js", false, true, true},
-              {"http://foo.com/from-network-cellular.js", true, true, false},
+              {"http://foo.com/from-cache.js", true, false, false, true},
+              {"http://some-cdn.com/from-network.js", true, true, false, false},
+              {"http://foo.com/from-cache-cellular.js", true, false, true,
+               true},
+              {"http://foo.com/from-network-cellular.js", true, true, true,
+               false},
+              {"http://foo.com/not-browsed.js", false, false, false, false},
           },
       },
       {
           "bar.com",
           {
-              {"http://bar.com/a.js", false, false, true},
-              {"http://some-cdn.com/b.js", false, true, true},
+              {"http://bar.com/a.js", true, false, false, true},
+              {"http://some-cdn.com/b.js", true, false, true, true},
+              {"http://bar.com/not-browsed.js", false, false, false, false},
           },
       },
       {
           "foobar.com",
           {
-              {"http://some-cdn.com/not-used.js", true, true, false},
+              {"http://some-cdn.com/not-used.js", true, true, true, false},
           },
       },
       {
           "empty.com", std::vector<test_resource_info>{},
       },
   };
   // Add precached resources.
   for (const auto& test : tests) {
     for (const auto& resource : test.resource_info) {
       precache_database_->RecordURLPrefetch(GURL(resource.url), test.hostname,
-                                            base::Time(), false, kSize);
+                                            kPrecacheTime, false, kSize);
     }
   }
   // Update some resources as used due to user browsing.
   for (const auto& test : tests) {
     for (const auto& resource : test.resource_info) {
+      if (!resource.is_user_browsed)
+        continue;
       if (!resource.is_network_fetched && !resource.is_cellular_fetched) {
         RecordFetchFromCache(GURL(resource.url), kFetchTime, kSize);
       } else if (!resource.is_network_fetched && resource.is_cellular_fetched) {
         RecordFetchFromCacheCellular(GURL(resource.url), kFetchTime, kSize);
       } else if (resource.is_network_fetched && !resource.is_cellular_fetched) {
         RecordFetchFromNetwork(GURL(resource.url), kLatency, kFetchTime, kSize);
       } else if (resource.is_network_fetched && resource.is_cellular_fetched) {
         RecordFetchFromNetworkCellular(GURL(resource.url), kLatency, kFetchTime,
                                        kSize);
       }
@@ skipping 24 matching lines @@
     precache_database_->UpdatePrecacheReferrerHost(test.hostname, 100,
                                                    kNewFetchTime);
     Flush();
     std::vector<GURL> actual_used_urls, actual_unused_urls;
     auto referrer_id = precache_database_->GetReferrerHost(test.hostname).id;
     EXPECT_NE(PrecacheReferrerHostEntry::kInvalidId, referrer_id);
     precache_database_->GetURLListForReferrerHost(
         referrer_id, &actual_used_urls, &actual_unused_urls);
     EXPECT_TRUE(actual_used_urls.empty());
   }
+  // Resources that were precached previously and not seen in user browsing
+  // should be still marked as precached.
+  std::map<GURL, base::Time> expected_url_table_map;
+  for (const auto& test : tests) {
+    for (const auto& resource : test.resource_info) {
+      if (!resource.is_user_browsed)
+        expected_url_table_map[GURL(resource.url)] = kPrecacheTime;
+    }
+  }
+  EXPECT_EQ(expected_url_table_map, GetActualURLTableMap());
 }
 
 }  // namespace
 
 }  // namespace precache