Update //base to chromium 9659b08ea5a34f889dc4166217f438095ddc10d2

third_party/zlib/google/zip_reader.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 "third_party/zlib/google/zip_reader.h"
 
 #include "base/bind.h"
 #include "base/files/file.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/thread_task_runner_handle.h"
 #include "third_party/zlib/google/zip_internal.h"
 
 #if defined(USE_SYSTEM_MINIZIP)
 #include <minizip/unzip.h>
 #else
 #include "third_party/zlib/contrib/minizip/unzip.h"
 #if defined(OS_WIN)
 #include "third_party/zlib/contrib/minizip/iowin32.h"
 #endif  // defined(OS_WIN)
 #endif  // defined(USE_SYSTEM_MINIZIP)
@@ skipping 100 matching lines @@
 // TODO(satorux): The implementation assumes that file names in zip files
 // are encoded in UTF-8. This is true for zip files created by Zip()
 // function in zip.h, but not true for user-supplied random zip files.
 ZipReader::EntryInfo::EntryInfo(const std::string& file_name_in_zip,
                                 const unz_file_info& raw_file_info)
     : file_path_(base::FilePath::FromUTF8Unsafe(file_name_in_zip)),
       is_directory_(false) {
   original_size_ = raw_file_info.uncompressed_size;
 
   // Directory entries in zip files end with "/".
-  is_directory_ = EndsWith(file_name_in_zip, "/", false);
+  is_directory_ =
+      base::EndsWith(file_name_in_zip, "/", base::CompareCase::SENSITIVE);
 
   // Check the file name here for directory traversal issues.
   is_unsafe_ = file_path_.ReferencesParent();
 
   // We also consider that the file name is unsafe, if it's invalid UTF-8.
   base::string16 file_name_utf16;
   if (!base::UTF8ToUTF16(file_name_in_zip.data(), file_name_in_zip.size(),
                          &file_name_utf16)) {
     is_unsafe_ = true;
   }
 
   // We also consider that the file name is unsafe, if it's absolute.
   // On Windows, IsAbsolute() returns false for paths starting with "/".
-  if (file_path_.IsAbsolute() || StartsWithASCII(file_name_in_zip, "/", false))
+  if (file_path_.IsAbsolute() ||
+      base::StartsWith(file_name_in_zip, "/", base::CompareCase::SENSITIVE))
     is_unsafe_ = true;
 
   // Construct the last modified time. The timezone info is not present in
   // zip files, so we construct the time as local time.
   base::Time::Exploded exploded_time = {};  // Zero-clear.
   exploded_time.year = raw_file_info.tmu_date.tm_year;
   // The month in zip file is 0-based, whereas ours is 1-based.
   exploded_time.month = raw_file_info.tmu_date.tm_mon + 1;
   exploded_time.day_of_month = raw_file_info.tmu_date.tm_mday;
   exploded_time.hour = raw_file_info.tmu_date.tm_hour;
@@ skipping 190 matching lines @@
     const base::FilePath& output_file_path,
     const SuccessCallback& success_callback,
     const FailureCallback& failure_callback,
     const ProgressCallback& progress_callback) {
   DCHECK(zip_file_);
   DCHECK(current_entry_info_.get());
 
   // If this is a directory, just create it and return.
   if (current_entry_info()->is_directory()) {
     if (base::CreateDirectory(output_file_path)) {
-      base::MessageLoopProxy::current()->PostTask(FROM_HERE, success_callback);
+      base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                    success_callback);
     } else {
       DVLOG(1) << "Unzip failed: unable to create directory.";
-      base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
+      base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
+                                                    failure_callback);
     }
     return;
   }
 
   if (unzOpenCurrentFile(zip_file_) != UNZ_OK) {
     DVLOG(1) << "Unzip failed: unable to open current zip entry.";
-    base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, failure_callback);
     return;
   }
 
   base::FilePath output_dir_path = output_file_path.DirName();
   if (!base::CreateDirectory(output_dir_path)) {
     DVLOG(1) << "Unzip failed: unable to create containing directory.";
-    base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, failure_callback);
     return;
   }
 
   const int flags = base::File::FLAG_CREATE_ALWAYS | base::File::FLAG_WRITE;
   base::File output_file(output_file_path, flags);
 
   if (!output_file.IsValid()) {
     DVLOG(1) << "Unzip failed: unable to create platform file at "
              << output_file_path.value();
-    base::MessageLoopProxy::current()->PostTask(FROM_HERE, failure_callback);
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, failure_callback);
     return;
   }
 
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&ZipReader::ExtractChunk,
                  weak_ptr_factory_.GetWeakPtr(),
                  Passed(output_file.Pass()),
                  success_callback,
                  failure_callback,
@@ skipping 134 matching lines @@
 }
 
 bool FileWriterDelegate::WriteBytes(const char* data, int num_bytes) {
   int bytes_written = file_->WriteAtCurrentPos(data, num_bytes);
   if (bytes_written > 0)
     file_length_ += bytes_written;
   return bytes_written == num_bytes;
 }
 
 }  // namespace zip