Improve Zip File Scanning on Mac

third_party/zlib/google/zip_reader_unittest.cc

 // Copyright (c) 2011 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 <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
@@ skipping 552 matching lines @@
 
   for (size_t i = 0; i < 8; i++) {
     SCOPED_TRACE(base::StringPrintf("Processing %d.txt", static_cast<int>(i)));
 
     base::FilePath file_name = base::FilePath::FromUTF8Unsafe(
         base::StringPrintf("%d.txt", static_cast<int>(i)));
     ASSERT_TRUE(reader.LocateAndOpenEntry(file_name));
 
     if (i > 1) {
       // Off by one byte read limit: must fail.
-      EXPECT_FALSE(reader.ExtractCurrentEntryToString(i - 1, &contents));
+      EXPECT_FALSE(reader.ExtractCurrentEntryToString(i - 1, true, &contents));
     }
 
     if (i > 0) {
       // Exact byte read limit: must pass.
-      EXPECT_TRUE(reader.ExtractCurrentEntryToString(i, &contents));
+      EXPECT_TRUE(reader.ExtractCurrentEntryToString(i, true, &contents));
       EXPECT_EQ(i, contents.size());
       EXPECT_EQ(0, memcmp(contents.c_str(), "0123456", i));
     }
 
     // More than necessary byte read limit: must pass.
-    EXPECT_TRUE(reader.ExtractCurrentEntryToString(16, &contents));
+    EXPECT_TRUE(reader.ExtractCurrentEntryToString(16, true, &contents));
     EXPECT_EQ(i, contents.size());
     EXPECT_EQ(0, memcmp(contents.c_str(), "0123456", i));
   }
   reader.Close();
 }
 
