predictors: ResourcePrefetchPredictorTables cleanup.

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/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/stringprintf.h"
 #include "base/trace_event/trace_event.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;
+using google::protobuf::MessageLite;
 
 namespace {
 
-using PrefetchData = predictors::PrefetchData;
-using RedirectData = predictors::RedirectData;
-using ::google::protobuf::MessageLite;
-
 const char kMetadataTableName[] = "resource_prefetch_predictor_metadata";
 const char kUrlResourceTableName[] = "resource_prefetch_predictor_url";
 const char kUrlRedirectTableName[] = "resource_prefetch_predictor_url_redirect";
 const char kHostResourceTableName[] = "resource_prefetch_predictor_host";
 const char kHostRedirectTableName[] =
     "resource_prefetch_predictor_host_redirect";
 
 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 kInsertProtoTableStatementTemplate[] =
     "INSERT INTO %s (key, proto) VALUES (?,?)";
 const char kDeleteProtoTableStatementTemplate[] = "DELETE FROM %s WHERE key=?";
 
 void BindProtoDataToStatement(const std::string& key,
                               const MessageLite& data,
-                              Statement* statement) {
+                              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(Statement* statement,
+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,
     size_t max_consecutive_misses) {
   auto new_end = std::remove_if(
       data->mutable_resources()->begin(), data->mutable_resources()->end(),
       [max_consecutive_misses](const ResourceData& x) {
         return x.consecutive_misses() >= max_consecutive_misses;
       });
   data->mutable_resources()->erase(new_end, data->mutable_resources()->end());
@@ skipping 131 matching lines @@
     return;
 
   DeleteDataHelper(key_type, PrefetchDataType::REDIRECT, {key});
 }
 
 void ResourcePrefetchPredictorTables::DeleteAllData() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
-  Statement deleter;
+  sql::Statement deleter;
   for (const char* table_name :
        {kUrlResourceTableName, kUrlRedirectTableName, kHostResourceTableName,
         kHostRedirectTableName}) {
     deleter.Assign(DB()->GetUniqueStatement(
         base::StringPrintf("DELETE FROM %s", table_name).c_str()));
     deleter.Run();
   }
 }
 
-ResourcePrefetchPredictorTables::ResourcePrefetchPredictorTables()
-    : PredictorTableBase() {}
+ResourcePrefetchPredictorTables::ResourcePrefetchPredictorTables() {}
 
 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);
