Improve Zip File Scanning on Mac

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 <utility>
 
 #include "base/bind.h"
 #include "base/files/file.h"
@@ skipping 307 matching lines @@
         break;
       }
     }
   }
 
   unzCloseCurrentFile(zip_file_);
 
   return success;
 }
 
+bool ZipReader::ExtractPartOfCurrentEntry(WriterDelegate* delegate,

[satorux1, 2017/07/18 07:46:37]

This function looks similar to ExtractCurrentEntry() above. Can you unify them?
I wonder if you can do something like:

  bool ZipReader::ExtractCurrentEntry(WriterDelegate* delegate) const {
    return ExtractPartOfCurrentEntry(delegate, -1);  // -1 means everything
  }

[mortonm, 2017/07/18 19:58:49]

Done.

+                                          size_t num_bytes_to_extract) const {
+  DCHECK(zip_file_);
+
+  const int open_result = unzOpenCurrentFile(zip_file_);
+  if (open_result != UNZ_OK)
+    return false;
+
+  if (!delegate->PrepareOutput())
+    return false;
+
+  bool success = true;  // This becomes false when something bad happens.
+  std::unique_ptr<char[]> buf(new char[num_bytes_to_extract]);
+  base::CheckedNumeric<size_t> total_num_bytes_read = 0;
+  while (true) {
+    // This should never result in a negative value, as |num_bytes_to_extract|
+    // will always be greater than |total_num_bytes_read|.
+    auto bytes_to_read = base::CheckedNumeric<size_t>(num_bytes_to_extract) -
+                         total_num_bytes_read;
+    if (!bytes_to_read.IsValid()) {
+      DLOG(ERROR) << "Size of bytes to read underflows";
+      return false;
+    }
+    const int num_bytes_read = unzReadCurrentFile(
+        zip_file_, buf.get(),
+        base::checked_cast<unsigned int>(bytes_to_read.ValueOrDie()));
+
+    if (num_bytes_read == 0) {
+      // Reached the end of the file, which should not happen unless |num_bytes|
+      // is greater than the file length.
+      return false;
+    } else if (num_bytes_read < 0) {
+      // If num_bytes_read < 0, then it's a specific UNZ_* error code.
+      success = false;
+      break;
+    } else if (num_bytes_read > 0) {
+      // Some data is read.
+      if (!delegate->WriteBytes(buf.get(), num_bytes_read)) {
+        success = false;
+        break;
+      }
+    }
+    // Previous check ensures that num_bytes_read is not negative here.
+    total_num_bytes_read += base::checked_cast<size_t>(num_bytes_read);
+    if (!total_num_bytes_read.IsValid()) {
+      DLOG(ERROR) << "Size of total_num_bytes_read overflows";
+      return false;
+    }
+    if (total_num_bytes_read.ValueOrDie() == num_bytes_to_extract) {
+      // Read all the data.
+      break;
+    }
+  }
+
+  unzCloseCurrentFile(zip_file_);
+
+  return success;
+}
+
 bool ZipReader::ExtractCurrentEntryToFilePath(
     const base::FilePath& output_file_path) const {
   DCHECK(zip_file_);
 
   // If this is a directory, just create it and return.
   if (current_entry_info()->is_directory())
     return base::CreateDirectory(output_file_path);
 
   bool success = false;
   {
@@ skipping 101 matching lines @@
       static_cast<size_t>(std::min(static_cast<int64_t>(max_read_bytes),
                                    current_entry_info()->original_size())));
 
   StringWriterDelegate writer(max_read_bytes, &contents);
   if (!ExtractCurrentEntry(&writer))
     return false;
   output->swap(contents);
   return true;
 }
 
+bool ZipReader::ExtractPartOfCurrentEntryToString(size_t num_bytes,

[satorux1, 2017/07/18 07:46:37]

ditto. this looks similar to ExtractCurrentEntryToString(). would be good to
unify them.

[mortonm, 2017/07/18 19:58:49]

Done.

+                                                  std::string* output) const {
+  DCHECK(output);
+  DCHECK(zip_file_);
+
+  if (num_bytes == 0U) {
+    output->clear();
+    return true;
+  }
+
+  if (current_entry_info()->is_directory()) {
+    output->clear();
+    return true;
+  }
+
+  std::string contents;
+  contents.reserve(num_bytes);
+
+  StringWriterDelegate writer(num_bytes, &contents);
+  if (!ExtractPartOfCurrentEntry(&writer, num_bytes)) {
+    output->clear();
+    return false;
+  }
+  output->swap(contents);
+  return true;
+}
+
 bool ZipReader::OpenInternal() {
   DCHECK(zip_file_);
 
   unz_global_info zip_info = {};  // Zero-clear.
   if (unzGetGlobalInfo(zip_file_, &zip_info) != UNZ_OK) {
     return false;
   }
   num_entries_ = zip_info.number_entry;
   if (num_entries_ < 0)
     return false;
@@ skipping 65 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