Report downloaded resources at most once

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>
 
+#include "base/bind.h"
+#include "base/bind_helpers.h"
 #include "base/containers/hash_tables.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_base.h"
 #include "base/test/histogram_tester.h"
 #include "base/time/time.h"
 #include "components/history/core/browser/history_constants.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
@@ skipping 62 matching lines @@
 
 }  // namespace
 
 namespace precache {
 
 class PrecacheDatabaseTest : public testing::Test {
  public:
   PrecacheDatabaseTest() {}
   ~PrecacheDatabaseTest() override {}
 
+  void SqlErrorCallback(int line, sql::Statement* statement) {
+    LOG(INFO) << "SQL error at line " << line << ": "
+              << statement->GetSQLStatement();
+  }
+
  protected:
   void SetUp() override {
     precache_database_.reset(new PrecacheDatabase());
 
     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
     base::FilePath db_path = scoped_temp_dir_.GetPath().Append(
         base::FilePath(FILE_PATH_LITERAL("precache_database")));
     ASSERT_TRUE(precache_database_->Init(db_path));
+    precache_database_->db_->set_error_callback(base::Bind(
+        &PrecacheDatabaseTest::SqlErrorCallback, base::Unretained(this)));
   }
 
   void TearDown() override { precache_url_table()->DeleteAll(); }
 
   std::map<GURL, base::Time> GetActualURLTableMap() {
     // Flush any buffered writes so that the URL table will be up to date.
     precache_database_->Flush();
 
     std::map<GURL, base::Time> url_table_map;
     precache_url_table()->GetAllDataForTesting(&url_table_map);
@@ skipping 144 matching lines @@
 
   EXPECT_EQ(BuildURLTableMap(kURL, kFetchTime), GetActualURLTableMap());
 
   ExpectNewSample("Precache.DownloadedPrecacheMotivated", kSize);
   ExpectNewSample("Precache.Latency.Prefetch", kLatency.InMilliseconds());
   ExpectNewSample("Precache.Freshness.Prefetch", kFreshnessBucket10K);
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, PrecacheFromCacheWithURLTableEntry) {
-  precache_url_table()->AddURL(kURL, kReferrerID, true, kOldFetchTime);
+  precache_url_table()->AddURL(kURL, kReferrerID, true, true, kOldFetchTime);
   RecordPrecacheFromCache(kURL, kFetchTime, kSize);
 
   // The URL table entry should have been updated to have |kFetchTime| as the
   // timestamp.
   EXPECT_EQ(BuildURLTableMap(kURL, kFetchTime), GetActualURLTableMap());
 
   ExpectNewSample("Precache.Latency.Prefetch", 0);
   ExpectNewSample("Precache.Freshness.Prefetch", kFreshnessBucket10K);
   ExpectNoOtherSamples();
 }
@@ skipping 42 matching lines @@
   ExpectNewSample("Precache.DownloadedNonPrecache", kSize);
   ExpectNewSample("Precache.DownloadedNonPrecache.Cellular", kSize);
   ExpectNewSample("Precache.CacheStatus.NonPrefetch", kFromNetwork);
   ExpectNewSample("Precache.Latency.NonPrefetch", kLatency.InMilliseconds());
   ExpectNewSample("Precache.Latency.NonPrefetch.NonTopHosts",
                   kLatency.InMilliseconds());
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, FetchOverNetworkWithURLTableEntry) {
-  precache_url_table()->AddURL(kURL, kReferrerID, true, kOldFetchTime);
+  precache_url_table()->AddURL(kURL, kReferrerID, true, true, kOldFetchTime);
   RecordFetchFromNetwork(kURL, kLatency, kFetchTime, kSize);
 
   // The URL table entry should have been deleted.
   EXPECT_TRUE(GetActualURLTableMap().empty());
 
   ExpectNewSample("Precache.DownloadedNonPrecache", kSize);
   ExpectNewSample("Precache.Latency.NonPrefetch", kLatency.InMilliseconds());
   ExpectNewSample("Precache.Latency.NonPrefetch.NonTopHosts",
                   kLatency.InMilliseconds());
   ExpectNewSample("Precache.CacheStatus.NonPrefetch", kFromNetwork);
   ExpectNewSample("Precache.CacheStatus.NonPrefetch.FromPrecache",
                   kFromNetwork);
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, FetchFromCacheWithURLTableEntry_NonCellular) {
-  precache_url_table()->AddURL(kURL, kReferrerID, true, kOldFetchTime);
+  precache_url_table()->AddURL(kURL, kReferrerID, true, true, kOldFetchTime);
   RecordFetchFromCache(kURL, kFetchTime, kSize);
 
   // The URL table entry should have been deleted.
   EXPECT_TRUE(GetActualURLTableMap().empty());
 
   ExpectNewSample("Precache.Latency.NonPrefetch", 0);
   ExpectNewSample("Precache.Latency.NonPrefetch.NonTopHosts", 0);
   ExpectNewSample("Precache.CacheStatus.NonPrefetch",
                   HttpResponseInfo::CacheEntryStatus::ENTRY_USED);
   ExpectNewSample("Precache.CacheStatus.NonPrefetch.FromPrecache",
                   HttpResponseInfo::CacheEntryStatus::ENTRY_USED);
   ExpectNewSample("Precache.Saved", kSize);
   ExpectNewSample("Precache.Saved.Freshness", kFreshnessBucket10K);
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, FetchFromCacheWithURLTableEntry_Cellular) {
-  precache_url_table()->AddURL(kURL, kReferrerID, true, kOldFetchTime);
+  precache_url_table()->AddURL(kURL, kReferrerID, true, true, kOldFetchTime);
   RecordFetchFromCacheCellular(kURL, kFetchTime, kSize);
 
   // The URL table entry should have been deleted.
   EXPECT_TRUE(GetActualURLTableMap().empty());
 
   ExpectNewSample("Precache.Latency.NonPrefetch", 0);
   ExpectNewSample("Precache.Latency.NonPrefetch.NonTopHosts", 0);
   ExpectNewSample("Precache.CacheStatus.NonPrefetch",
                   HttpResponseInfo::CacheEntryStatus::ENTRY_USED);
   ExpectNewSample("Precache.CacheStatus.NonPrefetch.FromPrecache",
@@ skipping 15 matching lines @@
                   HttpResponseInfo::CacheEntryStatus::ENTRY_USED);
   ExpectNoOtherSamples();
 }
 
 TEST_F(PrecacheDatabaseTest, DeleteExpiredPrecacheHistory) {
   const base::Time kToday = base::Time() + base::TimeDelta::FromDays(1000);
   const base::Time k59DaysAgo = kToday - base::TimeDelta::FromDays(59);
   const base::Time k61DaysAgo = kToday - base::TimeDelta::FromDays(61);
 
   precache_url_table()->AddURL(GURL("http://expired-precache.com"), kReferrerID,
-                               true, k61DaysAgo);
+                               true, true, k61DaysAgo);
   precache_url_table()->AddURL(GURL("http://old-precache.com"), kReferrerID,
-                               true, k59DaysAgo);
+                               true, true, k59DaysAgo);
 
   precache_database_->DeleteExpiredPrecacheHistory(kToday);
 
   EXPECT_EQ(BuildURLTableMap(GURL("http://old-precache.com"), k59DaysAgo),
             GetActualURLTableMap());
 }
 
 TEST_F(PrecacheDatabaseTest, SampleInteraction) {
   const GURL kURL1("http://url1.com");
   const int64_t kSize1 = 1;
@@ skipping 113 matching lines @@
   EXPECT_EQ(kNewFetchTime, actual_entry.time);
 }
 
 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);
 
