predictors: Remove unused field from the resource_prefetch_predictor database.

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>
@@ skipping 38 matching lines @@
     "PRIMARY KEY(main_page_url))";
 
 const char kInsertResourceTableStatementTemplate[] =
     "INSERT INTO %s (main_page_url, resource_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=?";
 
 // Database version. Always increment it when any change is made to the data
 // schema (including the .proto).
-const int kDatabaseVersion = 1;
+const int kDatabaseVersion = 2;
 
 void BindResourceRowToStatement(const ResourceRow& row,
                                 const std::string& primary_key,
                                 Statement* statement) {
   chrome_browser_predictors::ResourceData proto;
   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);
 }
 
-bool StepAndInitializeResourceRow(Statement* statement, ResourceRow* row) {
+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);
   DCHECK(data);
   chrome_browser_predictors::ResourceData proto;
   proto.ParseFromArray(data, size);
   ResourceRow::FromProto(proto, row);
 
-  row->primary_key = statement->ColumnString(0);
-  row->resource_url = GURL(statement->ColumnString(1));
+  GURL resource_url(statement->ColumnString(1));
+  DCHECK(resource_url == row->resource_url);
+
   return true;
 }
 
 }  // namespace
 
 namespace predictors {
 
-// static
-const size_t ResourcePrefetchPredictorTables::kMaxStringLength = 1024;
-
 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) {}
 
 ResourceRow::ResourceRow(const ResourceRow& other)
-    : primary_key(other.primary_key),
-      resource_url(other.resource_url),
+    : 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) {}
 
-ResourceRow::ResourceRow(const std::string& i_primary_key,
-                         const std::string& i_resource_url,
+ResourceRow::ResourceRow(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,
                          bool i_has_validators,
                          bool i_always_revalidate)
-    : primary_key(i_primary_key),
-      resource_url(i_resource_url),
+    : 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),
       has_validators(i_has_validators),
       always_revalidate(i_always_revalidate) {
   UpdateScore();
 }
@@ skipping 12 matching lines @@
 
     case content::RESOURCE_TYPE_IMAGE:
     default:
       score = kMaxResourcesPerType - average_position;
       break;
   }
   // TODO(lizeb): Take priority into account.
 }
 
 bool ResourceRow::operator==(const ResourceRow& rhs) const {
-  return primary_key == rhs.primary_key && resource_url == rhs.resource_url &&
+  return 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 &&
          has_validators == rhs.has_validators &&
          always_revalidate == rhs.always_revalidate && score == rhs.score;
 }
 
 void ResourceRow::ToProto(ResourceData* resource_data) const {
   using chrome_browser_predictors::ResourceData_Priority;
   using chrome_browser_predictors::ResourceData_ResourceType;
 
-  resource_data->set_primary_key(primary_key);
   resource_data->set_resource_url(resource_url.spec());
   resource_data->set_resource_type(
       static_cast<ResourceData_ResourceType>(resource_type));
   resource_data->set_number_of_hits(number_of_hits);
   resource_data->set_number_of_misses(number_of_misses);
   resource_data->set_consecutive_misses(consecutive_misses);
   resource_data->set_average_position(average_position);
   resource_data->set_priority(static_cast<ResourceData_Priority>(priority));
   resource_data->set_has_validators(has_validators);
   resource_data->set_always_revalidate(always_revalidate);
 }
 
 // static
 void ResourceRow::FromProto(const ResourceData& proto, ResourceRow* row) {
-  DCHECK(proto.has_primary_key());
-  row->primary_key = proto.primary_key();
   row->resource_url = GURL(proto.resource_url());
   row->resource_type =
       static_cast<content::ResourceType>(proto.resource_type());
   row->number_of_hits = proto.number_of_hits();
   row->number_of_misses = proto.number_of_misses();
   row->consecutive_misses = proto.consecutive_misses();
   row->average_position = proto.average_position();
   row->priority = static_cast<net::RequestPriority>(proto.priority());
   row->has_validators = proto.has_validators();
   row->always_revalidate = proto.always_revalidate();
+  row->UpdateScore();
 }
 
 // static
 void ResourcePrefetchPredictorTables::SortResourceRows(ResourceRows* rows) {
   std::sort(rows->begin(), rows->end(),
             [](const ResourceRow& x, const ResourceRow& y) {
               return x.score > y.score;
             });
 }
 
