Redirect handling in the 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 ResourceData = predictors::ResourceData;
+using RedirectData = predictors::RedirectData;
 
 const char kMetadataTableName[] = "resource_prefetch_predictor_metadata";
-const char kUrlResourceTableName[] = "resource_prefetch_predictor_url";
+const char kUrlResourceTableName[] = "resource_prefetch_predictor_url_resource";

[Benoit L, 2016/09/27 09:55:06]

Dont'change the name of the existing tables. It's unfortunate since it leads to
less naming consistency, but the database is shared with other predictors. Which
means that we cannot nuke the table when updating the schema.

This means that your change will lead undead tables behind, since the outdated
tables are removed in DropTablesIfOutdated() with the names you have modified
here.

[alexilin, 2016/09/27 14:52:46]

Yeah, I see. And we definitely don't want to have two versions of databases
names.
Done.

 const char kUrlMetadataTableName[] = "resource_prefetch_predictor_url_metadata";
-const char kHostResourceTableName[] = "resource_prefetch_predictor_host";
+const char kUrlRedirectTableName[] = "resource_prefetch_predictor_url_redirect";
+const char kHostResourceTableName[] =
+    "resource_prefetch_predictor_host_resource";
 const char kHostMetadataTableName[] =
     "resource_prefetch_predictor_host_metadata";
+const char kHostRedirectTableName[] =
+    "resource_prefetch_predictor_host_redirect";
 
 const char kCreateGlobalMetadataStatementTemplate[] =
     "CREATE TABLE %s ( "
     "key TEXT, value INTEGER, "
     "PRIMARY KEY (key))";
 const char kCreateResourceTableStatementTemplate[] =
     "CREATE TABLE %s ( "
     "main_page_url TEXT, "
     "resource_url TEXT, "
     "proto BLOB, "
     "PRIMARY KEY(main_page_url, resource_url))";
 const char kCreateMetadataTableStatementTemplate[] =
     "CREATE TABLE %s ( "
     "main_page_url TEXT, "
     "last_visit_time INTEGER, "
     "PRIMARY KEY(main_page_url))";
+const char kCreateRedirectTableStatementTemplate[] =
+    "CREATE TABLE %s ( "
+    "main_page_url TEXT, "
+    "proto BLOB, "
+    "PRIMARY KEY(main_page_url))";
 
 const char kInsertResourceTableStatementTemplate[] =
     "INSERT INTO %s (main_page_url, resource_url, proto) VALUES (?,?,?)";
+const char kInsertRedirectTableStatementTemplate[] =
+    "INSERT INTO %s (main_page_url, proto) VALUES (?,?)";
 const char kInsertMetadataTableStatementTemplate[] =
     "INSERT INTO %s (main_page_url, last_visit_time) VALUES (?,?)";
 const char kDeleteStatementTemplate[] = "DELETE FROM %s WHERE main_page_url=?";
 
 void BindResourceDataToStatement(const ResourceData& data,
                                  const std::string& primary_key,
                                  Statement* statement) {
   int size = data.ByteSize();
-  DCHECK(size > 0);
+  DCHECK_GT(size, 0);
   std::vector<char> proto_buffer(size);
   data.SerializeToArray(&proto_buffer[0], size);
 
   statement->BindString(0, primary_key);
   statement->BindString(1, data.resource_url());
   statement->BindBlob(2, &proto_buffer[0], size);
 }
 
+void BindRedirectDataToStatement(const RedirectData& data,
+                                 Statement* statement) {
+  int size = data.ByteSize();
+  DCHECK_GT(size, 0);
+  std::vector<char> proto_buffer(size);
+  data.SerializeToArray(&proto_buffer[0], size);
+
+  statement->BindString(0, data.primary_key());
+  statement->BindBlob(1, &proto_buffer[0], size);
+}
+
 bool StepAndInitializeResourceData(Statement* statement,
                                    ResourceData* data,
                                    std::string* primary_key) {
   if (!statement->Step())
     return false;
 
   *primary_key = statement->ColumnString(0);
-
   int size = statement->ColumnByteLength(2);
   const void* blob = statement->ColumnBlob(2);
   DCHECK(blob);
   data->ParseFromArray(blob, size);
 
   std::string resource_url = statement->ColumnString(1);
   DCHECK(resource_url == data->resource_url());
 
   return true;
 }
 
