Update //base to chromium 9659b08ea5a34f889dc4166217f438095ddc10d2

services/url_response_disk_cache/url_response_disk_cache_impl.cc

 // Copyright 2015 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 "services/url_response_disk_cache/url_response_disk_cache_impl.h"
 
 #include <dirent.h>
 #include <fcntl.h>
 #include <sys/types.h>
 
@@ skipping 219 matching lines @@
   for (size_t i = 0u; i < headers.size(); ++i) {
     const std::string& name = headers[i]->name.get();
     if (base::LowerCaseEqualsASCII(name, header_name.c_str()))
       result.push_back(headers[i]->value);
   }
   return result;
 }
 
 // Returns whether the given |entry| is valid.
 bool IsCacheEntryValid(const CacheEntryPtr& entry) {
-  return entry && PathExists(base::FilePath(entry->response_body_path));
+  return entry &&
+         PathExists(base::FilePath::FromUTF8Unsafe(entry->response_body_path));
 }
 
 // Returns whether the given directory |entry| is valid and its content can be
 // used for the given |response|.
 bool IsCacheEntryFresh(const URLResponsePtr& response,
                        const CacheEntryPtr& entry) {
   DCHECK(response);
   if (!IsCacheEntryValid(entry))
     return false;
 
@@ skipping 27 matching lines @@
 
 void PruneCache(scoped_refptr<URLResponseDiskCacheDB> db,
                 const scoped_ptr<URLResponseDiskCacheDB::Iterator>& iterator) {
   CacheKeyPtr last_key;
   CacheKeyPtr key;
   CacheEntryPtr entry;
   while (iterator->HasNext()) {
     iterator->GetNext(&key, &entry);
     if (last_key && last_key->request_origin == key->request_origin &&
         last_key->url == key->url) {
-      base::FilePath entry_directory = base::FilePath(entry->entry_directory);
+      base::FilePath entry_directory =
+          base::FilePath::FromUTF8Unsafe(entry->entry_directory);
       if (base::DeleteFile(entry_directory, true))
         db->Delete(key.Clone());
     }
     last_key = key.Pass();
   }
 }
 
 }  // namespace
 
 // static
@@ skipping 84 matching lines @@
             base::Bind(&RunMojoCallbackWithResponse, callback, canonilized_url),
             identifier, request_origin_, canonilized_url,
             base::Passed(GetMinimalResponse(canonilized_url)), db_,
             task_runner_));
     return;
   }
   if (IsInvalidated(entry) || !IsCacheEntryValid(entry)) {
     callback.Run(URLResponsePtr(), nullptr, nullptr);
     return;
   }
-  callback.Run(entry->response.Pass(),
-               PathToArray(base::FilePath(entry->response_body_path)),
-               PathToArray(GetConsumerCacheDirectory(
-                   base::FilePath(entry->entry_directory))));
+  callback.Run(
+      entry->response.Pass(),
+      PathToArray(base::FilePath::FromUTF8Unsafe(entry->response_body_path)),
+      PathToArray(GetConsumerCacheDirectory(
+          base::FilePath::FromUTF8Unsafe(entry->entry_directory))));
   UpdateLastInvalidation(db_, key.Pass(), base::Time::Now());
 }
 
 void URLResponseDiskCacheImpl::Validate(const String& url) {
   CacheKeyPtr key;
   CacheEntryPtr entry =
       db_->GetNewest(request_origin_, CanonicalizeURL(url), &key);
   if (entry)
     UpdateLastInvalidation(db_, key.Pass(), base::Time::Max());
 }
@@ skipping 27 matching lines @@
     return;
   }
 
   std::string url = CanonicalizeURL(response->url);
 
   // Check if the response is cached and valid. If that's the case, returns
   // the cached value.
   CacheKeyPtr key;
   CacheEntryPtr entry = db_->GetNewest(request_origin_, url, &key);
   if (IsCacheEntryFresh(response, entry)) {
-    callback.Run(
-        base::FilePath(entry->response_body_path),
-        GetConsumerCacheDirectory(base::FilePath(entry->entry_directory)));
+    callback.Run(base::FilePath::FromUTF8Unsafe(entry->response_body_path),
+                 GetConsumerCacheDirectory(
+                     base::FilePath::FromUTF8Unsafe(entry->entry_directory)));
     UpdateLastInvalidation(db_, key.Pass(), base::Time::Max());
     return;
   }
 
   if (!response->body.is_valid()) {
     callback.Run(base::FilePath(), base::FilePath());
     return;
   }
 
   std::string identifier = GetNewIdentifier();
@@ skipping 58 matching lines @@
       return;
     }
   }
   // We can ignore write error, as it will just force to clear the cache on the
   // next request.
   WriteFile(GetExtractionSentinel(entry_directory), nullptr, 0);
   callback.Run(extraction_directory, consumer_cache_directory);
 }
 
 }  // namespace mojo