Redirect handling in resource prefetch predictor

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_macros.h"
 #include "base/strings/stringprintf.h"
 #include "content/public/browser/browser_thread.h"
 #include "sql/meta_table.h"
 #include "sql/statement.h"
 #include "sql/transaction.h"
 
 using content::BrowserThread;
 using sql::Statement;
 
 namespace {
 
 using ResourceRow = predictors::ResourcePrefetchPredictorTables::ResourceRow;
+using RedirectStatRow =
+    predictors::ResourcePrefetchPredictorTables::RedirectStatRow;
 
 const char kMetadataTableName[] = "resource_prefetch_predictor_metadata";
 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 kCreateGlobalMetadataStatementTemplate[] =
     "CREATE TABLE %s ( "
@@ skipping 24 matching lines @@
   row.ToProto(&proto);
   int size = proto.ByteSize();
   std::vector<char> proto_buffer(size);
   proto.SerializeToArray(&proto_buffer[0], size);
 
   statement->BindString(0, primary_key);
   statement->BindString(1, row.resource_url.spec());
   statement->BindBlob(2, &proto_buffer[0], size);
 }
 
+void BindRedirectStatRowToStatement(const RedirectStatRow& row,
+                                    const std::string& primary_key,
+                                    Statement* statement) {
+
+}
+
 bool StepAndInitializeResourceRow(Statement* statement,
                                   ResourceRow* row,
                                   std::string* primary_key) {
   if (!statement->Step())
     return false;
 
   *primary_key = statement->ColumnString(0);
 
   int size = statement->ColumnByteLength(2);
   const void* data = statement->ColumnBlob(2);
@@ skipping 143 matching lines @@
 
 ResourcePrefetchPredictorTables::PrefetchData::~PrefetchData() {
 }
 
 bool ResourcePrefetchPredictorTables::PrefetchData::operator==(
     const PrefetchData& rhs) const {
   return key_type == rhs.key_type && primary_key == rhs.primary_key &&
       resources == rhs.resources;
 }
 
+RedirectStatRow::RedirectStatRow()
+  : number_of_hits(0),
+    number_of_misses(0),
+    consecutive_misses(0) {}
+
+RedirectStatRow::RedirectStatRow(const RedirectStatRow& other)
+  : final_redirect(other.final_redirect),
+    number_of_hits(other.number_of_hits),
+    number_of_misses(other.number_of_misses),
+    consecutive_misses(other.consecutive_misses) {}
+
+ResourcePrefetchPredictorTables::RedirectData::RedirectData(
+    PrefetchKeyType i_key_type,
+    const std::string& i_primary_key)
+  : key_type(i_key_type),
+    primary_key(i_primary_key) {}
+
+ResourcePrefetchPredictorTables::RedirectData::RedirectData(
+    const RedirectData& other)
+  : key_type(other.key_type),
+    primary_key(other.primary_key),
+    last_visit(other.last_visit),
+    redirect_stats(other.redirect_stats) {}
+
+ResourcePrefetchPredictorTables::RedirectData::~RedirectData() {
+}
+
 void ResourcePrefetchPredictorTables::GetAllData(
     PrefetchDataMap* url_data_map,
-    PrefetchDataMap* host_data_map) {
+    PrefetchDataMap* host_data_map,
+    RedirectDataMap* url_redirect_data_map,
+    RedirectDataMap* host_redirect_data_map) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
   DCHECK(url_data_map);
   DCHECK(host_data_map);
+  DCHECK(url_redirect_data_map);
+  DCHECK(host_redirect_data_map);
   url_data_map->clear();
   host_data_map->clear();
+  url_redirect_data_map->clear();
+  host_redirect_data_map->clear();
 
   std::vector<std::string> urls_to_delete, hosts_to_delete;
   GetAllDataHelper(PREFETCH_KEY_TYPE_URL, url_data_map, &urls_to_delete);
   GetAllDataHelper(PREFETCH_KEY_TYPE_HOST, host_data_map, &hosts_to_delete);
+  // TODO: get data from redirect tables
 
   if (!urls_to_delete.empty() || !hosts_to_delete.empty())
     DeleteData(urls_to_delete, hosts_to_delete);
 }
 
-void ResourcePrefetchPredictorTables::UpdateData(
+void ResourcePrefetchPredictorTables::UpdatePrefetchData(
     const PrefetchData& url_data,
     const PrefetchData& host_data) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
   DCHECK(!url_data.is_host() && host_data.is_host());
   DCHECK(!url_data.primary_key.empty() || !host_data.primary_key.empty());
 
   DB()->BeginTransaction();
 
-  bool success = (url_data.primary_key.empty() || UpdateDataHelper(url_data)) &&
+  bool success =
+      (url_data.primary_key.empty() || UpdatePrefetchDataHelper(url_data)) &&
       (host_data.primary_key.empty() || UpdateDataHelper(host_data));
   if (!success)
     DB()->RollbackTransaction();
 
   DB()->CommitTransaction();
 }
 
