Remove base's implicit_cast.

net/disk_cache/simple/simple_synchronous_entry.cc

 // Copyright (c) 2013 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 "net/disk_cache/simple/simple_synchronous_entry.h"
 
 #include <algorithm>
 #include <cstring>
 #include <functional>
 #include <limits>
@@ skipping 921 matching lines @@
 
     if (header.version != kSimpleEntryVersionOnDisk) {
       DLOG(WARNING) << "Unreadable version.";
       RecordSyncOpenResult(cache_type_, OPEN_ENTRY_BAD_VERSION, had_index);
       return net::ERR_FAILED;
     }
 
     scoped_ptr<char[]> key(new char[header.key_length]);
     int key_read_result = files_[i].Read(sizeof(header), key.get(),
                                          header.key_length);
-    if (key_read_result != implicit_cast<int>(header.key_length)) {
+    if (key_read_result != base::checked_cast<int>(header.key_length)) {
       DLOG(WARNING) << "Cannot read key from entry.";
       RecordSyncOpenResult(cache_type_, OPEN_ENTRY_CANT_READ_KEY, had_index);
       return net::ERR_FAILED;
     }
 
     key_ = std::string(key.get(), header.key_length);
     if (i == 0) {
       // File size for stream 0 has been stored temporarily in data_size[1].
       int total_data_size =
           GetDataSizeFromKeyAndFileSize(key_, out_entry_stat->data_size(1));
@@ skipping 58 matching lines @@
 
   int bytes_written = files_[file_index].Write(
       0, reinterpret_cast<char*>(&header), sizeof(header));
   if (bytes_written != sizeof(header)) {
     *out_result = CREATE_ENTRY_CANT_WRITE_HEADER;
     return false;
   }
 
   bytes_written = files_[file_index].Write(sizeof(header), key_.data(),
                                            key_.size());
-  if (bytes_written != implicit_cast<int>(key_.size())) {
+  if (bytes_written != base::checked_cast<int>(key_.size())) {
     *out_result = CREATE_ENTRY_CANT_WRITE_KEY;
     return false;
   }
 
   return true;
 }
 
 int SimpleSynchronousEntry::InitializeForCreate(
     bool had_index,
     SimpleEntryStat* out_entry_stat) {
@@ skipping 209 matching lines @@
 
   int header_write_result =
       sparse_file_.Write(0, reinterpret_cast<char*>(&header), sizeof(header));
   if (header_write_result != sizeof(header)) {
     DLOG(WARNING) << "Could not write sparse file header";
     return false;
   }
 
   int key_write_result = sparse_file_.Write(sizeof(header), key_.data(),
                                             key_.size());
-  if (key_write_result != implicit_cast<int>(key_.size())) {
+  if (key_write_result != base::checked_cast<int>(key_.size())) {
     DLOG(WARNING) << "Could not write sparse file key";
     return false;
   }
 
   sparse_ranges_.clear();
   sparse_tail_offset_ = sizeof(header) + key_.size();
 
   return true;
 }
 
@@ skipping 109 matching lines @@
 
     SimpleFileSparseRangeHeader header;
     header.sparse_range_magic_number = kSimpleSparseRangeMagicNumber;
     header.offset = range->offset;
     header.length = range->length;
     header.data_crc32 = range->data_crc32;
 
     int bytes_written = sparse_file_.Write(range->file_offset - sizeof(header),
                                            reinterpret_cast<char*>(&header),
                                            sizeof(header));
-    if (bytes_written != implicit_cast<int>(sizeof(header))) {
+    if (bytes_written != base::checked_cast<int>(sizeof(header))) {
       DLOG(WARNING) << "Could not rewrite sparse range header.";
       return false;
     }
   }
 
   int bytes_written = sparse_file_.Write(range->file_offset + offset, buf, len);
   if (bytes_written < len) {
     DLOG(WARNING) << "Could not write sparse range.";
     return false;
   }
@@ skipping 14 matching lines @@
 
   SimpleFileSparseRangeHeader header;
   header.sparse_range_magic_number = kSimpleSparseRangeMagicNumber;
   header.offset = offset;
   header.length = len;
   header.data_crc32 = data_crc32;
 
   int bytes_written = sparse_file_.Write(sparse_tail_offset_,
                                          reinterpret_cast<char*>(&header),
                                          sizeof(header));
-  if (bytes_written != implicit_cast<int>(sizeof(header))) {
+  if (bytes_written != base::checked_cast<int>(sizeof(header))) {
     DLOG(WARNING) << "Could not append sparse range header.";
     return false;
   }
   sparse_tail_offset_ += bytes_written;
 
   bytes_written = sparse_file_.Write(sparse_tail_offset_, buf, len);
   if (bytes_written < len) {
     DLOG(WARNING) << "Could not append sparse range data.";
     return false;
   }
   int64 data_file_offset = sparse_tail_offset_;
   sparse_tail_offset_ += bytes_written;
 
   SparseRange range;
   range.offset = offset;
   range.length = len;
   range.data_crc32 = data_crc32;
   range.file_offset = data_file_offset;
   sparse_ranges_.insert(std::make_pair(offset, range));
 
   return true;
 }
 
 }  // namespace disk_cache