Roll forward 8722,8721

chrome/browser/visitedlink_unittest.cc

 // Copyright (c) 2006-2008 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 <vector>
 #include <string>
 #include <cstdio>
 
 #include "base/message_loop.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
+#include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/string_util.h"
 #include "chrome/browser/visitedlink_master.h"
 #include "chrome/renderer/visitedlink_slave.h"
 #include "googleurl/src/gurl.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 // a nice long URL that we can append numbers to to get new URLs
 const char g_test_prefix[] =
   "http://www.google.com/products/foo/index.html?id=45028640526508376&seq=";
 const int g_test_count = 1000;
 
 // Returns a test URL for index |i|
 GURL TestURL(int i) {
   return GURL(StringPrintf("%s%d", g_test_prefix, i));
 }
 
-// when testing in single-threaded mode
-VisitedLinkMaster* g_master = NULL;
 std::vector<VisitedLinkSlave*> g_slaves;
 
 VisitedLinkMaster::PostNewTableEvent SynchronousBroadcastNewTableEvent;
 void SynchronousBroadcastNewTableEvent(base::SharedMemory* table) {
   if (table) {
     for (std::vector<VisitedLinkSlave>::size_type i = 0;
-         i < (int)g_slaves.size(); i++) {
+         i < g_slaves.size(); i++) {
       base::SharedMemoryHandle new_handle = NULL;
-      table->ShareToProcess(GetCurrentProcess(), &new_handle);
+      table->ShareToProcess(base::GetCurrentProcessHandle(), &new_handle);
       g_slaves[i]->Init(new_handle);
     }
   }
 }
 
