Refactoring AutocompleteActionPredictor Database.

chrome/browser/predictors/autocomplete_action_predictor_unittest.cc

 // Copyright (c) 2012 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/autocomplete_action_predictor.h"
 
 #include "base/command_line.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/autocomplete/autocomplete_match.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/history/in_memory_database.h"
 #include "chrome/browser/history/url_database.h"
 #include "chrome/browser/prerender/prerender_field_trial.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/guid.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
+using predictors::AutocompleteActionPredictor;
 
 namespace {
 
 struct TestUrlInfo {
   GURL url;
   string16 title;
   int days_from_now;
   string16 user_text;
   int number_of_hits;
   int number_of_misses;
@@ skipping 32 matching lines @@
     ASCIIToUTF16("just a test"), 2, 0,
     AutocompleteActionPredictor::ACTION_NONE },
   { GURL("http://www.testsite.com/i.html"),
     ASCIIToUTF16("Test - site - just a test"), 28,
     ASCIIToUTF16("just a test"), 2, 0,
     AutocompleteActionPredictor::ACTION_NONE }
 };
 
 }  // end namespace
 
+namespace predictors {
+
 class AutocompleteActionPredictorTest : public testing::Test {
  public:
   AutocompleteActionPredictorTest()
       : loop_(MessageLoop::TYPE_DEFAULT),
         ui_thread_(BrowserThread::UI, &loop_),
         db_thread_(BrowserThread::DB, &loop_),
         file_thread_(BrowserThread::FILE, &loop_),
         predictor_(new AutocompleteActionPredictor(&profile_)) {
   }
 
@@ skipping 37 matching lines @@
         base::Time::Now() - base::TimeDelta::FromDays(
             test_row.days_from_now);
 
     history::URLRow row(test_row.url);
     row.set_title(test_row.title);
     row.set_last_visit(visit_time);
 
     return url_db->AddURL(row);
   }
 
-  AutocompleteActionPredictorDatabase::Row CreateRowFromTestUrlInfo(
+  AutocompleteActionPredictorTable::Row CreateRowFromTestUrlInfo(
       const TestUrlInfo& test_row) const {
-    AutocompleteActionPredictorDatabase::Row row;
+    AutocompleteActionPredictorTable::Row row;
     row.id = guid::GenerateGUID();
     row.user_text = test_row.user_text;
     row.url = test_row.url;
     row.number_of_hits = test_row.number_of_hits;
     row.number_of_misses = test_row.number_of_misses;
     return row;
   }
 
   void AddAllRows() {
     for (size_t i = 0; i < arraysize(test_url_db); ++i)
       AddRow(test_url_db[i]);
   }
 
   std::string AddRow(const TestUrlInfo& test_row) {
     AutocompleteActionPredictor::DBCacheKey key = { test_row.user_text,
-                                               test_row.url };
-    AutocompleteActionPredictorDatabase::Row row =
+                                                    test_row.url };
+    AutocompleteActionPredictorTable::Row row =
         CreateRowFromTestUrlInfo(test_row);
-    predictor_->AddRow(key, row);
+    predictor_->AddAndUpdateRows(
+        AutocompleteActionPredictorTable::Rows(1, row),
+        AutocompleteActionPredictorTable::Rows());
 
     return row.id;
   }
 
-  void UpdateRow(AutocompleteActionPredictor::DBCacheKey key,
-                 const AutocompleteActionPredictorDatabase::Row& row) {
-    AutocompleteActionPredictor::DBCacheMap::iterator it =
-        db_cache()->find(key);
-    ASSERT_TRUE(it != db_cache()->end());
-
-    predictor_->UpdateRow(it, row);
+  void UpdateRow(const AutocompleteActionPredictorTable::Row& row) {
+    AutocompleteActionPredictor::DBCacheKey key = { row.user_text, row.url };
+    ASSERT_TRUE(db_cache()->find(key) != db_cache()->end());
+    predictor_->AddAndUpdateRows(
+        AutocompleteActionPredictorTable::Rows(),
+        AutocompleteActionPredictorTable::Rows(1, row));
   }
 
   void DeleteAllRows() {
     predictor_->DeleteAllRows();
   }
 
   void DeleteRowsWithURLs(const history::URLRows& rows) {
     predictor_->DeleteRowsWithURLs(rows);
   }
 
   void DeleteOldIdsFromCaches(
-      std::vector<AutocompleteActionPredictorDatabase::Row::Id>* id_list) {
+      std::vector<AutocompleteActionPredictorTable::Row::Id>* id_list) {
     HistoryService* history_service =
         profile_.GetHistoryService(Profile::EXPLICIT_ACCESS);
     ASSERT_TRUE(history_service);
 
     history::URLDatabase* url_db = history_service->InMemoryDatabase();
     ASSERT_TRUE(url_db);
 
     predictor_->DeleteOldIdsFromCaches(url_db, id_list);
   }
 
@@ skipping 42 matching lines @@
   EXPECT_EQ(arraysize(test_url_db), db_id_cache()->size());
 
   // Get the data back out of the cache.
   const DBCacheKey key = { test_url_db[0].user_text, test_url_db[0].url };
   DBCacheMap::const_iterator it = db_cache()->find(key);
   EXPECT_TRUE(it != db_cache()->end());
 
   DBIdCacheMap::const_iterator id_it = db_id_cache()->find(key);
   EXPECT_TRUE(id_it != db_id_cache()->end());
 
-  AutocompleteActionPredictorDatabase::Row update_row;
+  AutocompleteActionPredictorTable::Row update_row;
   update_row.id = id_it->second;
   update_row.user_text = key.user_text;
   update_row.url = key.url;
   update_row.number_of_hits = it->second.number_of_hits + 1;
   update_row.number_of_misses = it->second.number_of_misses + 2;
 
-  UpdateRow(key, update_row);
+  UpdateRow(update_row);
 
   // Get the updated version.
   DBCacheMap::const_iterator update_it = db_cache()->find(key);
   EXPECT_TRUE(update_it != db_cache()->end());
 
   EXPECT_EQ(update_row.number_of_hits, update_it->second.number_of_hits);
   EXPECT_EQ(update_row.number_of_misses, update_it->second.number_of_misses);
 
   DBIdCacheMap::const_iterator update_id_it = db_id_cache()->find(key);
   EXPECT_TRUE(update_id_it != db_id_cache()->end());
@@ skipping 31 matching lines @@
   for (size_t i = 0; i < arraysize(test_url_db); ++i) {
     DBCacheKey key = { test_url_db[i].user_text, test_url_db[i].url };
 
     bool deleted = (i < 2);
     EXPECT_EQ(deleted, db_cache()->find(key) == db_cache()->end());
     EXPECT_EQ(deleted, db_id_cache()->find(key) == db_id_cache()->end());
   }
 }
 
 TEST_F(AutocompleteActionPredictorTest, DeleteOldIdsFromCaches) {
-  std::vector<AutocompleteActionPredictorDatabase::Row::Id> expected;
-  std::vector<AutocompleteActionPredictorDatabase::Row::Id> all_ids;
+  std::vector<AutocompleteActionPredictorTable::Row::Id> expected;
+  std::vector<AutocompleteActionPredictorTable::Row::Id> all_ids;
 
   for (size_t i = 0; i < arraysize(test_url_db); ++i) {
     std::string row_id = AddRow(test_url_db[i]);
     all_ids.push_back(row_id);
 
     bool exclude_url = StartsWithASCII(test_url_db[i].url.path(), "/d", true) ||
         (test_url_db[i].days_from_now > maximum_days_to_keep_entry());
 
     if (exclude_url)
       expected.push_back(row_id);
     else
       ASSERT_TRUE(AddRowToHistory(test_url_db[i]));
   }
 
-  std::vector<AutocompleteActionPredictorDatabase::Row::Id> id_list;
+  std::vector<AutocompleteActionPredictorTable::Row::Id> id_list;
   DeleteOldIdsFromCaches(&id_list);
   EXPECT_EQ(expected.size(), id_list.size());
   EXPECT_EQ(all_ids.size() - expected.size(), db_cache()->size());
   EXPECT_EQ(all_ids.size() - expected.size(), db_id_cache()->size());
 
-  for (std::vector<AutocompleteActionPredictorDatabase::Row::Id>::iterator it =
+  for (std::vector<AutocompleteActionPredictorTable::Row::Id>::iterator it =
        all_ids.begin();
        it != all_ids.end(); ++it) {
     bool in_expected =
         (std::find(expected.begin(), expected.end(), *it) != expected.end());
     bool in_list =
         (std::find(id_list.begin(), id_list.end(), *it) != id_list.end());
     EXPECT_EQ(in_expected, in_list);
   }
 }
 
@@ skipping 22 matching lines @@
     AutocompleteActionPredictor::Action expected_action =
         (test_url_db[i].expected_action ==
          AutocompleteActionPredictor::ACTION_PRERENDER) ?
         AutocompleteActionPredictor::ACTION_PRECONNECT :
         test_url_db[i].expected_action;
     EXPECT_EQ(expected_action,
               predictor()->RecommendAction(test_url_db[i].user_text, match))
         << "Unexpected action for " << match.destination_url;
   }
 }
+
+}  // namespace predictors