+bool StepAndInitializeRedirectData(Statement* statement,
+                                   RedirectData* data,
+                                   std::string* primary_key) {
+  if (!statement->Step())
+    return false;
+
+  *primary_key = statement->ColumnString(0);
+
+  int size = statement->ColumnByteLength(1);
+  const void* blob = statement->ColumnBlob(1);
+  DCHECK(blob);
+  data->ParseFromArray(blob, size);
+
+  DCHECK(data->primary_key() == *primary_key);
+
+  return true;
+}
+
 }  // namespace
 
 namespace predictors {
 
 // static
 void ResourcePrefetchPredictorTables::SortResources(
     std::vector<ResourceData>* resources) {
-  // Sort indices instead of ResourceData objects and then apply resulting
-  // permutation to the resources.
   std::sort(resources->begin(), resources->end(),
             [](const ResourceData& x, const ResourceData& y) {
-              return ComputeScore(x) > ComputeScore(y);
+              return ComputeResourceScore(x) > ComputeResourceScore(y);
             });
 }
 
+// static
+void ResourcePrefetchPredictorTables::SortRedirects(
+    std::vector<RedirectStat>* redirects) {
+  std::sort(redirects->begin(), redirects->end(),
+            [](const RedirectStat& x, const RedirectStat& y) {
+              return ComputeRedirectScore(x) > ComputeRedirectScore(y);
+            });
+}
+
 ResourcePrefetchPredictorTables::PrefetchData::PrefetchData(
     PrefetchKeyType i_key_type,
     const std::string& i_primary_key)
     : key_type(i_key_type),
       primary_key(i_primary_key) {
 }
 
 ResourcePrefetchPredictorTables::PrefetchData::PrefetchData(
     const PrefetchData& other)
     : key_type(other.key_type),
       primary_key(other.primary_key),
       last_visit(other.last_visit),
       resources(other.resources) {
 }
 
 ResourcePrefetchPredictorTables::PrefetchData::~PrefetchData() {
 }
 
 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);
+  GetAllResourceDataHelper(PREFETCH_KEY_TYPE_URL, url_data_map,
+                           &urls_to_delete);
+  GetAllResourceDataHelper(PREFETCH_KEY_TYPE_HOST, host_data_map,
+                           &hosts_to_delete);
+  GetAllRedirectDataHelper(PREFETCH_KEY_TYPE_URL, url_redirect_data_map);
+  GetAllRedirectDataHelper(PREFETCH_KEY_TYPE_HOST, host_redirect_data_map);
 
   if (!urls_to_delete.empty() || !hosts_to_delete.empty())
-    DeleteData(urls_to_delete, hosts_to_delete);
+    DeleteResourceData(urls_to_delete, hosts_to_delete);
 }
 
 void ResourcePrefetchPredictorTables::UpdateData(
     const PrefetchData& url_data,
-    const PrefetchData& host_data) {
+    const PrefetchData& host_data,
+    const RedirectData& url_redirect_data,
+    const RedirectData& host_redirect_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());
+  DCHECK(!url_data.primary_key.empty() || !host_data.primary_key.empty() ||
+         url_redirect_data.has_primary_key() ||
+         host_redirect_data.has_primary_key());
 
   DB()->BeginTransaction();
 
-  bool success = (url_data.primary_key.empty() || UpdateDataHelper(url_data)) &&
-      (host_data.primary_key.empty() || UpdateDataHelper(host_data));
+  bool success =
+      (url_data.primary_key.empty() ||
+       UpdateResourceDataHelper(PREFETCH_KEY_TYPE_URL, url_data)) &&
+      (host_data.primary_key.empty() ||
+       UpdateResourceDataHelper(PREFETCH_KEY_TYPE_HOST, host_data)) &&
+      (!url_redirect_data.has_primary_key() ||
+       UpdateRedirectDataHelper(PREFETCH_KEY_TYPE_URL, url_redirect_data)) &&
+      (!host_redirect_data.has_primary_key() ||
+       UpdateRedirectDataHelper(PREFETCH_KEY_TYPE_HOST, host_redirect_data));
   if (!success)
     DB()->RollbackTransaction();
-
-  DB()->CommitTransaction();
+  else
+    DB()->CommitTransaction();
 }
 
