Move ScopedFILE to base namespace and scoped_file.h

chrome/browser/safe_browsing/prefix_set_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/safe_browsing/prefix_set.h"
 
 #include <algorithm>
 #include <iterator>
 
 #include "base/file_util.h"
+#include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/md5.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/rand_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 namespace {
 
@@ skipping 126 matching lines @@
     ASSERT_EQ(file_size, ftell(fp));
   }
 
   // Open |filename| and increment the uint32 at |offset| by |inc|.
   // Then re-generate the checksum to account for the new contents.
   void ModifyAndCleanChecksum(const base::FilePath& filename, long offset,
                               int inc) {
     int64 size_64;
     ASSERT_TRUE(base::GetFileSize(filename, &size_64));
 
-    file_util::ScopedFILE file(base::OpenFile(filename, "r+b"));
+    base::ScopedFILE file(base::OpenFile(filename, "r+b"));
     IncrementIntAt(file.get(), offset, inc);
     CleanChecksum(file.get());
     file.reset();
 
     int64 new_size_64;
     ASSERT_TRUE(base::GetFileSize(filename, &new_size_64));
     ASSERT_EQ(new_size_64, size_64);
   }
 
   // Tests should not modify this shared resource.
@@ skipping 192 matching lines @@
     CheckPrefixes(*prefix_set, prefixes);
   }
 }
 
 // Check that |CleanChecksum()| makes an acceptable checksum.
 TEST_F(PrefixSetTest, CorruptionHelpers) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   // This will modify data in |index_|, which will fail the digest check.
-  file_util::ScopedFILE file(base::OpenFile(filename, "r+b"));
+  base::ScopedFILE file(base::OpenFile(filename, "r+b"));
   IncrementIntAt(file.get(), kPayloadOffset, 1);
   file.reset();
   scoped_ptr<safe_browsing::PrefixSet>
       prefix_set(safe_browsing::PrefixSet::LoadFile(filename));
   ASSERT_FALSE(prefix_set.get());
 
   // Fix up the checksum and it will read successfully (though the
   // data will be wrong).
   file.reset(base::OpenFile(filename, "r+b"));
   CleanChecksum(file.get());
@@ skipping 49 matching lines @@
       prefix_set(safe_browsing::PrefixSet::LoadFile(filename));
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test that the digest catches corruption in the middle of the file
 // (in the payload between the header and the digest).
 TEST_F(PrefixSetTest, CorruptionPayload) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
-  file_util::ScopedFILE file(base::OpenFile(filename, "r+b"));
+  base::ScopedFILE file(base::OpenFile(filename, "r+b"));
   ASSERT_NO_FATAL_FAILURE(IncrementIntAt(file.get(), 666, 1));
   file.reset();
   scoped_ptr<safe_browsing::PrefixSet>
       prefix_set(safe_browsing::PrefixSet::LoadFile(filename));
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test corruption in the digest itself.
 TEST_F(PrefixSetTest, CorruptionDigest) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   int64 size_64;
   ASSERT_TRUE(base::GetFileSize(filename, &size_64));
-  file_util::ScopedFILE file(base::OpenFile(filename, "r+b"));
+  base::ScopedFILE file(base::OpenFile(filename, "r+b"));
   long digest_offset = static_cast<long>(size_64 - sizeof(base::MD5Digest));
   ASSERT_NO_FATAL_FAILURE(IncrementIntAt(file.get(), digest_offset, 1));
   file.reset();
   scoped_ptr<safe_browsing::PrefixSet>
       prefix_set(safe_browsing::PrefixSet::LoadFile(filename));
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test excess data after the digest (fails the size test).
 TEST_F(PrefixSetTest, CorruptionExcess) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   // Add some junk to the trunk.
-  file_util::ScopedFILE file(base::OpenFile(filename, "ab"));
+  base::ScopedFILE file(base::OpenFile(filename, "ab"));
   const char buf[] = "im in ur base, killing ur d00dz.";
   ASSERT_EQ(strlen(buf), fwrite(buf, 1, strlen(buf), file.get()));
   file.reset();
   scoped_ptr<safe_browsing::PrefixSet>
       prefix_set(safe_browsing::PrefixSet::LoadFile(filename));
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test that files which had 64-bit size_t are discarded.
 TEST_F(PrefixSetTest, SizeTRecovery) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   // Open the file for rewrite.
-  file_util::ScopedFILE file(base::OpenFile(filename, "r+b"));
+  base::ScopedFILE file(base::OpenFile(filename, "r+b"));
 
   // Leave existing magic and version.
   ASSERT_NE(-1, fseek(file.get(), sizeof(uint32) * 2, SEEK_SET));
 
   // Indicate two index values and two deltas.
   uint32 val = 2;
   ASSERT_EQ(sizeof(val), fwrite(&val, 1, sizeof(val), file.get()));
   ASSERT_EQ(sizeof(val), fwrite(&val, 1, sizeof(val), file.get()));
 
   // Write two index values with 64-bit "size_t".
@@ skipping 22 matching lines @@
       prefix_set(safe_browsing::PrefixSet::LoadFile(filename));
   ASSERT_FALSE(prefix_set.get());
 }
 
 // Test that a version 1 file is re-ordered correctly on read.
 TEST_F(PrefixSetTest, ReadWriteSigned) {
   base::FilePath filename;
   ASSERT_TRUE(GetPrefixSetFile(&filename));
 
   // Open the file for rewrite.
-  file_util::ScopedFILE file(base::OpenFile(filename, "r+b"));
+  base::ScopedFILE file(base::OpenFile(filename, "r+b"));
 
   // Leave existing magic.
   ASSERT_NE(-1, fseek(file.get(), sizeof(uint32), SEEK_SET));
 
   // Version 1.
   uint32 version = 1;
   ASSERT_EQ(sizeof(version), fwrite(&version, 1, sizeof(version), file.get()));
 
   // Indicate two index values and two deltas.
   uint32 val = 2;
@@ skipping 37 matching lines @@
   std::vector<SBPrefix> prefixes_copy;
   prefix_set->GetPrefixes(&prefixes_copy);
   EXPECT_EQ(prefixes_copy.size(), 4u);
   EXPECT_EQ(prefixes_copy[0], 1000u);
   EXPECT_EQ(prefixes_copy[1], 1023u);
   EXPECT_EQ(prefixes_copy[2], static_cast<uint32>(-1000));
   EXPECT_EQ(prefixes_copy[3], static_cast<uint32>(-1000 + 23));
 }
 
 }  // namespace