Port some more parts of browser/...

chrome/browser/safe_browsing/safe_browsing_database_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.
 //
 // Unit tests for the SafeBrowsing storage system.
 
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
@@ skipping 45 matching lines @@
   std::wstring GetTestDatabaseName() {
     std::wstring filename;
     PathService::Get(base::DIR_TEMP, &filename);
     filename.push_back(file_util::kPathSeparator);
     filename.append(kSafeBrowsingTestDatabase);
     return filename;
   }
 
   SafeBrowsingDatabase* SetupTestDatabase() {
     std::wstring filename = GetTestDatabaseName();
-    DeleteFile(filename.c_str());  // In case it existed from a previous run.
+    // In case it existed from a previous run.
+    file_util::Delete(filename, false);
 
     SafeBrowsingDatabase* database = SafeBrowsingDatabase::Create();
     database->SetSynchronous();
     EXPECT_TRUE(database->Init(filename, NULL));
 
     return database;
   }
 
   void TearDownTestDatabase(SafeBrowsingDatabase* database) {
-    DeleteFile(GetTestDatabaseName().c_str());
+    file_util::Delete(GetTestDatabaseName(), false);
     delete database;
   }
 
 }  // namespace
 
 // Checks database reading and writing.
 TEST(SafeBrowsingDatabase, Database) {
   SafeBrowsingDatabase* database = SetupTestDatabase();
 
   // Add a simple chunk with one hostkey.
@@ skipping 47 matching lines @@
 
   chunks = new std::deque<SBChunk>;
   chunks->push_back(chunk);
   database->InsertChunks("goog-malware", chunks);
   database->UpdateFinished();
 
 
   // Make sure they were added correctly.
   std::vector<SBListChunkRanges> lists;
   database->GetListsInfo(&lists);
-  EXPECT_EQ(lists.size(), 1);
+  EXPECT_EQ(lists.size(), 1U);
   EXPECT_EQ(lists[0].name, "goog-malware");
   EXPECT_EQ(lists[0].adds, "1-3");
   EXPECT_TRUE(lists[0].subs.empty());
 
   const Time now = Time::Now();
   std::vector<SBFullHashResult> full_hashes;
   std::vector<SBPrefix> prefix_hits;
   std::string matching_list;
   EXPECT_TRUE(database->ContainsUrl(GURL("http://www.evil.com/phishing.html"),
                                     &matching_list, &prefix_hits,
                                     &full_hashes, now));
   EXPECT_EQ(prefix_hits[0], Sha256Prefix("www.evil.com/phishing.html"));
-  EXPECT_EQ(prefix_hits.size(), 1);
+  EXPECT_EQ(prefix_hits.size(), 1U);
 
   EXPECT_TRUE(database->ContainsUrl(GURL("http://www.evil.com/malware.html"),
                                     &matching_list, &prefix_hits,
                                     &full_hashes, now));
 
   EXPECT_TRUE(database->ContainsUrl(GURL("http://www.evil.com/notevil1.html"),
                                     &matching_list, &prefix_hits,
                                     &full_hashes, now));
 
   EXPECT_TRUE(database->ContainsUrl(GURL("http://www.evil.com/notevil2.html"),
                                     &matching_list, &prefix_hits,
                                     &full_hashes, now));
 
   EXPECT_TRUE(database->ContainsUrl(GURL("http://www.good.com/good1.html"),
                                     &matching_list, &prefix_hits,
                                     &full_hashes, now));
 
   EXPECT_TRUE(database->ContainsUrl(GURL("http://www.good.com/good2.html"),
                                     &matching_list, &prefix_hits,
                                     &full_hashes, now));
 
   EXPECT_TRUE(database->ContainsUrl(GURL("http://192.168.0.1/malware.html"),
                                     &matching_list, &prefix_hits,
                                     &full_hashes, now));
 
   EXPECT_FALSE(database->ContainsUrl(GURL("http://www.evil.com/"),
                                      &matching_list, &prefix_hits,
                                      &full_hashes, now));
-  EXPECT_EQ(prefix_hits.size(), 0);
+  EXPECT_EQ(prefix_hits.size(), 0U);
 
   EXPECT_FALSE(database->ContainsUrl(GURL("http://www.evil.com/robots.txt"),
                                      &matching_list, &prefix_hits,
                                      &full_hashes, now));
 
   // Test removing a single prefix from the add chunk.
   host.host = Sha256Prefix("www.evil.com/");
   host.entry = SBEntry::Create(SBEntry::SUB_PREFIX, 2);
   host.entry->set_chunk_id(2);
   host.entry->SetChunkIdAtPrefix(0, 2);
   host.entry->SetPrefixAt(0, Sha256Prefix("www.evil.com/notevil1.html"));
 
   chunk.is_add = false;
   chunk.chunk_number = 4;
   chunk.hosts.clear();
   chunk.hosts.push_back(host);
 
   chunks = new std::deque<SBChunk>;
   chunks->push_back(chunk);
 
   database->InsertChunks("goog-malware", chunks);
   database->UpdateFinished();
 
   EXPECT_TRUE(database->ContainsUrl(GURL("http://www.evil.com/phishing.html"),
                                     &matching_list, &prefix_hits,
                                     &full_hashes, now));
   EXPECT_EQ(prefix_hits[0], Sha256Prefix("www.evil.com/phishing.html"));
-  EXPECT_EQ(prefix_hits.size(), 1);
+  EXPECT_EQ(prefix_hits.size(), 1U);
 
   EXPECT_FALSE(database->ContainsUrl(GURL("http://www.evil.com/notevil1.html"),
                                      &matching_list, &prefix_hits,
                                      &full_hashes, now));
-  EXPECT_EQ(prefix_hits.size(), 0);
+  EXPECT_EQ(prefix_hits.size(), 0U);
 
   EXPECT_TRUE(database->ContainsUrl(GURL("http://www.evil.com/notevil2.html"),
                                     &matching_list, &prefix_hits,
                                     &full_hashes, now));
 
   EXPECT_TRUE(database->ContainsUrl(GURL("http://www.good.com/good1.html"),
                                     &matching_list, &prefix_hits,
                                     &full_hashes, now));
 
   EXPECT_TRUE(database->ContainsUrl(GURL("http://www.good.com/good2.html"),
                                     &matching_list, &prefix_hits,
                                     &full_hashes, now));
 
   database->GetListsInfo(&lists);
-  EXPECT_EQ(lists.size(), 1);
+  EXPECT_EQ(lists.size(), 1U);
   EXPECT_EQ(lists[0].name, "goog-malware");
   EXPECT_EQ(lists[0].subs, "4");
 
   // Test removing all the prefixes from an add chunk.
   AddDelChunk(database, "goog-malware", 2);
   database->UpdateFinished();
 
   EXPECT_FALSE(database->ContainsUrl(GURL("http://www.evil.com/notevil2.html"),
                                      &matching_list, &prefix_hits,
                                      &full_hashes, now));
 
   EXPECT_FALSE(database->ContainsUrl(GURL("http://www.good.com/good1.html"),
                                      &matching_list, &prefix_hits,
                                      &full_hashes, now));
 
   EXPECT_FALSE(database->ContainsUrl(GURL("http://www.good.com/good2.html"),
                                      &matching_list, &prefix_hits,
                                      &full_hashes, now));
 
   database->GetListsInfo(&lists);
-  EXPECT_EQ(lists.size(), 1);
+  EXPECT_EQ(lists.size(), 1U);
   EXPECT_EQ(lists[0].name, "goog-malware");
   EXPECT_EQ(lists[0].adds, "1,3");
   EXPECT_EQ(lists[0].subs, "4");
 
   // The adddel command exposed a bug in the transaction code where any
   // transaction after it would fail.  Add a dummy entry and remove it to
   // make sure the transcation works fine.
   host.host = Sha256Prefix("www.redherring.com/");
   host.entry = SBEntry::Create(SBEntry::ADD_PREFIX, 1);
   host.entry->set_chunk_id(1);
@@ skipping 10 matching lines @@
 
   // Now remove the dummy entry.  If there are any problems with the
   // transactions, asserts will fire.
   AddDelChunk(database, "goog-malware", 44);
 
   // Test the subdel command.
   SubDelChunk(database, "goog-malware", 4);
   database->UpdateFinished();
 
   database->GetListsInfo(&lists);
-  EXPECT_EQ(lists.size(), 1);
+  EXPECT_EQ(lists.size(), 1U);
   EXPECT_EQ(lists[0].name, "goog-malware");
   EXPECT_EQ(lists[0].adds, "1,3");
   EXPECT_EQ(lists[0].subs, "");
 
   // Test a sub command coming in before the add.
   host.host = Sha256Prefix("www.notevilanymore.com/");
   host.entry = SBEntry::Create(SBEntry::SUB_PREFIX, 2);
   host.entry->set_chunk_id(10);
   host.entry->SetPrefixAt(0, Sha256Prefix("www.notevilanymore.com/index.html"));
   host.entry->SetChunkIdAtPrefix(0, 10);
@@ skipping 157 matching lines @@
   database->UpdateFinished();
   list_chunks_empty.clear();
   database->GetListsInfo(&list_chunks_empty);
   EXPECT_EQ(list_chunks_empty[0].adds, "1,10,19-20,22");
   EXPECT_EQ(list_chunks_empty[0].subs, "");
 
   TearDownTestDatabase(database);
 }
 
 void PrintStat(const wchar_t* name) {
+#if defined(OS_WIN)
   int value = StatsTable::current()->GetCounterValue(name);
-  std::wstring out = StringPrintf(L"%ls %d\r\n", name, value);
-  OutputDebugStringW(out.c_str());
+  LOG(INFO) << StringPrintf(L"%ls %d", name, value);
+#else
+  // TODO(port): Enable when StatsTable is ported.
+  NOTIMPLEMENTED();
+#endif
 }
 
 std::wstring GetFullSBDataPath(const std::wstring& path) {
   std::wstring full_path;
   CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &full_path));