@@ skipping 83 matching lines @@
   if (CantAccessDatabase())
     return;
 
   DeleteDataHelper(key_type, std::vector<std::string>(1, key));
 }
 
 void ResourcePrefetchPredictorTables::DeleteAllData() {
   if (CantAccessDatabase())
     return;
 
-  Statement deleter(DB()->GetUniqueStatement(
-      base::StringPrintf("DELETE FROM %s", kUrlResourceTableName).c_str()));
-  deleter.Run();
-  deleter.Assign(DB()->GetUniqueStatement(
-      base::StringPrintf("DELETE FROM %s", kUrlMetadataTableName).c_str()));
-  deleter.Run();
-  deleter.Assign(DB()->GetUniqueStatement(
-      base::StringPrintf("DELETE FROM %s", kHostResourceTableName).c_str()));
-  deleter.Run();
-  deleter.Assign(DB()->GetUniqueStatement(
-      base::StringPrintf("DELETE FROM %s", kHostMetadataTableName).c_str()));
-  deleter.Run();
+  Statement deleter;
+  for (const char* table_name :
+       {kUrlResourceTableName, kUrlMetadataTableName, kHostResourceTableName,
+        kHostMetadataTableName}) {
+    deleter.Assign(DB()->GetUniqueStatement(
+        base::StringPrintf("DELETE FROM %s", table_name).c_str()));
+    deleter.Run();
+  }
 }
 
 ResourcePrefetchPredictorTables::ResourcePrefetchPredictorTables()
     : PredictorTableBase() {
 }
 
 ResourcePrefetchPredictorTables::~ResourcePrefetchPredictorTables() {
 }
 
 void ResourcePrefetchPredictorTables::GetAllDataHelper(
     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()));
 
   ResourceRow row;
-  while (StepAndInitializeResourceRow(&resource_reader, &row)) {
-    row.UpdateScore();
-    std::string primary_key = row.primary_key;
-    // Don't need to store primary key since the data is grouped by primary key.
-    row.primary_key.clear();
-
+  std::string primary_key;
+  while (StepAndInitializeResourceRow(&resource_reader, &row, &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(row);
   }
 
   // Sort each of the resource row vectors by score.
   for (auto& kv : *data_map)
@@ skipping 36 matching lines @@
   if (!deleter->Run())
     return false;
 
   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.
-  const ResourceRows& resources = data.resources;
-  for (const ResourceRow& resource : resources) {
+  for (const ResourceRow& resource : data.resources) {
     std::unique_ptr<Statement> resource_inserter(
         data.is_host() ? GetHostResourceUpdateStatement()
                        : GetUrlResourceUpdateStatement());
     BindResourceRowToStatement(resource, data.primary_key,
                                resource_inserter.get());
     if (!resource_inserter->Run())
       return false;
   }
 
   std::unique_ptr<Statement> metadata_inserter(
       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;
 }
 
 void ResourcePrefetchPredictorTables::DeleteDataHelper(
     PrefetchKeyType key_type,
     const std::vector<std::string>& keys) {
   bool is_host = key_type == PREFETCH_KEY_TYPE_HOST;
 
-  for (std::vector<std::string>::const_iterator it = keys.begin();
-       it != keys.end(); ++it) {
+  for (const std::string& key : keys) {
     std::unique_ptr<Statement> deleter(is_host
                                            ? GetHostResourceDeleteStatement()
                                            : GetUrlResourceDeleteStatement());
-    deleter->BindString(0, *it);
+    deleter->BindString(0, key);
     deleter->Run();
 
     deleter.reset(is_host ? GetHostMetadataDeleteStatement() :
         GetUrlMetadataDeleteStatement());
-    deleter->BindString(0, *it);
+    deleter->BindString(0, key);
     deleter->Run();
   }
 }
 
+// static
 bool ResourcePrefetchPredictorTables::StringsAreSmallerThanDBLimit(
-    const PrefetchData& data) const {
+    const PrefetchData& data) {
   if (data.primary_key.length() > kMaxStringLength)
     return false;
 
-  for (ResourceRows::const_iterator it = data.resources.begin();
-       it != data.resources.end(); ++it) {
-    if (it->resource_url.spec().length() > kMaxStringLength)
+  for (const ResourceRow& row : data.resources) {
+    if (row.resource_url.spec().length() > kMaxStringLength)
       return false;
   }
   return true;
 }
 
 // static
 bool ResourcePrefetchPredictorTables::DropTablesIfOutdated(
     sql::Connection* db) {
   int tables_version = 0;
   if (db->DoesTableExist(kMetadataTableName)) {
@@ skipping 152 matching lines @@
 }
 
 Statement* ResourcePrefetchPredictorTables::GetHostMetadataUpdateStatement() {
   return new Statement(DB()->GetCachedStatement(
       SQL_FROM_HERE, base::StringPrintf(kInsertMetadataTableStatementTemplate,
                                         kHostMetadataTableName)
                          .c_str()));
 }
 
 }  // namespace predictors