Remove base's implicit_cast.

net/disk_cache/backend_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 <stdint.h>
 
 #include "base/basictypes.h"
 #include "base/files/file_util.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
@@ skipping 234 matching lines @@
   const int kNumEntries = 10;
 
   for (int i = 0; i < kNumEntries; ++i) {
     std::string key = GenerateKey(true);
     disk_cache::Entry* entry;
     if (CreateEntry(key, &entry) != net::OK)
       return false;
     key_pool->insert(key);
     entry->Close();
   }
-  return key_pool->size() == implicit_cast<size_t>(cache_->GetEntryCount());
+  return key_pool->size() == static_cast<size_t>(cache_->GetEntryCount());
 }
 
 // Performs iteration over the backend and checks that the keys of entries
 // opened are in |keys_to_match|, then erases them. Up to |max_to_open| entries
 // will be opened, if it is positive. Otherwise, iteration will continue until
 // OpenNextEntry stops returning net::OK.
 bool DiskCacheBackendTest::EnumerateAndMatchKeys(
     int max_to_open,
     TestIterator* iter,
     std::set<std::string>* keys_to_match,
     size_t* count) {
   disk_cache::Entry* entry;
 
   if (!iter)
     return false;
   while (iter->OpenNextEntry(&entry) == net::OK) {
     if (!entry)
       return false;
     EXPECT_EQ(1U, keys_to_match->erase(entry->GetKey()));
     entry->Close();
     ++(*count);
-    if (max_to_open >= 0 && implicit_cast<int>(*count) >= max_to_open)
+    if (max_to_open >= 0 && static_cast<int>(*count) >= max_to_open)
       break;
   };
 
   return true;
 }
 
 void DiskCacheBackendTest::BackendBasics() {
   InitCache();
   disk_cache::Entry *entry1 = NULL, *entry2 = NULL;
   EXPECT_NE(net::OK, OpenEntry("the first key", &entry1));
@@ skipping 3032 matching lines @@
   // The entry is being closed on the Simple Cache worker pool
   disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
   base::RunLoop().RunUntilIdle();
 
   // Write an invalid header for stream 0 and stream 1.
   base::FilePath entry_file1_path = cache_path_.AppendASCII(
       disk_cache::simple_util::GetFilenameFromKeyAndFileIndex(key, 0));
 
   disk_cache::SimpleFileHeader header;
   header.initial_magic_number = UINT64_C(0xbadf00d);
-  EXPECT_EQ(
-      implicit_cast<int>(sizeof(header)),
-      base::WriteFile(entry_file1_path, reinterpret_cast<char*>(&header),
-                           sizeof(header)));
+  EXPECT_EQ(static_cast<int>(sizeof(header)),
+            base::WriteFile(entry_file1_path, reinterpret_cast<char*>(&header),
+                            sizeof(header)));
   ASSERT_EQ(net::ERR_FAILED, OpenEntry(key, &entry));
 }
 
 // Tests that the Simple Cache Backend fails to initialize with non-matching
 // file structure on disk.
 TEST_F(DiskCacheBackendTest, SimpleCacheOverBlockfileCache) {
   // Create a cache structure with the |BackendImpl|.
   InitCache();
   disk_cache::Entry* entry;
   const int kSize = 50;
@@ skipping 138 matching lines @@
   const int kSize = 50;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kSize));
   CacheTestFillBuffer(buffer->data(), kSize, false);
   ASSERT_EQ(kSize,
             WriteData(corrupted_entry, 0, 0, buffer.get(), kSize, false));
   ASSERT_EQ(kSize, ReadData(corrupted_entry, 0, 0, buffer.get(), kSize));
   corrupted_entry->Close();
 
   EXPECT_TRUE(disk_cache::simple_util::CreateCorruptFileForTests(
       key, cache_path_));
-  EXPECT_EQ(key_pool.size() + 1,
-            implicit_cast<size_t>(cache_->GetEntryCount()));
+  EXPECT_EQ(key_pool.size() + 1, static_cast<size_t>(cache_->GetEntryCount()));
 
   // Check that enumeration returns all entries but the corrupt one.
   std::set<std::string> keys_to_match(key_pool);
   scoped_ptr<TestIterator> iter = CreateIterator();
   size_t count = 0;
   ASSERT_TRUE(EnumerateAndMatchKeys(-1, iter.get(), &keys_to_match, &count));
   iter.reset();
 
   EXPECT_EQ(key_pool.size(), count);
   EXPECT_TRUE(keys_to_match.empty());
@@ skipping 21 matching lines @@
 // after closing.
 // NOTE: IF THIS TEST IS FLAKY THEN IT IS FAILING. See https://crbug.com/416940
 TEST_F(DiskCacheBackendTest, SimpleCacheDeleteQuickly) {
   SetSimpleCacheMode();
   for (int i = 0; i < 100; ++i) {
     InitCache();
     cache_.reset();
     EXPECT_TRUE(CleanupCacheDir());
   }
 }