-  file_util::AppendToPath(&full_path, L"chrome\\test\\data\\safe_browsing");
+  file_util::AppendToPath(&full_path, L"chrome");
+  file_util::AppendToPath(&full_path, L"test");
+  file_util::AppendToPath(&full_path, L"data");
+  file_util::AppendToPath(&full_path, L"safe_browsing");
   file_util::AppendToPath(&full_path, path);
   CHECK(file_util::PathExists(full_path));
   return full_path;
 }
 
 struct ChunksInfo {
   std::deque<SBChunk>* chunks;
   std::string listname;
 };
 
 void PeformUpdate(const std::wstring& initial_db,
                   const std::vector<ChunksInfo>& chunks,
                   std::vector<SBChunkDelete>* deletes) {
   IoCounters before, after;
 
   std::wstring filename;
   PathService::Get(base::DIR_TEMP, &filename);
   filename.push_back(file_util::kPathSeparator);
   filename.append(L"SafeBrowsingTestDatabase");
-  DeleteFile(filename.c_str());  // In case it existed from a previous run.
+  // In case it existed from a previous run.
+  file_util::Delete(filename, false);
 
   if (!initial_db.empty()) {
     std::wstring full_initial_db = GetFullSBDataPath(initial_db);
     ASSERT_TRUE(file_util::CopyFile(full_initial_db, filename));
   }
 
   SafeBrowsingDatabase* database = SafeBrowsingDatabase::Create();
   database->SetSynchronous();
   EXPECT_TRUE(database->Init(filename, NULL));
 
   Time before_time = Time::Now();
   ProcessHandle handle = Process::Current().handle();
   scoped_ptr<process_util::ProcessMetrics> metric(
       process_util::ProcessMetrics::CreateProcessMetrics(handle));
   CHECK(metric->GetIOCounters(&before));
 
   database->DeleteChunks(deletes);
 
   for (size_t i = 0; i < chunks.size(); ++i)
     database->InsertChunks(chunks[i].listname, chunks[i].chunks);
 
   database->UpdateFinished();
 
   CHECK(metric->GetIOCounters(&after));
 
-  OutputDebugStringA(StringPrintf("I/O Read Bytes: %d\r\n",
-      after.ReadTransferCount - before.ReadTransferCount).c_str());
-  OutputDebugStringA(StringPrintf("I/O Write Bytes: %d\r\n",
-      after.WriteTransferCount - before.WriteTransferCount).c_str());
-  OutputDebugStringA(StringPrintf("I/O Reads: %d\r\n",
-      after.ReadOperationCount - before.ReadOperationCount).c_str());
-  OutputDebugStringA(StringPrintf("I/O Writes: %d\r\n",
-      after.WriteOperationCount - before.WriteOperationCount).c_str());
-  OutputDebugStringA(StringPrintf("Finished in %d ms\r\n",
-    (Time::Now() - before_time).InMilliseconds()).c_str());
+  LOG(INFO) << StringPrintf("I/O Read Bytes: %d",
+      after.ReadTransferCount - before.ReadTransferCount);
+  LOG(INFO) << StringPrintf("I/O Write Bytes: %d",
+      after.WriteTransferCount - before.WriteTransferCount);
+  LOG(INFO) << StringPrintf("I/O Reads: %d",
+      after.ReadOperationCount - before.ReadOperationCount);
+  LOG(INFO) << StringPrintf("I/O Writes: %d",
+      after.WriteOperationCount - before.WriteOperationCount);
+  LOG(INFO) << StringPrintf("Finished in %d ms",
+      (Time::Now() - before_time).InMilliseconds());
 
   PrintStat(L"c:SB.HostSelect");
   PrintStat(L"c:SB.HostSelectForBloomFilter");
   PrintStat(L"c:SB.HostReplace");
   PrintStat(L"c:SB.HostInsert");
   PrintStat(L"c:SB.HostDelete");
   PrintStat(L"c:SB.ChunkSelect");
   PrintStat(L"c:SB.ChunkInsert");
   PrintStat(L"c:SB.ChunkDelete");
   PrintStat(L"c:SB.TransactionCommit");
@@ skipping 60 matching lines @@
                                   &urls);
       DCHECK(result);
       if (!updates_path.empty())
         DCHECK(urls.size() == chunks.size());
     }
   }
 
   PeformUpdate(initial_db, chunks, deletes);
 }
 
