Refactor base/safe_numerics.h

components/policy/core/common/cloud/resource_cache.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 "components/policy/core/common/cloud/resource_cache.h"
 
 #include "base/base64.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/logging.h"
-#include "base/safe_numerics.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
 
 namespace policy {
 
 namespace {
 
 // Verifies that |value| is not empty and encodes it into base64url format,
 // which is safe to use as a file name on all platforms.
 bool Base64Encode(const std::string& value, std::string* encoded) {
@@ skipping 52 matching lines @@
   base::FilePath subkey_path;
   // Delete the file before writing to it. This ensures that the write does not
   // follow a symlink planted at |subkey_path|, clobbering a file outside the
   // cache directory. The mechanism is meant to foil file-system-level attacks
   // where a symlink is planted in the cache directory before Chrome has
   // started. An attacker controlling a process running concurrently with Chrome
   // would be able to race against the protection by re-creating the symlink
   // between these two calls. There is nothing in file_util that could be used
   // to protect against such races, especially as the cache is cross-platform
   // and therefore cannot use any POSIX-only tricks.
-  int size = base::checked_numeric_cast<int>(data.size());
+  int size = base::checked_cast<int>(data.size());
   return VerifyKeyPathAndGetSubkeyPath(key, true, subkey, &subkey_path) &&
          base::DeleteFile(subkey_path, false) &&
          (file_util::WriteFile(subkey_path, data.data(), size) == size);
 }
 
 bool ResourceCache::Load(const std::string& key,
                          const std::string& subkey,
                          std::string* data) {
   DCHECK(task_runner_->RunsTasksOnCurrentThread());
   base::FilePath subkey_path;
@@ skipping 136 matching lines @@
   if (!VerifyKeyPath(key, allow_create_key, &key_path) ||
       !Base64Encode(subkey, &encoded)) {
     return false;
   }
   *path = key_path.AppendASCII(encoded);
   return true;
 }
 
 
 }  // namespace policy