-void ResourcePrefetchPredictorTables::DeleteData(
+void ResourcePrefetchPredictorTables::DeleteResourceData(
     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())
+    DeleteDataHelper(PREFETCH_KEY_TYPE_URL, PREFETCH_DATA_TYPE_RESOURCE, urls);
+  if (!hosts.empty()) {
+    DeleteDataHelper(PREFETCH_KEY_TYPE_HOST, PREFETCH_DATA_TYPE_RESOURCE,
+                     hosts);
+  }
+}
+
+void ResourcePrefetchPredictorTables::DeleteSingleResourceDataPoint(
+    const std::string& key,
+    PrefetchKeyType key_type) {
+  DCHECK_CURRENTLY_ON(BrowserThread::DB);
+  if (CantAccessDatabase())
+    return;
+
+  DeleteDataHelper(key_type, PREFETCH_DATA_TYPE_RESOURCE, {key});
+}
+
+void ResourcePrefetchPredictorTables::DeleteRedirectData(
+    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())
-    DeleteDataHelper(PREFETCH_KEY_TYPE_URL, urls);
-  if (!hosts.empty())
-    DeleteDataHelper(PREFETCH_KEY_TYPE_HOST, hosts);
+    DeleteDataHelper(PREFETCH_KEY_TYPE_URL, PREFETCH_DATA_TYPE_REDIRECT, urls);
+  if (!hosts.empty()) {
+    DeleteDataHelper(PREFETCH_KEY_TYPE_HOST, PREFETCH_DATA_TYPE_REDIRECT,
+                     hosts);
+  }
 }
 