+namespace {
+
+const wchar_t* GetOldSafeBrowsingPath() {
+  std::wstring path = L"old";
+  file_util::AppendToPath(&path, L"SafeBrowsing");
+  return path.c_str();
+}
+
+const wchar_t* GetOldResponsePath() {
+  std::wstring path = L"old";
+  file_util::AppendToPath(&path, L"response");
+  return path.c_str();
+}
+
+const wchar_t* GetOldUpdatesPath() {
+  std::wstring path = L"old";
+  file_util::AppendToPath(&path, L"updates");
+  return path.c_str();
+}
+
+}  // namespace
+
 // Counts the IO needed for the initial update of a database.
 // test\data\safe_browsing\download_update.py was used to fetch the add/sub
 // chunks that are read, in order to get repeatable runs.
 TEST(SafeBrowsingDatabase, DISABLED_DatabaseInitialIO) {
   UpdateDatabase(L"", L"", L"initial");
 }
 
+// TODO(port): For now on Linux the test below would fail with error below:
+// [1004/201323:FATAL:browser/safe_browsing/safe_browsing_database_impl.cc(712)]
+// Check failed: false.
+//
 // Counts the IO needed to update a month old database.
 // The data files were generated by running "..\download_update.py postdata"
 // in the "safe_browsing\old" directory.
 TEST(SafeBrowsingDatabase, DISABLED_DatabaseOldIO) {
-  UpdateDatabase(L"old\\SafeBrowsing", L"old\\response", L"old\\updates");
+  UpdateDatabase(GetOldSafeBrowsingPath(), GetOldResponsePath(),
+                 GetOldUpdatesPath());
 }
 
