predictors: Extract sql key-value tables into separate class.

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 <algorithm>
 #include <utility>
 
 #include "base/memory/ptr_util.h"
@@ skipping 18 matching lines @@
 
 const char kCreateGlobalMetadataStatementTemplate[] =
     "CREATE TABLE %s ( "
     "key TEXT, value INTEGER, "
     "PRIMARY KEY (key))";
 const char kCreateProtoTableStatementTemplate[] =
     "CREATE TABLE %s ( "
     "key TEXT, "
     "proto BLOB, "
     "PRIMARY KEY(key))";
-const char kInsertProtoStatementTemplate[] =
-    "INSERT INTO %s (key, proto) VALUES (?,?)";
-const char kDeleteProtoStatementTemplate[] = "DELETE FROM %s WHERE key=?";
-const char kSelectAllStatementTemplate[] = "SELECT * FROM %s";
-
-void BindProtoDataToStatement(const std::string& key,
-                              const MessageLite& data,
-                              sql::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, key);
-  statement->BindBlob(1, &proto_buffer[0], size);
-}
-
-bool StepAndInitializeProtoData(sql::Statement* statement,
-                                std::string* key,
-                                MessageLite* data) {
-  if (!statement->Step())
-    return false;
-
-  *key = statement->ColumnString(0);
-
-  int size = statement->ColumnByteLength(1);
-  const void* blob = statement->ColumnBlob(1);
-  DCHECK(blob);
-  data->ParseFromArray(blob, size);
-
-  return true;
-}
 
 }  // namespace
 
 namespace predictors {
 
 using content::BrowserThread;
 
 // static
 void ResourcePrefetchPredictorTables::TrimResources(
     PrefetchData* data,
@@ skipping 69 matching lines @@
   DCHECK(host_redirect_data_map);
   DCHECK(manifest_map);
   DCHECK(origin_data_map);
   url_data_map->clear();
   host_data_map->clear();
   url_redirect_data_map->clear();
   host_redirect_data_map->clear();
   manifest_map->clear();
   origin_data_map->clear();
 
-  GetAllResourceDataHelper(PREFETCH_KEY_TYPE_URL, url_data_map);
-  GetAllResourceDataHelper(PREFETCH_KEY_TYPE_HOST, host_data_map);
-  GetAllRedirectDataHelper(PREFETCH_KEY_TYPE_URL, url_redirect_data_map);
-  GetAllRedirectDataHelper(PREFETCH_KEY_TYPE_HOST, host_redirect_data_map);
-  GetAllManifestDataHelper(manifest_map);
-  GetAllOriginDataHelper(origin_data_map);
+  url_resource_table_->GetAllData(url_data_map);
+  host_resource_table_->GetAllData(host_data_map);
+  url_redirect_table_->GetAllData(url_redirect_data_map);
+  host_redirect_table_->GetAllData(host_redirect_data_map);
+  manifest_table_->GetAllData(manifest_map);
+  origin_table_->GetAllData(origin_data_map);
 }
 
 void ResourcePrefetchPredictorTables::UpdateResourceData(
     const PrefetchData& data,
     PrefetchKeyType key_type) {
   TRACE_EVENT0("browser", "ResourcePrefetchPredictor::UpdateResourceData");
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
-  UpdateDataHelper(key_type, PrefetchDataType::RESOURCE, data.primary_key(),
-                   data);
+  if (key_type == PREFETCH_KEY_TYPE_URL)
+    url_resource_table_->UpdateData(data.primary_key(), data);
+  else
+    host_resource_table_->UpdateData(data.primary_key(), data);
 }
 
 void ResourcePrefetchPredictorTables::UpdateRedirectData(
     const RedirectData& data,
     PrefetchKeyType key_type) {
   TRACE_EVENT0("browser", "ResourcePrefetchPredictor::UpdateRedirectData");
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
-  UpdateDataHelper(key_type, PrefetchDataType::REDIRECT, data.primary_key(),
-                   data);
+  if (key_type == PREFETCH_KEY_TYPE_URL)
+    url_redirect_table_->UpdateData(data.primary_key(), data);
+  else
+    host_redirect_table_->UpdateData(data.primary_key(), data);
 }
 
 void ResourcePrefetchPredictorTables::UpdateManifestData(
     const std::string& host,
     const precache::PrecacheManifest& manifest_data) {
   TRACE_EVENT0("browser", "ResourcePrefetchPredictor::UpdateManifestData");
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
-  UpdateDataHelper(PREFETCH_KEY_TYPE_HOST, PrefetchDataType::MANIFEST, host,
-                   manifest_data);
+  manifest_table_->UpdateData(host, manifest_data);
 }
 
 void ResourcePrefetchPredictorTables::UpdateOriginData(
     const OriginData& origin_data) {
   TRACE_EVENT0("browser", "ResourcePrefetchPredictor::UpdateOriginData");
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
-  UpdateDataHelper(PREFETCH_KEY_TYPE_HOST, PrefetchDataType::ORIGIN,
-                   origin_data.host(), origin_data);
+  origin_table_->UpdateData(origin_data.host(), origin_data);
 }
 
 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, PrefetchDataType::RESOURCE, urls);