+}  // namespace
+
 class VisitedLinkTest : public testing::Test {
  protected:
   // Initialize the history system. This should be called before InitVisited().
   bool InitHistory() {
     history_service_ = new HistoryService;
-    return history_service_->Init(history_dir_, NULL);
+    return history_service_->Init(history_dir_.ToWStringHack(), NULL);
   }
 
   // Initializes the visited link objects. Pass in the size that you want a
   // freshly created table to be. 0 means use the default.
   //
   // |suppress_rebuild| is set when we're not testing rebuilding, see
   // the VisitedLinkMaster constructor.
   bool InitVisited(int initial_size, bool suppress_rebuild) {
     // Initialize the visited link system.
     master_.reset(new VisitedLinkMaster(NULL,
@@ skipping 33 matching lines @@
     ASSERT_TRUE(InitVisited(0, true));
     master_->DebugValidate();
 
     // check that the table has the proper number of entries
     int used_count = master_->GetUsedCount();
     ASSERT_EQ(used_count, g_test_count);
 
     // Create a slave database.
     VisitedLinkSlave slave;
     base::SharedMemoryHandle new_handle = NULL;
-    master_->ShareToProcess(GetCurrentProcess(), &new_handle);
+    master_->ShareToProcess(base::GetCurrentProcessHandle(), &new_handle);
     bool success = slave.Init(new_handle);
     ASSERT_TRUE(success);
     g_slaves.push_back(&slave);
 
     bool found;
     for (int i = 0; i < g_test_count; i++) {
       GURL cur = TestURL(i);
       found = master_->IsVisited(cur);
       EXPECT_TRUE(found) << "URL " << i << "not found in master.";
 
       found = slave.IsVisited(cur);
       EXPECT_TRUE(found) << "URL " << i << "not found in slave.";
     }
 
     // test some random URL so we know that it returns false sometimes too
     found = master_->IsVisited(GURL("http://unfound.site/"));
     ASSERT_FALSE(found);
     found = slave.IsVisited(GURL("http://unfound.site/"));
     ASSERT_FALSE(found);
 
     master_->DebugValidate();
 
     g_slaves.clear();
   }
 
   // testing::Test
   virtual void SetUp() {
     PathService::Get(base::DIR_TEMP, &history_dir_);
-    file_util::AppendToPath(&history_dir_, L"VisitedLinkTest");
+    history_dir_ = history_dir_.Append(FILE_PATH_LITERAL("VisitedLinkTest"));
     file_util::Delete(history_dir_, true);
     file_util::CreateDirectory(history_dir_);
 
-    visited_file_ = history_dir_;
-    file_util::AppendToPath(&visited_file_, L"VisitedLinks");
+    visited_file_ = history_dir_.Append(FILE_PATH_LITERAL("VisitedLinks"));
   }
 
   virtual void TearDown() {
     ClearDB();
     file_util::Delete(history_dir_, true);
   }
   
   MessageLoop message_loop_;
 
   // Filenames for the services;
-  std::wstring history_dir_;
-  std::wstring visited_file_;
+  FilePath history_dir_;
+  FilePath visited_file_;
 
   scoped_ptr<VisitedLinkMaster> master_;
   scoped_refptr<HistoryService> history_service_;
 };
 
-} // namespace
-
 // This test creates and reads some databases to make sure the data is
 // preserved throughout those operations.
 TEST_F(VisitedLinkTest, DatabaseIO) {
   ASSERT_TRUE(InitHistory());
   ASSERT_TRUE(InitVisited(0, true));
 
   for (int i = 0; i < g_test_count; i++)
     master_->AddURL(TestURL(i));
 
   // Test that the database was written properly
   Reload();
 }
 
 // Checks that we can delete things properly when there are collisions.
 TEST_F(VisitedLinkTest, Delete) {
   static const int32 kInitialSize = 17;
   ASSERT_TRUE(InitHistory());
   ASSERT_TRUE(InitVisited(kInitialSize, true));
 
   // Add a cluster from 14-17 wrapping around to 0. These will all hash to the
   // same value.
-  const int kFingerprint0 = kInitialSize * 0 + 14;
-  const int kFingerprint1 = kInitialSize * 1 + 14;
-  const int kFingerprint2 = kInitialSize * 2 + 14;
-  const int kFingerprint3 = kInitialSize * 3 + 14;
-  const int kFingerprint4 = kInitialSize * 4 + 14;
+  const VisitedLinkCommon::Fingerprint kFingerprint0 = kInitialSize * 0 + 14;
+  const VisitedLinkCommon::Fingerprint kFingerprint1 = kInitialSize * 1 + 14;
+  const VisitedLinkCommon::Fingerprint kFingerprint2 = kInitialSize * 2 + 14;
+  const VisitedLinkCommon::Fingerprint kFingerprint3 = kInitialSize * 3 + 14;
+  const VisitedLinkCommon::Fingerprint kFingerprint4 = kInitialSize * 4 + 14;
   master_->AddFingerprint(kFingerprint0);  // @14
   master_->AddFingerprint(kFingerprint1);  // @15
   master_->AddFingerprint(kFingerprint2);  // @16
   master_->AddFingerprint(kFingerprint3);  // @0
   master_->AddFingerprint(kFingerprint4);  // @1
 
   // Deleting 14 should move the next value up one slot (we do not specify an
   // order).
   EXPECT_EQ(kFingerprint3, master_->hash_table_[0]);
   master_->DeleteFingerprint(kFingerprint3, false);
-  EXPECT_EQ(0, master_->hash_table_[1]);
-  EXPECT_NE(0, master_->hash_table_[0]);
+  VisitedLinkCommon::Fingerprint zero_fingerprint = 0;
+  EXPECT_EQ(zero_fingerprint, master_->hash_table_[1]);
+  EXPECT_NE(zero_fingerprint, master_->hash_table_[0]);
 
   // Deleting the other four should leave the table empty.
   master_->DeleteFingerprint(kFingerprint0, false);
   master_->DeleteFingerprint(kFingerprint1, false);
   master_->DeleteFingerprint(kFingerprint2, false);
   master_->DeleteFingerprint(kFingerprint4, false);
 
   EXPECT_EQ(0, master_->used_items_);
   for (int i = 0; i < kInitialSize; i++)
-    EXPECT_EQ(0, master_->hash_table_[i]) << "Hash table has values in it.";
+    EXPECT_EQ(zero_fingerprint, master_->hash_table_[i]) <<
+        "Hash table has values in it.";
 }
 
 // When we delete more than kBigDeleteThreshold we trigger different behavior
 // where the entire file is rewritten.
 TEST_F(VisitedLinkTest, BigDelete) {
   ASSERT_TRUE(InitHistory());
   ASSERT_TRUE(InitVisited(16381, true));
 
   // Add the base set of URLs that won't be deleted.
   // Reload() will test for these.
@@ skipping 15 matching lines @@
   Reload();
 }
 
 TEST_F(VisitedLinkTest, DeleteAll) {
   ASSERT_TRUE(InitHistory());
   ASSERT_TRUE(InitVisited(0, true));
 
   {
     VisitedLinkSlave slave;
     base::SharedMemoryHandle new_handle = NULL;
-    master_->ShareToProcess(GetCurrentProcess(), &new_handle);
+    master_->ShareToProcess(base::GetCurrentProcessHandle(), &new_handle);
     ASSERT_TRUE(slave.Init(new_handle));
     g_slaves.push_back(&slave);
 
     // Add the test URLs.
     for (int i = 0; i < g_test_count; i++) {
       master_->AddURL(TestURL(i));
       ASSERT_EQ(i + 1, master_->GetUsedCount());
     }
     master_->DebugValidate();
 
@@ skipping 27 matching lines @@
 // full, notifies its slaves of the change, and updates the disk.
 TEST_F(VisitedLinkTest, Resizing) {
   // Create a very small database.
   const int32 initial_size = 17;
   ASSERT_TRUE(InitHistory());
   ASSERT_TRUE(InitVisited(initial_size, true));
 
   // ...and a slave
   VisitedLinkSlave slave;
   base::SharedMemoryHandle new_handle = NULL;
-  master_->ShareToProcess(GetCurrentProcess(), &new_handle);
+  master_->ShareToProcess(base::GetCurrentProcessHandle(), &new_handle);
   bool success = slave.Init(new_handle);
   ASSERT_TRUE(success);
   g_slaves.push_back(&slave);
 
   int32 used_count = master_->GetUsedCount();
   ASSERT_EQ(used_count, 0);
 
   for (int i = 0; i < g_test_count; i++) {
     master_->AddURL(TestURL(i));
     used_count = master_->GetUsedCount();
@@ skipping 65 matching lines @@
   master_->set_rebuild_complete_task(new MessageLoop::QuitTask);
   MessageLoop::current()->Run();
 
   // Test that all URLs were written to the database properly.
   Reload();
 
   // Make sure the extra one was *not* written (Reload won't test this).
   EXPECT_FALSE(master_->IsVisited(TestURL(g_test_count)));
 }