-  Statement resource_reader(DB()->GetUniqueStatement(
+  sql::Statement resource_reader(DB()->GetUniqueStatement(
       base::StringPrintf("SELECT * FROM %s", 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);
-  Statement redirect_reader(DB()->GetUniqueStatement(
+  sql::Statement redirect_reader(DB()->GetUniqueStatement(
       base::StringPrintf("SELECT * FROM %s", 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);
   }
 }
 
 bool ResourcePrefetchPredictorTables::UpdateDataHelper(
     PrefetchKeyType key_type,
     PrefetchDataType data_type,
     const std::string& key,
     const MessageLite& data) {
   // Delete the older data from the table.
-  std::unique_ptr<Statement> deleter(
+  std::unique_ptr<sql::Statement> deleter(
       GetTableUpdateStatement(key_type, data_type, TableOperationType::REMOVE));
   deleter->BindString(0, key);
   if (!deleter->Run())
     return false;
 
   // Add the new data to the table.
-  std::unique_ptr<Statement> inserter(
+  std::unique_ptr<sql::Statement> inserter(
       GetTableUpdateStatement(key_type, data_type, TableOperationType::INSERT));
   BindProtoDataToStatement(key, data, inserter.get());
   return inserter->Run();
 }
 
 void ResourcePrefetchPredictorTables::DeleteDataHelper(
     PrefetchKeyType key_type,
     PrefetchDataType data_type,
     const std::vector<std::string>& keys) {
   for (const std::string& key : keys) {
-    std::unique_ptr<Statement> deleter(GetTableUpdateStatement(
+    std::unique_ptr<sql::Statement> deleter(GetTableUpdateStatement(
         key_type, data_type, TableOperationType::REMOVE));
     deleter->BindString(0, key);
     deleter->Run();
   }
 }
 
 // static
 float ResourcePrefetchPredictorTables::ComputeResourceScore(
     const ResourceData& data) {
   // The ranking is done by considering, in this order:
@@ skipping 40 matching lines @@
 
 // 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;
 
   // These are deprecated tables but they still have to be removed if present.
-  const char kUrlMetadataTableName[] =
+  static const char kUrlMetadataTableName[] =
       "resource_prefetch_predictor_url_metadata";
-  const char kHostMetadataTableName[] =
+  static const char kHostMetadataTableName[] =
       "resource_prefetch_predictor_host_metadata";
 
   if (incompatible_version) {
     for (const char* table_name :
          {kMetadataTableName, kUrlResourceTableName, kHostResourceTableName,
           kUrlRedirectTableName, kHostRedirectTableName, kUrlMetadataTableName,
           kHostMetadataTableName}) {
       success =
           success &&
           db->Execute(base::StringPrintf("DROP TABLE IF EXISTS %s", table_name)
@@ skipping 38 matching lines @@
   return statement.Run();
 }
 
 void ResourcePrefetchPredictorTables::CreateTableIfNonExistent() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
   // Database initialization is all-or-nothing.
   sql::Connection* db = DB();
-  sql::Transaction transaction{db};
-  bool success = transaction.Begin();
-
+  bool success = db->BeginTransaction();
   success = success && DropTablesIfOutdated(db);
 
   for (const char* table_name :
        {kUrlResourceTableName, kHostResourceTableName, kUrlRedirectTableName,
         kHostRedirectTableName}) {
     success = success &&
               (db->DoesTableExist(table_name) ||
                db->Execute(base::StringPrintf(
                                kCreateProtoTableStatementTemplate, table_name)
                                .c_str()));
   }
 
   if (success)
-    success = transaction.Commit();
+    success = db->CommitTransaction();
   else
-    transaction.Rollback();
+    db->RollbackTransaction();
 
   if (!success)
     ResetDB();
 }
 
-void ResourcePrefetchPredictorTables::LogDatabaseStats()  {
+void ResourcePrefetchPredictorTables::LogDatabaseStats() {
   DCHECK_CURRENTLY_ON(BrowserThread::DB);
   if (CantAccessDatabase())
     return;
 
-  Statement statement(DB()->GetUniqueStatement(
-      base::StringPrintf("SELECT count(*) FROM %s",
-                         kUrlResourceTableName).c_str()));
+  sql::Statement statement(DB()->GetUniqueStatement(
+      base::StringPrintf("SELECT count(*) FROM %s", kUrlResourceTableName)
+          .c_str()));
   if (statement.Step())
     UMA_HISTOGRAM_COUNTS("ResourcePrefetchPredictor.UrlTableRowCount",
                          statement.ColumnInt(0));
 
   statement.Assign(DB()->GetUniqueStatement(
-      base::StringPrintf("SELECT count(*) FROM %s",
-                         kHostResourceTableName).c_str()));
+      base::StringPrintf("SELECT count(*) FROM %s", kHostResourceTableName)
+          .c_str()));
   if (statement.Step())
     UMA_HISTOGRAM_COUNTS("ResourcePrefetchPredictor.HostTableRowCount",
                          statement.ColumnInt(0));
 }
 
-std::unique_ptr<Statement>
+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) << 2));
   const char* statement_template = (op_type == TableOperationType::REMOVE
                                         ? kDeleteProtoTableStatementTemplate
                                         : kInsertProtoTableStatementTemplate);
   const char* table_name = GetTableName(key_type, data_type);
-  return base::MakeUnique<Statement>(DB()->GetCachedStatement(
+  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;
   }
 
   NOTREACHED();
   return nullptr;
 }
 
 }  // namespace predictors