+    url_resource_table_->DeleteData(urls);
   if (!hosts.empty())
-    DeleteDataHelper(PREFETCH_KEY_TYPE_HOST, PrefetchDataType::RESOURCE, hosts);
+    host_resource_table_->DeleteData(hosts);
 }
 
 void ResourcePrefetchPredictorTables::DeleteSingleResourceDataPoint(
     const std::string& key,
     PrefetchKeyType key_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
-  DeleteDataHelper(key_type, PrefetchDataType::RESOURCE, {key});
+  if (key_type == PREFETCH_KEY_TYPE_URL)
+    url_resource_table_->DeleteData({key});
+  else
+    host_resource_table_->DeleteData({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, PrefetchDataType::REDIRECT, urls);
+    url_redirect_table_->DeleteData(urls);
   if (!hosts.empty())
-    DeleteDataHelper(PREFETCH_KEY_TYPE_HOST, PrefetchDataType::REDIRECT, hosts);
+    host_redirect_table_->DeleteData(hosts);
 }
 
 void ResourcePrefetchPredictorTables::DeleteSingleRedirectDataPoint(
     const std::string& key,
     PrefetchKeyType key_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
-  DeleteDataHelper(key_type, PrefetchDataType::REDIRECT, {key});
+  if (key_type == PREFETCH_KEY_TYPE_URL)
+    url_redirect_table_->DeleteData({key});
+  else
+    host_redirect_table_->DeleteData({key});
 }
 
 void ResourcePrefetchPredictorTables::DeleteManifestData(
     const std::vector<std::string>& hosts) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
-  DeleteDataHelper(PREFETCH_KEY_TYPE_HOST, PrefetchDataType::MANIFEST, hosts);
+  manifest_table_->DeleteData(hosts);
 }
 
 void ResourcePrefetchPredictorTables::DeleteOriginData(
     const std::vector<std::string>& hosts) {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
-  DeleteDataHelper(PREFETCH_KEY_TYPE_HOST, PrefetchDataType::ORIGIN, hosts);
+  origin_table_->DeleteData(hosts);
 }
 
 void ResourcePrefetchPredictorTables::DeleteAllData() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
-  sql::Statement deleter;
-  for (const char* table_name :
-       {kUrlResourceTableName, kUrlRedirectTableName, kHostResourceTableName,
-        kHostRedirectTableName, kManifestTableName}) {
-    deleter.Assign(DB()->GetUniqueStatement(
-        base::StringPrintf("DELETE FROM %s", table_name).c_str()));
-    deleter.Run();
-  }
+  url_resource_table_->DeleteAllData();
+  url_redirect_table_->DeleteAllData();
+  host_resource_table_->DeleteAllData();
+  host_redirect_table_->DeleteAllData();
+  manifest_table_->DeleteAllData();
+  origin_table_->DeleteAllData();
 }
 
-ResourcePrefetchPredictorTables::ResourcePrefetchPredictorTables() {}
+ResourcePrefetchPredictorTables::ResourcePrefetchPredictorTables() = default;
 