+TEST_F(ZipReaderTest, ExtractPartOfCurrentEntry) {
+  // test_mismatch_size.zip contains files with names from 0.txt to 7.txt with
+  // sizes from 0 to 7 bytes respectively, being the contents of each file a
+  // substring of "0123456" starting at '0'.
+  base::FilePath test_zip_file =
+      test_data_dir_.AppendASCII("test_mismatch_size.zip");
+
+  ZipReader reader;
+  std::string contents;
+  ASSERT_TRUE(reader.Open(test_zip_file));
+
+  base::FilePath file_name0 = base::FilePath::FromUTF8Unsafe("0.txt");
+  ASSERT_TRUE(reader.LocateAndOpenEntry(file_name0));
+  EXPECT_TRUE(reader.ExtractCurrentEntryToString(0, false, &contents));
+  EXPECT_EQ(0, memcmp(contents.c_str(), "", 0));
+  EXPECT_FALSE(reader.ExtractCurrentEntryToString(1, false, &contents));
+  EXPECT_EQ(0, memcmp(contents.c_str(), "", 0));
+
+  base::FilePath file_name1 = base::FilePath::FromUTF8Unsafe("1.txt");
+  ASSERT_TRUE(reader.LocateAndOpenEntry(file_name1));
+  EXPECT_TRUE(reader.ExtractCurrentEntryToString(0, false, &contents));
+  EXPECT_EQ(0, memcmp(contents.c_str(), "", 0));
+  EXPECT_TRUE(reader.ExtractCurrentEntryToString(1, false, &contents));
+  EXPECT_EQ(0, memcmp(contents.c_str(), "0", 1));
+  EXPECT_FALSE(reader.ExtractCurrentEntryToString(2, false, &contents));
+  EXPECT_EQ(0, memcmp(contents.c_str(), "", 0));
+
+  base::FilePath file_name4 = base::FilePath::FromUTF8Unsafe("4.txt");
+  ASSERT_TRUE(reader.LocateAndOpenEntry(file_name4));
+  EXPECT_TRUE(reader.ExtractCurrentEntryToString(0, false, &contents));
+  EXPECT_EQ(0, memcmp(contents.c_str(), "", 0));
+  EXPECT_TRUE(reader.ExtractCurrentEntryToString(2, false, &contents));
+  EXPECT_EQ(0, memcmp(contents.c_str(), "01", 2));
+  EXPECT_TRUE(reader.ExtractCurrentEntryToString(4, false, &contents));
+  EXPECT_EQ(0, memcmp(contents.c_str(), "0123", 4));
+  EXPECT_FALSE(reader.ExtractCurrentEntryToString(5, false, &contents));
+  EXPECT_EQ(0, memcmp(contents.c_str(), "", 0));
+
+  reader.Close();
+}
+
 // This test exposes http://crbug.com/430959, at least on OS X
 TEST_F(ZipReaderTest, DISABLED_LeakDetectionTest) {
   for (int i = 0; i < 100000; ++i) {
     FileWrapper zip_fd_wrapper(test_zip_file_, FileWrapper::READ_ONLY);
     ZipReader reader;
     ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
   }
 }
 
 // Test that when WriterDelegate::PrepareMock returns false, no other methods on
 // the delegate are called and the extraction fails.
 TEST_F(ZipReaderTest, ExtractCurrentEntryPrepareFailure) {
   testing::StrictMock<MockWriterDelegate> mock_writer;
 
   EXPECT_CALL(mock_writer, PrepareOutput())
       .WillOnce(Return(false));
 
   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
   ZipReader reader;
 
   ASSERT_TRUE(reader.Open(test_zip_file_));
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
-  ASSERT_FALSE(reader.ExtractCurrentEntry(&mock_writer));
+  ASSERT_FALSE(reader.ExtractCurrentEntry(&mock_writer, -1));
 }
 
 // Test that when WriterDelegate::WriteBytes returns false, no other methods on
 // the delegate are called and the extraction fails.
 TEST_F(ZipReaderTest, ExtractCurrentEntryWriteBytesFailure) {
   testing::StrictMock<MockWriterDelegate> mock_writer;
 
   EXPECT_CALL(mock_writer, PrepareOutput())
       .WillOnce(Return(true));
   EXPECT_CALL(mock_writer, WriteBytes(_, _))
       .WillOnce(Return(false));
 
   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
   ZipReader reader;
 
   ASSERT_TRUE(reader.Open(test_zip_file_));
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
-  ASSERT_FALSE(reader.ExtractCurrentEntry(&mock_writer));
+  ASSERT_FALSE(reader.ExtractCurrentEntry(&mock_writer, -1));
 }
 
 // Test that extraction succeeds when the writer delegate reports all is well.
 TEST_F(ZipReaderTest, ExtractCurrentEntrySuccess) {
   testing::StrictMock<MockWriterDelegate> mock_writer;
 
   EXPECT_CALL(mock_writer, PrepareOutput())
       .WillOnce(Return(true));
   EXPECT_CALL(mock_writer, WriteBytes(_, _))
       .WillRepeatedly(Return(true));
 
   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
   ZipReader reader;
 
   ASSERT_TRUE(reader.Open(test_zip_file_));
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
-  ASSERT_TRUE(reader.ExtractCurrentEntry(&mock_writer));
+  ASSERT_TRUE(reader.ExtractCurrentEntry(&mock_writer, -1));
+}
+
+// Test that when WriterDelegate::PrepareMock returns false, no other methods on
+// the delegate are called and the partial extraction fails.
+TEST_F(ZipReaderTest, ExtractFromBeginningOfCurrentEntryPrepareFailure) {
+  testing::StrictMock<MockWriterDelegate> mock_writer;
+
+  EXPECT_CALL(mock_writer, PrepareOutput()).WillOnce(Return(false));
+
+  base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  ZipReader reader;
+
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
+  ASSERT_FALSE(reader.ExtractCurrentEntry(&mock_writer, 1));
+}
+
+// Test that when WriterDelegate::WriteBytes returns false, no other methods on
+// the delegate are called and the partial extraction fails.
+TEST_F(ZipReaderTest, ExtractFromBeginningOfCurrentEntryWriteBytesFailure) {
+  testing::StrictMock<MockWriterDelegate> mock_writer;
+
+  EXPECT_CALL(mock_writer, PrepareOutput()).WillOnce(Return(true));
+  EXPECT_CALL(mock_writer, WriteBytes(_, _)).WillOnce(Return(false));
+
+  base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  ZipReader reader;
+
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
+  ASSERT_FALSE(reader.ExtractCurrentEntry(&mock_writer, 1));
+}
+
+// Test that partial extraction succeeds when the writer delegate reports all is
+// well.
+TEST_F(ZipReaderTest, ExtractFromBeginningOfCurrentEntrySuccess) {
+  testing::StrictMock<MockWriterDelegate> mock_writer;
+
+  EXPECT_CALL(mock_writer, PrepareOutput()).WillOnce(Return(true));
+  EXPECT_CALL(mock_writer, WriteBytes(_, _)).WillRepeatedly(Return(true));
+
+  base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  ZipReader reader;
+
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
+  ASSERT_TRUE(reader.ExtractCurrentEntry(&mock_writer, 1));
 }
 
 class FileWriterDelegateTest : public ::testing::Test {
  protected:
   void SetUp() override {
     ASSERT_TRUE(base::CreateTemporaryFile(&temp_file_path_));
     file_.Initialize(temp_file_path_, (base::File::FLAG_CREATE_ALWAYS |
                                        base::File::FLAG_READ |
                                        base::File::FLAG_WRITE |
                                        base::File::FLAG_TEMPORARY |
@@ skipping 25 matching lines @@
     ASSERT_TRUE(writer.PrepareOutput());
     ASSERT_TRUE(writer.WriteBytes(kSomeData, kSomeDataLen));
   }
   ASSERT_EQ(kSomeDataLen, file_.GetLength());
   char buf[kSomeDataLen] = {};
   ASSERT_EQ(kSomeDataLen, file_.Read(0LL, buf, kSomeDataLen));
   ASSERT_EQ(std::string(kSomeData), std::string(buf, kSomeDataLen));
 }
 
 }  // namespace zip