predictors: Track whether resources have validators, and require validation.

chrome/browser/predictors/resource_prefetch_predictor_tables.cc

 // Copyright 2014 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 "chrome/browser/predictors/resource_prefetch_predictor_tables.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/browser_thread.h"
 #include "sql/statement.h"
 
 using content::BrowserThread;
 using sql::Statement;
 
 namespace {
 
 const char kUrlResourceTableName[] = "resource_prefetch_predictor_url";
 const char kUrlMetadataTableName[] = "resource_prefetch_predictor_url_metadata";
 const char kHostResourceTableName[] = "resource_prefetch_predictor_host";
 const char kHostMetadataTableName[] =
     "resource_prefetch_predictor_host_metadata";
 
+const char kInsertResourceTableStatementTemplate[] =
+    "INSERT INTO %s "
+    "(main_page_url, resource_url, resource_type, number_of_hits, "
+    "number_of_misses, consecutive_misses, average_position, priority, "
+    "has_validators, always_revalidate) "
+    "VALUES (?,?,?,?,?,?,?,?,?,?)";
+
 void BindResourceRowToStatement(
     const predictors::ResourcePrefetchPredictorTables::ResourceRow& row,
     const std::string& primary_key,
     Statement* statement) {
   statement->BindString(0, primary_key);
   statement->BindString(1, row.resource_url.spec());
   statement->BindInt(2, static_cast<int>(row.resource_type));
   statement->BindInt(3, row.number_of_hits);
   statement->BindInt(4, row.number_of_misses);
   statement->BindInt(5, row.consecutive_misses);
   statement->BindDouble(6, row.average_position);
   statement->BindInt(7, static_cast<int>(row.priority));
+  statement->BindInt(8, static_cast<int>(row.has_validators));
+  statement->BindInt(9, static_cast<int>(row.always_revalidate));
 }
 
 bool StepAndInitializeResourceRow(
     Statement* statement,
     predictors::ResourcePrefetchPredictorTables::ResourceRow* row) {
   if (!statement->Step())
     return false;
 
   row->primary_key = statement->ColumnString(0);
   row->resource_url = GURL(statement->ColumnString(1));
   row->resource_type = static_cast<content::ResourceType>(
       statement->ColumnInt(2));
   row->number_of_hits = statement->ColumnInt(3);
   row->number_of_misses = statement->ColumnInt(4);
   row->consecutive_misses = statement->ColumnInt(5);
   row->average_position = statement->ColumnDouble(6);
   row->priority = static_cast<net::RequestPriority>(statement->ColumnInt(7));
+  // static_cast<bool> creates a C4800 warning with Visual Studio.
+  row->has_validators = statement->ColumnInt(8) != 0;
+  row->always_revalidate = statement->ColumnInt(9) != 0;
+
   return true;
 }
 
 }  // namespace
 
 namespace predictors {
 
 // static
 const size_t ResourcePrefetchPredictorTables::kMaxStringLength = 1024;
 
 ResourcePrefetchPredictorTables::ResourceRow::ResourceRow()
     : resource_type(content::RESOURCE_TYPE_LAST_TYPE),
       number_of_hits(0),
       number_of_misses(0),
       consecutive_misses(0),
       average_position(0.0),
       priority(net::IDLE),
+      has_validators(false),
+      always_revalidate(false),
       score(0.0) {}
 
 ResourcePrefetchPredictorTables::ResourceRow::ResourceRow(
     const ResourceRow& other)
     : primary_key(other.primary_key),
       resource_url(other.resource_url),
       resource_type(other.resource_type),
       number_of_hits(other.number_of_hits),
       number_of_misses(other.number_of_misses),
       consecutive_misses(other.consecutive_misses),
       average_position(other.average_position),
       priority(other.priority),
+      has_validators(other.has_validators),
+      always_revalidate(other.always_revalidate),
       score(other.score) {}
 
 ResourcePrefetchPredictorTables::ResourceRow::ResourceRow(
     const std::string& i_primary_key,
     const std::string& i_resource_url,
     content::ResourceType i_resource_type,
     int i_number_of_hits,
     int i_number_of_misses,
     int i_consecutive_misses,
     double i_average_position,
-    net::RequestPriority i_priority)
+    net::RequestPriority i_priority,
+    bool i_has_validators,
+    bool i_always_revalidate)
     : primary_key(i_primary_key),
       resource_url(i_resource_url),
       resource_type(i_resource_type),
       number_of_hits(i_number_of_hits),
       number_of_misses(i_number_of_misses),
       consecutive_misses(i_consecutive_misses),
       average_position(i_average_position),