+  // Add two resources that shouldn't appear in downloaded.
+  Flush();  // We need to write the referrer_host_id.
+  const std::string already_reported_and_not_refetch =
+      "http://foo.com/already-reported-and-not-refetch.js";
+
+  precache_database_->RecordURLPrefetch(GURL(already_reported_and_not_refetch),
+                                        "foo.com", kPrecacheTime, false, kSize);
+  const std::string already_reported_and_in_cache =
+      "http://foo.com/already-reported-and-in-cache.js";
+  precache_database_->RecordURLPrefetch(GURL(already_reported_and_in_cache),
+                                        "foo.com", kPrecacheTime, false, kSize);
+  {
+    std::vector<GURL> unused_a, unused_b;
+    auto id = precache_database_->GetReferrerHost("foo.com").id;
+    CHECK_NE(PrecacheReferrerHostEntry::kInvalidId, id);

[twifkak, 2016/12/20 01:41:59]

Per the last bullet of
https://chromium.googlesource.com/chromium/src/+/master/styleguide/c++/c++.md...,
use ASSERT_NE instead.

[jamartin, 2016/12/20 21:09:34]

Done.

+    precache_database_->GetURLListForReferrerHost(id, &unused_a, &unused_b);

[twifkak, 2016/12/20 01:41:59]

I assume the purpose of this call is to mark the already_reported resources as
is_download_reported = 1. Leave a comment to that effect.

[jamartin, 2016/12/20 21:09:34]

Done.

+  }
+
   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;