+void ResourcePrefetchPredictorTables::UpdateRedirectData(
+    const RedirectData& redirect_data) {
+  DCHECK_CURRENTLY_ON(BrowserThread::DB);
+  if (CantAccessDatabase())
+    return;
+
+  DB()->BeginTransaction();
+
+  bool success = UpdateRedirectDataHelper(redirect_data);
+  if (!success)
+    DB()->RollbackTransaction();
+
+  DB()->CommitTransaction();
+}
+
 void ResourcePrefetchPredictorTables::DeleteData(
     const std::vector<std::string>& urls,
     const std::vector<std::string>& hosts) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
   DCHECK(!urls.empty() || !hosts.empty());
 
   if (!urls.empty())
@@ skipping 73 matching lines @@
     PrefetchDataMap::iterator it = data_map->find(primary_key);
     if (it != data_map->end()) {
       int64_t last_visit = metadata_reader.ColumnInt64(1);
       it->second.last_visit = base::Time::FromInternalValue(last_visit);
     } else {
       to_delete->push_back(primary_key);
     }
   }
 }
 
-bool ResourcePrefetchPredictorTables::UpdateDataHelper(
+bool ResourcePrefetchPredictorTables::UpdatePrefetchDataHelper(
     const PrefetchData& data) {
   DCHECK(!data.primary_key.empty());
 
   if (!StringsAreSmallerThanDBLimit(data)) {
     UMA_HISTOGRAM_BOOLEAN("ResourcePrefetchPredictor.DbStringTooLong", true);
     return false;
   }
 
   // Delete the older data from both the tables.
   std::unique_ptr<Statement> deleter(data.is_host()
@@ skipping 24 matching lines @@
       data.is_host() ? GetHostMetadataUpdateStatement()
                      : GetUrlMetadataUpdateStatement());
   metadata_inserter->BindString(0, data.primary_key);
   metadata_inserter->BindInt64(1, data.last_visit.ToInternalValue());
   if (!metadata_inserter->Run())
     return false;
 
   return true;
 }
 
+bool ResourcePrefetchPredictorTables::UpdateRedirectDataHelper(
+    const RedirectData& data) {
+  DCHECK(!data.primary_key.empty());
+
+  if (!StringsAreSmallerThanDBLimit(data)) {
+    // TODO: UMA?

[mattcary, 2016/09/09 13:19:21]

Yes!

+    return false;
+  }
+
+  // Delete the older data from the table.
+  std::unique_ptr<Statement> deleter(data.is_host()
+                                      ? GetHostRedirectStatDeleteStatement()
+                                      : GetUrlRedirectStatDeleteStatement());
+  deleter->BindString(0, data.primary_key);
+  if (!deleter->Run())
+    return false;
+
+  // Add the new data to the table.
+  for (const RedirectStatRow& row : data.redirect_stats) {
+    std::unique_ptr<Statement> row_inserter(
+        data.is_host() ? GetHostRedirectStatUpdateStatement()
+                       : GetUrlRedirectStatUpdateStatement());
+    BindRedirectStatRowToStatement(row, data.primary_key, row_inserter.get());
+    if (!row_inserter->Run())
+      return false;
+  }
+
+  return true;
+}
+
 void ResourcePrefetchPredictorTables::DeleteDataHelper(
     PrefetchKeyType key_type,
     const std::vector<std::string>& keys) {
   bool is_host = key_type == PREFETCH_KEY_TYPE_HOST;
 
   for (const std::string& key : keys) {
     std::unique_ptr<Statement> deleter(is_host
                                            ? GetHostResourceDeleteStatement()
                                            : GetUrlResourceDeleteStatement());
     deleter->BindString(0, key);
@@ skipping 13 matching lines @@
     return false;
 
   for (const ResourceRow& row : data.resources) {
     if (row.resource_url.spec().length() > kMaxStringLength)
       return false;
   }
   return true;
 }
 
 // static
+bool ResourcePrefetchPredictorTables::StringAreSmallerThanDBLimit(
+    const RedirectData& data) {
+  if (data.primary_key.length() > kMaxStringLength)
+    return false;
+
+  for (const RedirectStatRow& row : data.redirect_stats) {
+    if (row.final_redirect.length() > kMaxStringLength)
+      return false;
+  }
+  return true;
+}
+
+// static
 bool ResourcePrefetchPredictorTables::DropTablesIfOutdated(
     sql::Connection* db) {
   int version = GetDatabaseVersion(db);
   bool success = true;
   // Too new is also a problem.
   bool incompatible_version = version != kDatabaseVersion;
 
   if (incompatible_version) {
     for (const char* table_name :
          {kMetadataTableName, kUrlResourceTableName, kHostResourceTableName,
@@ skipping 159 matching lines @@
 }
 
 Statement* ResourcePrefetchPredictorTables::GetHostMetadataUpdateStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE, base::StringPrintf(kInsertMetadataTableStatementTemplate,
                                         kHostMetadataTableName)
                          .c_str()));
 }
 
 }  // namespace predictors