-void ResourcePrefetchPredictorTables::DeleteSingleDataPoint(
+void ResourcePrefetchPredictorTables::DeleteSingleRedirectDataPoint(
     const std::string& key,
     PrefetchKeyType key_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
-  DeleteDataHelper(key_type, std::vector<std::string>(1, key));
+  DeleteDataHelper(key_type, PREFETCH_DATA_TYPE_REDIRECT, {key});
 }
 
 void ResourcePrefetchPredictorTables::DeleteAllData() {
   if (CantAccessDatabase())
     return;
 
   Statement deleter;
   for (const char* table_name :
-       {kUrlResourceTableName, kUrlMetadataTableName, kHostResourceTableName,
-        kHostMetadataTableName}) {
+       {kUrlResourceTableName, kUrlMetadataTableName, kUrlRedirectTableName,
+        kHostResourceTableName, kHostMetadataTableName,
+        kHostRedirectTableName}) {
     deleter.Assign(DB()->GetUniqueStatement(
         base::StringPrintf("DELETE FROM %s", table_name).c_str()));
     deleter.Run();
   }
 }
 
 ResourcePrefetchPredictorTables::ResourcePrefetchPredictorTables()
     : PredictorTableBase() {
 }
 
 ResourcePrefetchPredictorTables::~ResourcePrefetchPredictorTables() {
 }
 
-void ResourcePrefetchPredictorTables::GetAllDataHelper(
+void ResourcePrefetchPredictorTables::GetAllResourceDataHelper(
     PrefetchKeyType key_type,
     PrefetchDataMap* data_map,
     std::vector<std::string>* to_delete) {
   bool is_host = key_type == PREFETCH_KEY_TYPE_HOST;
 
   // Read the resources table and organize it per primary key.
   const char* resource_table_name = is_host ? kHostResourceTableName :
       kUrlResourceTableName;
   Statement resource_reader(DB()->GetUniqueStatement(
       base::StringPrintf("SELECT * FROM %s", resource_table_name).c_str()));
 
   ResourceData resource;
   std::string primary_key;
   while (StepAndInitializeResourceData(&resource_reader, &resource,
                                        &primary_key)) {
     PrefetchDataMap::iterator it = data_map->find(primary_key);
     if (it == data_map->end()) {
       it = data_map->insert(std::make_pair(
           primary_key, PrefetchData(key_type, primary_key))).first;
     }
     it->second.resources.push_back(resource);
   }
 
   // Sort each of the resource row vectors by score.
   for (auto& kv : *data_map)
     SortResources(&(kv.second.resources));
 
   // Read the metadata and keep track of entries that have metadata, but no
   // resource entries, so they can be deleted.
-  const char* metadata_table_name = is_host ? kHostMetadataTableName :
-      kUrlMetadataTableName;
+  const char* metadata_table_name =
+      is_host ? kHostMetadataTableName : kUrlMetadataTableName;
   Statement metadata_reader(DB()->GetUniqueStatement(
       base::StringPrintf("SELECT * FROM %s", metadata_table_name).c_str()));
 
   while (metadata_reader.Step()) {
     std::string primary_key = metadata_reader.ColumnString(0);
 
     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(
+void ResourcePrefetchPredictorTables::GetAllRedirectDataHelper(
+    PrefetchKeyType key_type,
+    RedirectDataMap* redirect_map) {
+  bool is_host = key_type == PREFETCH_KEY_TYPE_HOST;
+
+  const char* redirect_table_name =
+      is_host ? kHostRedirectTableName : kUrlRedirectTableName;
+  Statement redirect_reader(DB()->GetUniqueStatement(
+      base::StringPrintf("SELECT * FROM %s", redirect_table_name).c_str()));
+
+  RedirectData data;
+  std::string primary_key;
+  while (StepAndInitializeRedirectData(&redirect_reader, &data, &primary_key)) {
+    auto result = redirect_map->insert(std::make_pair(primary_key, data));
+    DCHECK(result.second);
+  }
+}
+
+bool ResourcePrefetchPredictorTables::UpdateResourceDataHelper(
+    PrefetchKeyType key_type,
     const PrefetchData& data) {
   DCHECK(!data.primary_key.empty());
 
   if (!StringsAreSmallerThanDBLimit(data)) {
     UMA_HISTOGRAM_BOOLEAN("ResourcePrefetchPredictor.DbStringTooLong", true);
     return false;
   }
 
+  bool is_host = key_type == PREFETCH_KEY_TYPE_HOST;
+
   // Delete the older data from both the tables.
-  std::unique_ptr<Statement> deleter(data.is_host()
-                                         ? GetHostResourceDeleteStatement()
-                                         : GetUrlResourceDeleteStatement());
+  std::unique_ptr<Statement> deleter(is_host ? GetHostResourceDeleteStatement()
+                                             : GetUrlResourceDeleteStatement());
   deleter->BindString(0, data.primary_key);
   if (!deleter->Run())
     return false;
 
-  deleter.reset(data.is_host() ? GetHostMetadataDeleteStatement() :
-      GetUrlMetadataDeleteStatement());
+  deleter.reset(data.is_host() ? GetHostMetadataDeleteStatement()
+                               : GetUrlMetadataDeleteStatement());
   deleter->BindString(0, data.primary_key);
   if (!deleter->Run())
     return false;
 
   // Add the new data to the tables.
   for (const ResourceData& resource : data.resources) {
     std::unique_ptr<Statement> resource_inserter(
-        data.is_host() ? GetHostResourceUpdateStatement()
-                       : GetUrlResourceUpdateStatement());
+        is_host ? GetHostResourceUpdateStatement()
+                : GetUrlResourceUpdateStatement());
     BindResourceDataToStatement(resource, data.primary_key,
                                 resource_inserter.get());
     if (!resource_inserter->Run())
       return false;
   }
 
   std::unique_ptr<Statement> metadata_inserter(
-      data.is_host() ? GetHostMetadataUpdateStatement()
-                     : GetUrlMetadataUpdateStatement());
+      is_host ? GetHostMetadataUpdateStatement()
+              : GetUrlMetadataUpdateStatement());
   metadata_inserter->BindString(0, data.primary_key);
   metadata_inserter->BindInt64(1, data.last_visit.ToInternalValue());
-  if (!metadata_inserter->Run())
+  return metadata_inserter->Run();
+}
+
+bool ResourcePrefetchPredictorTables::UpdateRedirectDataHelper(
+    PrefetchKeyType key_type,
+    const RedirectData& data) {
+  DCHECK(data.has_primary_key());
+
+  if (!StringsAreSmallerThanDBLimit(data)) {
+    UMA_HISTOGRAM_BOOLEAN("ResourcePrefetchPredictor.DbStringTooLong", true);
+    return false;
+  }
+
+  bool is_host = key_type == PREFETCH_KEY_TYPE_HOST;
+
+  // Delete the older data from the table.
+  std::unique_ptr<Statement> deleter(is_host ? GetHostRedirectDeleteStatement()
+                                             : GetUrlRedirectDeleteStatement());
+  deleter->BindString(0, data.primary_key());
+  if (!deleter->Run())
     return false;
 
-  return true;
+  // Add the new data to the table.
+  std::unique_ptr<Statement> inserter(is_host
+                                          ? GetHostRedirectUpdateStatement()
+                                          : GetUrlRedirectUpdateStatement());
+  BindRedirectDataToStatement(data, inserter.get());
+  return inserter->Run();
 }
 
 void ResourcePrefetchPredictorTables::DeleteDataHelper(
     PrefetchKeyType key_type,
+    PrefetchDataType data_type,
     const std::vector<std::string>& keys) {
   bool is_host = key_type == PREFETCH_KEY_TYPE_HOST;
+  bool is_resource = data_type == PREFETCH_DATA_TYPE_RESOURCE;
 
   for (const std::string& key : keys) {
-    std::unique_ptr<Statement> deleter(is_host
-                                           ? GetHostResourceDeleteStatement()
-                                           : GetUrlResourceDeleteStatement());
+    std::unique_ptr<Statement> deleter(
+        is_host ? (is_resource ? GetHostResourceDeleteStatement()
+                               : GetHostRedirectDeleteStatement())
+                : (is_resource ? GetUrlResourceDeleteStatement()
+                               : GetUrlRedirectDeleteStatement()));
+
     deleter->BindString(0, key);
     deleter->Run();
 
-    deleter.reset(is_host ? GetHostMetadataDeleteStatement() :
-        GetUrlMetadataDeleteStatement());
-    deleter->BindString(0, key);
-    deleter->Run();
+    if (data_type == PREFETCH_DATA_TYPE_RESOURCE) {
+      // Delete corresponding resource metadata as well.
+      deleter.reset(is_host ? GetHostMetadataDeleteStatement()
+                            : GetUrlMetadataDeleteStatement());
+      deleter->BindString(0, key);
+      deleter->Run();
+    }
   }
 }
 
 // static
 bool ResourcePrefetchPredictorTables::StringsAreSmallerThanDBLimit(
     const PrefetchData& data) {
   if (data.primary_key.length() > kMaxStringLength)
     return false;
 
   for (const ResourceData& resource : data.resources) {
     if (resource.resource_url().length() > kMaxStringLength)
       return false;
   }
   return true;
 }
 
+bool ResourcePrefetchPredictorTables::StringsAreSmallerThanDBLimit(
+    const RedirectData& data) {
+  if (data.primary_key().length() > kMaxStringLength)
+    return false;
+
+  for (const RedirectStat& redirect : data.redirects()) {
+    if (redirect.url().length() > kMaxStringLength)
+      return false;
+  }
+  return true;
+}
+
 // static
-float ResourcePrefetchPredictorTables::ComputeScore(const ResourceData& data) {
+float ResourcePrefetchPredictorTables::ComputeResourceScore(
+    const ResourceData& data) {
   // 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 (data.resource_type()) {
     case ResourceData::RESOURCE_TYPE_STYLESHEET:
     case ResourceData::RESOURCE_TYPE_SCRIPT:
     case ResourceData::RESOURCE_TYPE_FONT_RESOURCE:
       return (2 * kMaxResourcesPerType) - data.average_position();
 
     case ResourceData::RESOURCE_TYPE_IMAGE:
     default:
       return kMaxResourcesPerType - data.average_position();
   }
   // TODO(lizeb): Take priority into account.
 }
 
 // static
+float ResourcePrefetchPredictorTables::ComputeRedirectScore(
+    const RedirectStat& data) {
+  // TODO(alexilin): Invent some scoring.
+  return 0.0;
+}
+
+// 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,
-          kUrlMetadataTableName, kHostMetadataTableName}) {
+          kUrlRedirectTableName, kHostRedirectTableName, kUrlMetadataTableName,
+          kHostMetadataTableName}) {
       success =
           success &&
           db->Execute(base::StringPrintf("DROP TABLE IF EXISTS %s", table_name)
                           .c_str());
     }
   }
 
   if (incompatible_version) {
     success =
         success &&
@@ skipping 46 matching lines @@
   success =
       success &&
       (db->DoesTableExist(kUrlResourceTableName) ||
        db->Execute(base::StringPrintf(kCreateResourceTableStatementTemplate,
                                       kUrlResourceTableName)
                        .c_str())) &&
       (db->DoesTableExist(kUrlMetadataTableName) ||
        db->Execute(base::StringPrintf(kCreateMetadataTableStatementTemplate,
                                       kUrlMetadataTableName)
                        .c_str())) &&
+      (db->DoesTableExist(kUrlRedirectTableName) ||
+       db->Execute(base::StringPrintf(kCreateRedirectTableStatementTemplate,
+                                      kUrlRedirectTableName)
+                       .c_str())) &&
       (db->DoesTableExist(kHostResourceTableName) ||
        db->Execute(base::StringPrintf(kCreateResourceTableStatementTemplate,
                                       kHostResourceTableName)
                        .c_str())) &&
       (db->DoesTableExist(kHostMetadataTableName) ||
        db->Execute(base::StringPrintf(kCreateMetadataTableStatementTemplate,
                                       kHostMetadataTableName)
+                       .c_str())) &&
+      (db->DoesTableExist(kHostRedirectTableName) ||
+       db->Execute(base::StringPrintf(kCreateRedirectTableStatementTemplate,
+                                      kHostRedirectTableName)
                        .c_str()));
 
   if (success)
     success = transaction.Commit();
   else
     transaction.Rollback();
 
   if (!success)
     ResetDB();
 }
