Android handler: Fix name collision.

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 <type_traits>
+
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "mojo/common/data_pipe_utils.h"
 #include "mojo/public/cpp/application/application_connection.h"
 #include "mojo/public/cpp/bindings/lib/fixed_buffer.h"
 #include "services/url_response_disk_cache/url_response_disk_cache_entry.mojom.h"
 #include "third_party/zlib/google/zip_reader.h"
 #include "url/gurl.h"
 
 namespace mojo {
 
 namespace {
 
+// The current version of the cache. This should only be incremented. When this
+// is incremented, all current cache entries will be invalidated.
+const uint32_t kCurrentVersion = 1;
+
 const char kEtagHeader[] = "etag";
 
 template <typename T>
 void Serialize(T input, std::string* output) {
   typedef typename mojo::internal::WrapperTraits<T>::DataType DataType;
   size_t size = GetSerializedSize_(input);
   mojo::internal::FixedBuffer buf(size);
   DataType data_type;
   Serialize_(input.Pass(), &buf, &data_type);
   std::vector<Handle> handles;
   data_type->EncodePointersAndHandles(&handles);
   void* serialized_data = buf.Leak();
   *output = std::string(static_cast<char*>(serialized_data), size);
   free(serialized_data);
 }
 
 template <typename T>
-void Deserialize(std::string input, T* output) {
+bool Deserialize(std::string input, T* output) {
   typedef typename mojo::internal::WrapperTraits<T>::DataType DataType;
+  mojo::internal::BoundsChecker bounds_checker(&input[0], input.size(), 0);
+  if (!std::remove_pointer<DataType>::type::Validate(&input[0],
+                                                     &bounds_checker)) {
+    return false;
+  }
   DataType data_type = reinterpret_cast<DataType>(&input[0]);
   std::vector<Handle> handles;
   data_type->DecodePointersAndHandles(&handles);
   Deserialize_(data_type, output);
+  return true;
 }
 
 Array<uint8_t> PathToArray(const base::FilePath& path) {
   if (path.empty())
     return Array<uint8_t>();
   const std::string& string = path.value();
   Array<uint8_t> result(string.size());
   memcpy(&result.front(), string.data(), string.size());
   return result.Pass();
 }
@@ skipping 104 matching lines @@
                        URLResponse* response,
                        CacheEntryPtr* output) {
   // Find the entry file, and deserialize it.
   base::FilePath entry_path = dir.Append("entry");
   if (!base::PathExists(entry_path))
     return false;
   std::string serialized_entry;
   if (!ReadFileToString(entry_path, &serialized_entry))
     return false;
   CacheEntryPtr entry;
-  Deserialize(serialized_entry, &entry);
+  if (!Deserialize(serialized_entry, &entry))
+    return false;
+
+  // Obsolete entries are invalidated.
+  if (entry->version != kCurrentVersion)
+    return false;
 
   // If |entry| or |response| has not headers, it is not possible to check if
   // the entry is valid, so returns |false|.
   if (entry->headers.is_null() || response->headers.is_null())
     return false;
 
   // Only handle etag for the moment.
   std::string etag_header_name = kEtagHeader;
   std::vector<std::string> entry_etags =
       GetHeaderValues(etag_header_name, entry->headers);
@@ skipping 38 matching lines @@
                          base::Bind(&RunMojoCallback, callback));
 }
 
 void URLResponseDiskCacheImpl::GetExtractedContent(
     URLResponsePtr response,
     const GetExtractedContentCallback& callback) {
   base::FilePath dir = GetDirName(base_directory_, response->url);
   base::FilePath extracted_dir = dir.Append("extracted");
   if (IsCacheEntryValid(dir, response.get(), nullptr) &&
       PathExists(GetExtractedSentinel(dir))) {
-    callback.Run(PathToArray(extracted_dir), PathToArray(dir));
+    callback.Run(PathToArray(extracted_dir),
+                 PathToArray(GetConsumerCacheDirectory(dir)));
     return;
   }
 
   GetFileInternal(
       response.Pass(),
       base::Bind(&URLResponseDiskCacheImpl::GetExtractedContentInternal,
                  base::Unretained(this), base::Bind(&RunMojoCallback, callback),
-                 extracted_dir));
+                 dir, extracted_dir));
 }
 
 void URLResponseDiskCacheImpl::GetFileInternal(
     URLResponsePtr response,
     const FilePathPairCallback& callback) {
   base::FilePath dir = GetDirName(base_directory_, response->url);
 
   // Check if the response is cached and valid. If that's the case, returns the
   // cached value.
   CacheEntryPtr entry;
@@ skipping 23 matching lines @@
                                         nullptr)) {
     callback.Run(base::FilePath(), base::FilePath());
     return;
   }
 
   // Fill the entry values for the request.
   base::FilePath entry_path = dir.Append("entry");
   base::FilePath content;
   CHECK(CreateTemporaryFileInDir(dir, &content));
   entry = CacheEntry::New();
+  entry->version = kCurrentVersion;
   entry->url = response->url;
   entry->content_path = content.value();
   entry->headers = response->headers.Pass();
   // Asynchronously copy the response body to the cached file. The entry is send
   // to the callback so that it is saved on disk only if the copy of the body
   // succeded.
   common::CopyToFile(response->body.Pass(), content, worker_pool_.get(),
                      base::Bind(&RunCallbackWithSuccess, callback, content,
                                 GetConsumerCacheDirectory(dir), entry_path,
                                 base::Passed(entry.Pass())));
 }
 
 void URLResponseDiskCacheImpl::GetExtractedContentInternal(
     const FilePathPairCallback& callback,
+    const base::FilePath& base_dir,
     const base::FilePath& extracted_dir,
     const base::FilePath& content,
-    const base::FilePath& dir) {
+    const base::FilePath& cache_dir) {
   // If it is not possible to get the cached file, returns an error.
   if (content.empty()) {
     callback.Run(base::FilePath(), base::FilePath());
     return;
   }
 
   // Unzip the content to the extracted directory. In case of any error, returns
   // an error.
   zip::ZipReader reader;
   if (!reader.Open(content)) {
     callback.Run(base::FilePath(), base::FilePath());
     return;
   }
   while (reader.HasMore()) {
     bool success = reader.OpenCurrentEntryInZip();
     success = success && reader.ExtractCurrentEntryIntoDirectory(extracted_dir);
     success = success && reader.AdvanceToNextEntry();
     if (!success) {
       callback.Run(base::FilePath(), base::FilePath());
       return;
     }
   }
   // We can ignore write error, as it will just force to clear the cache on the
   // next request.
-  WriteFile(GetExtractedSentinel(dir), nullptr, 0);
-  callback.Run(extracted_dir, GetConsumerCacheDirectory(dir));
+  WriteFile(GetExtractedSentinel(base_dir), nullptr, 0);
+  callback.Run(extracted_dir, cache_dir);
 }
 
 }  // namespace mojo