@@ skipping 29 matching lines @@
           "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,
                                             kPrecacheTime, false, kSize);
     }
   }
+  precache_database_->RecordURLPrefetch(GURL(already_reported_and_in_cache),
+                                        "foo.com", kPrecacheTime, true, 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);
       }
     }
   }
   Flush();
-  // Verify the used and unused resources.
+  // Verify the used and downloaded resources.
   for (const auto& test : tests) {
-    std::vector<GURL> expected_used_urls, expected_unused_urls;
+    std::vector<GURL> expected_used_urls, expected_downloaded_urls;
     for (const auto& resource : test.resource_info) {
       if (resource.expected_in_used) {
         expected_used_urls.push_back(GURL(resource.url));
-      } else {
-        expected_unused_urls.push_back(GURL(resource.url));
       }
+      expected_downloaded_urls.push_back(GURL(resource.url));
     }
-    std::vector<GURL> actual_used_urls, actual_unused_urls;
+    std::vector<GURL> actual_used_urls, actual_downloaded_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_THAT(expected_used_urls, ::testing::ContainerEq(actual_used_urls));
-    EXPECT_THAT(expected_unused_urls,
-                ::testing::ContainerEq(actual_unused_urls));
+        referrer_id, &actual_used_urls, &actual_downloaded_urls);
+    EXPECT_THAT(actual_used_urls, ::testing::ContainerEq(expected_used_urls));
+    EXPECT_THAT(actual_downloaded_urls,
+                ::testing::ContainerEq(expected_downloaded_urls))
+        << "Host: " << test.hostname;
   }
-  // Subsequent manifest updates should clear the used and unused resources.
+  // Subsequent manifest updates should clear the used and downloaded resources.
   for (const auto& test : tests) {
     precache_database_->UpdatePrecacheReferrerHost(test.hostname, 100,
                                                    kNewFetchTime);
     Flush();
-    std::vector<GURL> actual_used_urls, actual_unused_urls;
+    std::vector<GURL> actual_used_urls, actual_downloaded_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);
+        referrer_id, &actual_used_urls, &actual_downloaded_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;
     }
   }
+  expected_url_table_map[GURL(already_reported_and_not_refetch)] =
+      kPrecacheTime;
+  expected_url_table_map[GURL(already_reported_and_in_cache)] = kPrecacheTime;
   EXPECT_EQ(expected_url_table_map, GetActualURLTableMap());
 }
 
 }  // namespace
 
 }  // namespace precache