@@ skipping 27 matching lines @@
 }
 
 Statement*
     ResourcePrefetchPredictorTables::GetUrlResourceUpdateStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE, base::StringPrintf(kInsertResourceTableStatementTemplate,
                                         kUrlResourceTableName)
                          .c_str()));
 }
 
-Statement*
-    ResourcePrefetchPredictorTables::GetUrlMetadataDeleteStatement() {
+Statement* ResourcePrefetchPredictorTables::GetUrlMetadataDeleteStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE,
       base::StringPrintf(kDeleteStatementTemplate, kUrlMetadataTableName)
           .c_str()));
 }
 
-Statement*
-    ResourcePrefetchPredictorTables::GetUrlMetadataUpdateStatement() {
+Statement* ResourcePrefetchPredictorTables::GetUrlMetadataUpdateStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE, base::StringPrintf(kInsertMetadataTableStatementTemplate,
                                         kUrlMetadataTableName)
                          .c_str()));
 }
 
+Statement* ResourcePrefetchPredictorTables::GetUrlRedirectDeleteStatement() {
+  return new Statement(DB()->GetCachedStatement(
+      SQL_FROM_HERE,
+      base::StringPrintf(kDeleteStatementTemplate, kUrlRedirectTableName)
+          .c_str()));
+}
+
+Statement* ResourcePrefetchPredictorTables::GetUrlRedirectUpdateStatement() {
+  return new Statement(DB()->GetCachedStatement(
+      SQL_FROM_HERE, base::StringPrintf(kInsertRedirectTableStatementTemplate,
+                                        kUrlRedirectTableName)
+                         .c_str()));
+}
+
 Statement*
     ResourcePrefetchPredictorTables::GetHostResourceDeleteStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE,
       base::StringPrintf(kDeleteStatementTemplate, kHostResourceTableName)
           .c_str()));
 }
 
 Statement*
     ResourcePrefetchPredictorTables::GetHostResourceUpdateStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE, base::StringPrintf(kInsertResourceTableStatementTemplate,
                                         kHostResourceTableName)
                          .c_str()));
 }
 
-Statement*
-    ResourcePrefetchPredictorTables::GetHostMetadataDeleteStatement() {
+Statement* ResourcePrefetchPredictorTables::GetHostMetadataDeleteStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE,
       base::StringPrintf(kDeleteStatementTemplate, kHostMetadataTableName)
           .c_str()));
 }
 
 Statement* ResourcePrefetchPredictorTables::GetHostMetadataUpdateStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE, base::StringPrintf(kInsertMetadataTableStatementTemplate,
                                         kHostMetadataTableName)
                          .c_str()));
 }
 
+Statement* ResourcePrefetchPredictorTables::GetHostRedirectDeleteStatement() {
+  return new Statement(DB()->GetCachedStatement(
+      SQL_FROM_HERE,
+      base::StringPrintf(kDeleteStatementTemplate, kHostRedirectTableName)
+          .c_str()));
+}
+
+Statement* ResourcePrefetchPredictorTables::GetHostRedirectUpdateStatement() {
+  return new Statement(DB()->GetCachedStatement(
+      SQL_FROM_HERE, base::StringPrintf(kInsertRedirectTableStatementTemplate,
+                                        kHostRedirectTableName)
+                         .c_str()));
+}
+
 }  // namespace predictors