-ResourcePrefetchPredictorTables::~ResourcePrefetchPredictorTables() {}
-
-void ResourcePrefetchPredictorTables::GetAllResourceDataHelper(
-    PrefetchKeyType key_type,
-    PrefetchDataMap* data_map) {
-  // Read the resources table and organize it per primary key.
-  const char* table_name = GetTableName(key_type, PrefetchDataType::RESOURCE);
-  sql::Statement resource_reader(DB()->GetUniqueStatement(
-      base::StringPrintf(kSelectAllStatementTemplate, table_name).c_str()));
-
-  PrefetchData data;
-  std::string key;
-  while (StepAndInitializeProtoData(&resource_reader, &key, &data)) {
-    data_map->insert(std::make_pair(key, data));
-    DCHECK_EQ(data.primary_key(), key);
-  }
-
-  // Sort each of the resource vectors by score.
-  for (auto& kv : *data_map) {
-    SortResources(&(kv.second));
-  }
-}
-
-void ResourcePrefetchPredictorTables::GetAllRedirectDataHelper(
-    PrefetchKeyType key_type,
-    RedirectDataMap* data_map) {
-  // Read the redirects table and organize it per primary key.
-  const char* table_name = GetTableName(key_type, PrefetchDataType::REDIRECT);
-  sql::Statement redirect_reader(DB()->GetUniqueStatement(
-      base::StringPrintf(kSelectAllStatementTemplate, table_name).c_str()));
-
-  RedirectData data;
-  std::string key;
-  while (StepAndInitializeProtoData(&redirect_reader, &key, &data)) {
-    data_map->insert(std::make_pair(key, data));
-    DCHECK_EQ(data.primary_key(), key);
-  }
-}
-
-void ResourcePrefetchPredictorTables::GetAllManifestDataHelper(
-    ManifestDataMap* manifest_map) {
-  sql::Statement manifest_reader(DB()->GetUniqueStatement(
-      base::StringPrintf(kSelectAllStatementTemplate, kManifestTableName)
-          .c_str()));
-
-  precache::PrecacheManifest data;
-  std::string key;
-  while (StepAndInitializeProtoData(&manifest_reader, &key, &data)) {
-    manifest_map->insert(std::make_pair(key, data));
-  }
-}
-
-void ResourcePrefetchPredictorTables::GetAllOriginDataHelper(
-    OriginDataMap* origin_map) {
-  sql::Statement reader(DB()->GetUniqueStatement(
-      base::StringPrintf(kSelectAllStatementTemplate, kOriginTableName)
-          .c_str()));
-
-  OriginData data;
-  std::string key;
-  while (StepAndInitializeProtoData(&reader, &key, &data)) {
-    origin_map->insert({key, data});
-    DCHECK_EQ(data.host(), key);
-  }
-}
-
-void ResourcePrefetchPredictorTables::UpdateDataHelper(
-    PrefetchKeyType key_type,
-    PrefetchDataType data_type,
-    const std::string& key,
-    const MessageLite& data) {
-  DB()->BeginTransaction();
-
-  // Delete the older data from the table.
-  std::unique_ptr<sql::Statement> deleter(
-      GetTableUpdateStatement(key_type, data_type, TableOperationType::REMOVE));
-  deleter->BindString(0, key);
-  bool success = deleter->Run();
-
-  if (success) {
-    // Add the new data to the table.
-    std::unique_ptr<sql::Statement> inserter(GetTableUpdateStatement(
-        key_type, data_type, TableOperationType::INSERT));
-    BindProtoDataToStatement(key, data, inserter.get());
-    success = inserter->Run();
-  }
-
-  if (!success)
-    DB()->RollbackTransaction();
-  else
-    DB()->CommitTransaction();
-}
-
-void ResourcePrefetchPredictorTables::DeleteDataHelper(
-    PrefetchKeyType key_type,
-    PrefetchDataType data_type,
-    const std::vector<std::string>& keys) {
-  for (const std::string& key : keys) {
-    std::unique_ptr<sql::Statement> deleter(GetTableUpdateStatement(
-        key_type, data_type, TableOperationType::REMOVE));
-    deleter->BindString(0, key);
-    deleter->Run();
-  }
-}
+ResourcePrefetchPredictorTables::~ResourcePrefetchPredictorTables() = default;
 
 // static
 float ResourcePrefetchPredictorTables::ComputeResourceScore(
     const ResourceData& data) {
   // The ranking is done by considering, in this order:
   // 1. Resource Priority
   // 2. Request resource type
   // 3. Finally, the average position, giving a higher priotity to earlier
   //    resources.
 
@@ skipping 137 matching lines @@
                                .c_str()));
   }
 
   if (success)
     success = db->CommitTransaction();
   else
     db->RollbackTransaction();
 
   if (!success)
     ResetDB();