+// TODO(port): For now on Linux the test below would fail with error below:
+// [1004/201323:FATAL:browser/safe_browsing/safe_browsing_database_impl.cc(712)]
+// Check failed: false.
+//
 // Like DatabaseOldIO but only the deletes.
 TEST(SafeBrowsingDatabase, DISABLED_DatabaseOldDeletesIO) {
-  UpdateDatabase(L"old\\SafeBrowsing", L"old\\response", L"");
+  UpdateDatabase(GetOldSafeBrowsingPath(), GetOldResponsePath(), L"");
 }
 
 // Like DatabaseOldIO but only the updates.
 TEST(SafeBrowsingDatabase, DISABLED_DatabaseOldUpdatesIO) {
-  UpdateDatabase(L"old\\SafeBrowsing", L"", L"old\\updates");
+  UpdateDatabase(GetOldSafeBrowsingPath(), L"", GetOldUpdatesPath());
 }
 
+// TODO(port): For now on Linux the test below would fail with error below:
+// [1004/201323:FATAL:browser/safe_browsing/safe_browsing_database_impl.cc(712)]
+// Check failed: false.
+//
 // Does a a lot of addel's on very large chunks.
 TEST(SafeBrowsingDatabase, DISABLED_DatabaseOldLotsofDeletesIO) {
   std::vector<ChunksInfo> chunks;
   std::vector<SBChunkDelete>* deletes = new std::vector<SBChunkDelete>;
   SBChunkDelete del;
   del.is_sub_del = false;
   del.list_name = "goog-malware-shavar";
   del.chunk_del.push_back(ChunkRange(3539, 3579));
   deletes->push_back(del);
-  PeformUpdate(L"old\\SafeBrowsing", chunks, deletes);
+  PeformUpdate(GetOldSafeBrowsingPath(), chunks, deletes);
 }