-      priority(i_priority) {
+      priority(i_priority),
+      has_validators(i_has_validators),
+      always_revalidate(i_always_revalidate) {
   UpdateScore();
 }
 
 void ResourcePrefetchPredictorTables::ResourceRow::UpdateScore() {
   // The score is calculated so that when the rows are sorted, stylesheets,
   // scripts and fonts appear first, sorted by position(ascending) and then the
   // rest of the resources sorted by position (ascending).
   static const int kMaxResourcesPerType = 100;
   switch (resource_type) {
     case content::RESOURCE_TYPE_STYLESHEET:
@@ skipping 11 matching lines @@
 }
 
 bool ResourcePrefetchPredictorTables::ResourceRow::operator==(
     const ResourceRow& rhs) const {
   return primary_key == rhs.primary_key && resource_url == rhs.resource_url &&
          resource_type == rhs.resource_type &&
          number_of_hits == rhs.number_of_hits &&
          number_of_misses == rhs.number_of_misses &&
          consecutive_misses == rhs.consecutive_misses &&
          average_position == rhs.average_position && priority == rhs.priority &&
-         score == rhs.score;
+         has_validators == rhs.has_validators &&
+         always_revalidate == rhs.always_revalidate && score == rhs.score;
 }
 
 bool ResourcePrefetchPredictorTables::ResourceRowSorter::operator()(
     const ResourceRow& x, const ResourceRow& y) const {
   return x.score > y.score;
 }
 
 ResourcePrefetchPredictorTables::PrefetchData::PrefetchData(
     PrefetchKeyType i_key_type,
     const std::string& i_primary_key)
@@ skipping 241 matching lines @@
   }
   return true;
 }
 
 bool ResourcePrefetchPredictorTables::DropTablesIfOutdated(
     sql::Connection* db) {
   bool success = true;
   for (const char* table_name :
        {kUrlResourceTableName, kHostResourceTableName}) {
     if (db->DoesTableExist(table_name) &&
-        !db->DoesColumnExist(table_name, "priority")) {
+        !db->DoesColumnExist(table_name, "always_revalidate")) {
       success &=
           db->Execute(base::StringPrintf("DROP TABLE %s", table_name).c_str());
     }
   }
   return success;
 }
 
 void ResourcePrefetchPredictorTables::CreateTableIfNonExistent() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
   const char resource_table_creator[] =
       "CREATE TABLE %s ( "
       "main_page_url TEXT, "
       "resource_url TEXT, "
       "resource_type INTEGER, "
       "number_of_hits INTEGER, "
       "number_of_misses INTEGER, "
       "consecutive_misses INTEGER, "
       "average_position DOUBLE, "
       "priority INTEGER, "
+      "has_validators INTEGER, "
+      "always_revalidate INTEGER, "
       "PRIMARY KEY(main_page_url, resource_url))";
   const char* metadata_table_creator =
       "CREATE TABLE %s ( "
       "main_page_url TEXT, "
       "last_visit_time INTEGER, "
       "PRIMARY KEY(main_page_url))";
 
   sql::Connection* db = DB();
   bool success = DropTablesIfOutdated(db) &&
                  (db->DoesTableExist(kUrlResourceTableName) ||
@@ skipping 41 matching lines @@
     ResourcePrefetchPredictorTables::GetUrlResourceDeleteStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE,
       base::StringPrintf("DELETE FROM %s WHERE main_page_url=?",
                          kUrlResourceTableName).c_str()));
 }
 
 Statement*
     ResourcePrefetchPredictorTables::GetUrlResourceUpdateStatement() {
   return new Statement(DB()->GetCachedStatement(
-      SQL_FROM_HERE,
-      base::StringPrintf(
-          "INSERT INTO %s "
-          "(main_page_url, resource_url, resource_type, number_of_hits, "
-          "number_of_misses, consecutive_misses, average_position, priority) "
-          "VALUES (?,?,?,?,?,?,?,?)",
-          kUrlResourceTableName)
-          .c_str()));
+      SQL_FROM_HERE, base::StringPrintf(kInsertResourceTableStatementTemplate,
+                                        kUrlResourceTableName)
+                         .c_str()));
 }
 
 Statement*
     ResourcePrefetchPredictorTables::GetUrlMetadataDeleteStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE,
       base::StringPrintf("DELETE FROM %s WHERE main_page_url=?",
                          kUrlMetadataTableName).c_str()));
 }
 
@@ skipping 10 matching lines @@
     ResourcePrefetchPredictorTables::GetHostResourceDeleteStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE,
       base::StringPrintf("DELETE FROM %s WHERE main_page_url=?",
                          kHostResourceTableName).c_str()));
 }
 
 Statement*
     ResourcePrefetchPredictorTables::GetHostResourceUpdateStatement() {
   return new Statement(DB()->GetCachedStatement(
-      SQL_FROM_HERE,
-      base::StringPrintf(
-          "INSERT INTO %s "
-          "(main_page_url, resource_url, resource_type, number_of_hits, "
-          "number_of_misses, consecutive_misses, average_position, priority) "
-          "VALUES (?,?,?,?,?,?,?,?)",
-          kHostResourceTableName)
-          .c_str()));
+      SQL_FROM_HERE, base::StringPrintf(kInsertResourceTableStatementTemplate,
+                                        kHostResourceTableName)
+                         .c_str()));
 }
 
 Statement*
     ResourcePrefetchPredictorTables::GetHostMetadataDeleteStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE,
       base::StringPrintf("DELETE FROM %s WHERE main_page_url=?",
                          kHostMetadataTableName).c_str()));
 }
 
 Statement* ResourcePrefetchPredictorTables::GetHostMetadataUpdateStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE,
       base::StringPrintf(
           "INSERT INTO %s (main_page_url, last_visit_time) VALUES (?,?)",
           kHostMetadataTableName).c_str()));
 }
 
 }  // namespace predictors