+
+  if (success) {
+    url_resource_table_ = base::MakeUnique<GlowplugKeyValueTable<PrefetchData>>(
+        kUrlResourceTableName, db);
+    url_redirect_table_ = base::MakeUnique<GlowplugKeyValueTable<RedirectData>>(
+        kUrlRedirectTableName, db);
+    host_resource_table_ =
+        base::MakeUnique<GlowplugKeyValueTable<PrefetchData>>(
+            kHostResourceTableName, db);
+    host_redirect_table_ =
+        base::MakeUnique<GlowplugKeyValueTable<RedirectData>>(
+            kHostRedirectTableName, db);
+    manifest_table_ =
+        base::MakeUnique<GlowplugKeyValueTable<precache::PrecacheManifest>>(
+            kManifestTableName, db);
+    origin_table_ = base::MakeUnique<GlowplugKeyValueTable<OriginData>>(
+        kOriginTableName, db);
+  }
 }
 
 void ResourcePrefetchPredictorTables::LogDatabaseStats() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
   sql::Statement statement(DB()->GetUniqueStatement(
       base::StringPrintf("SELECT count(*) FROM %s", kUrlResourceTableName)
           .c_str()));
   if (statement.Step())
     UMA_HISTOGRAM_COUNTS("ResourcePrefetchPredictor.UrlTableRowCount2",
                          statement.ColumnInt(0));
 
   statement.Assign(DB()->GetUniqueStatement(
       base::StringPrintf("SELECT count(*) FROM %s", kHostResourceTableName)
           .c_str()));
   if (statement.Step())
     UMA_HISTOGRAM_COUNTS("ResourcePrefetchPredictor.HostTableRowCount2",
                          statement.ColumnInt(0));
 }
 
-std::unique_ptr<sql::Statement>
-ResourcePrefetchPredictorTables::GetTableUpdateStatement(
-    PrefetchKeyType key_type,
-    PrefetchDataType data_type,
-    TableOperationType op_type) {
-  sql::StatementID id(__FILE__, key_type | (static_cast<int>(data_type) << 1) |
-                                    (static_cast<int>(op_type) << 3));
-  const char* statement_template =
-      (op_type == TableOperationType::REMOVE ? kDeleteProtoStatementTemplate
-                                             : kInsertProtoStatementTemplate);
-  const char* table_name = GetTableName(key_type, data_type);
-  return base::MakeUnique<sql::Statement>(DB()->GetCachedStatement(
-      id, base::StringPrintf(statement_template, table_name).c_str()));
-}
-
-// static
-const char* ResourcePrefetchPredictorTables::GetTableName(
-    PrefetchKeyType key_type,
-    PrefetchDataType data_type) {
-  bool is_host = key_type == PREFETCH_KEY_TYPE_HOST;
-  switch (data_type) {
-    case PrefetchDataType::RESOURCE:
-      return is_host ? kHostResourceTableName : kUrlResourceTableName;
-    case PrefetchDataType::REDIRECT:
-      return is_host ? kHostRedirectTableName : kUrlRedirectTableName;
-    case PrefetchDataType::MANIFEST:
-      return kManifestTableName;
-    case PrefetchDataType::ORIGIN:
-      return kOriginTableName;
-  }
-
-  NOTREACHED();
-  return nullptr;
-}
-
 }  // namespace predictors