Adds asynchronous unzip functions to ZipReader

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 <set>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/logging.h"
 #include "base/md5.h"
+#include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_file.h"
+#include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
+#include "testing/gmock/include/gmock/gmock.h"

[satorux1, 2013/12/05 04:39:37]

gmock should usually be avoided in Chrome code.

[Drew Haven, 2013/12/09 23:33:12]

I personally like gmock for mocking out interfaces and void functions.  I
understand many of the arguments against it and didn't see a solid resolution on
its use, just that it should be used carefully.

However, I have hand-written a fake for this test.

 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 #include "third_party/zlib/google/zip_internal.h"
 
 namespace {
 
+using testing::_;
+using testing::AtLeast;
+
+const static std::string kQuuxExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
+
 // Wrap PlatformFiles in a class so that we don't leak them in tests.
 class PlatformFileWrapper {
  public:
   typedef enum {
     READ_ONLY,
     READ_WRITE
   } AccessMode;
 
   PlatformFileWrapper(const base::FilePath& file, AccessMode mode)
       : file_(base::kInvalidPlatformFileValue) {
@@ skipping 20 matching lines @@
   ~PlatformFileWrapper() {
     base::ClosePlatformFile(file_);
   }
 
   base::PlatformFile platform_file() { return file_; }
 
  private:
   base::PlatformFile file_;
 };
 
+class MockListener : public zip::ZipReader::Listener {
+ public:
+  MockListener() {}
+  MOCK_METHOD1(OnUnzipProgress, void(int progress));
+  MOCK_METHOD0(OnUnzipSuccess,  void());
+  MOCK_METHOD0(OnUnzipFailed,   void());
+
+  void ExpectSuccess() {
+    EXPECT_CALL(*this, OnUnzipSuccess());
+    EXPECT_CALL(*this, OnUnzipFailed()).Times(0);
+    EXPECT_CALL(*this, OnUnzipProgress(_)).Times(AtLeast(0));
+  }
+
+  void ExpectSuccessWithProgress() {
+    EXPECT_CALL(*this, OnUnzipSuccess());
+    EXPECT_CALL(*this, OnUnzipFailed()).Times(0);
+    EXPECT_CALL(*this, OnUnzipProgress(_)).Times(AtLeast(1));

[satorux1, 2013/12/05 04:39:37]

Instead of checking with GMock, can you do something like:

class RecordingListener ... {
  void OnUnzipProgress(int x) {
     num_bytes_ += x;
  }
  int num_bytes() const { return num_bytes_; }
}

Then you can check that OnUnzipProgress() is called as expected and the
num_bytes is correct.

[Drew Haven, 2013/12/09 23:33:12]

I was originally reporting the percentage because in the case of the API the app
doesn't have a good way to know how big the file is.  However, in this case we
can so I have changed it to report only the number of bytes and have done
something similar to your system.

Is there a reason we would insist on getter-functions for local test-only
classes?

+  }
+ protected:
+  virtual ~MockListener() { }
+};
+
 }   // namespace
 
 namespace zip {
 
 // Make the test a PlatformTest to setup autorelease pools properly on Mac.
 class ZipReaderTest : public PlatformTest {
  protected:
   virtual void SetUp() {
     PlatformTest::SetUp();
 
@@ skipping 13 matching lines @@
     test_zip_contents_.insert(base::FilePath(FILE_PATH_LITERAL("foo/bar/")));
     test_zip_contents_.insert(
         base::FilePath(FILE_PATH_LITERAL("foo/bar/baz.txt")));
     test_zip_contents_.insert(
         base::FilePath(FILE_PATH_LITERAL("foo/bar/quux.txt")));
     test_zip_contents_.insert(
         base::FilePath(FILE_PATH_LITERAL("foo/bar.txt")));
     test_zip_contents_.insert(base::FilePath(FILE_PATH_LITERAL("foo.txt")));
     test_zip_contents_.insert(
         base::FilePath(FILE_PATH_LITERAL("foo/bar/.hidden")));
+
+    mock_listener_ = new MockListener;
+    message_loop_proxy_ = base::MessageLoop::current()->message_loop_proxy();
   }
 
   virtual void TearDown() {
     PlatformTest::TearDown();
   }
 
   bool GetTestDataDirectory(base::FilePath* path) {
     bool success = PathService::Get(base::DIR_SOURCE_ROOT, path);
     EXPECT_TRUE(success);
     if (!success)
       return false;
     *path = path->AppendASCII("third_party");
     *path = path->AppendASCII("zlib");
     *path = path->AppendASCII("google");
     *path = path->AppendASCII("test");
     *path = path->AppendASCII("data");
     return true;
   }
 
+  void CompareFileAndMD5(const base::FilePath& path,
+                         const std::string expected_md5) {
+    // Read the output file and compute the MD5.
+    std::string output;
+    ASSERT_TRUE(base::ReadFileToString(path, &output));
+    const std::string md5 = base::MD5String(output);
+    EXPECT_EQ(expected_md5, md5);
+  }
+
   // The path to temporary directory used to contain the test operations.
   base::FilePath test_dir_;
   // The path to the test data directory where test.zip etc. are located.
   base::FilePath test_data_dir_;
   // The path to test.zip in the test data directory.
   base::FilePath test_zip_file_;
   // The path to evil.zip in the test data directory.
   base::FilePath evil_zip_file_;
   // The path to evil_via_invalid_utf8.zip in the test data directory.
   base::FilePath evil_via_invalid_utf8_zip_file_;
   // The path to evil_via_absolute_file_name.zip in the test data directory.
   base::FilePath evil_via_absolute_file_name_zip_file_;
   std::set<base::FilePath> test_zip_contents_;
 
   base::ScopedTempDir temp_dir_;
+
+  scoped_refptr<MockListener> mock_listener_;
+  base::MessageLoop message_loop_;
+  scoped_refptr<base::MessageLoopProxy> message_loop_proxy_;
 };
 
 TEST_F(ZipReaderTest, Open_ValidZipFile) {
   ZipReader reader;
   ASSERT_TRUE(reader.Open(test_zip_file_));
 }
 
 TEST_F(ZipReaderTest, Open_ValidZipPlatformFile) {
   ZipReader reader;
   PlatformFileWrapper zip_fd_wrapper(test_zip_file_,
@@ skipping 72 matching lines @@
   ASSERT_TRUE(reader.Open(test_zip_file_));
   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
   ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath(
       test_dir_.AppendASCII("quux.txt")));
   // Read the output file ans compute the MD5.
   std::string output;
   ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
                                      &output));
   const std::string md5 = base::MD5String(output);
-  const std::string kExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
-  EXPECT_EQ(kExpectedMD5, md5);
+  EXPECT_EQ(kQuuxExpectedMD5, md5);
   // quux.txt should be larger than kZipBufSize so that we can exercise
   // the loop in ExtractCurrentEntry().
   EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size());
 }
 
 TEST_F(ZipReaderTest, PlatformFileExtractCurrentEntryToFilePath_RegularFile) {
   ZipReader reader;
   PlatformFileWrapper zip_fd_wrapper(test_zip_file_,
                                      PlatformFileWrapper::READ_ONLY);
   ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
   ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath(
       test_dir_.AppendASCII("quux.txt")));
   // Read the output file and compute the MD5.
   std::string output;
   ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
                                      &output));
   const std::string md5 = base::MD5String(output);
-  const std::string kExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
-  EXPECT_EQ(kExpectedMD5, md5);
+  EXPECT_EQ(kQuuxExpectedMD5, md5);
   // quux.txt should be larger than kZipBufSize so that we can exercise
   // the loop in ExtractCurrentEntry().
   EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size());
 }
 
 #if defined(OS_POSIX)
 TEST_F(ZipReaderTest, PlatformFileExtractCurrentEntryToFd_RegularFile) {
   ZipReader reader;
   PlatformFileWrapper zip_fd_wrapper(test_zip_file_,
                                      PlatformFileWrapper::READ_ONLY);
   ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
   base::FilePath out_path = test_dir_.AppendASCII("quux.txt");
   PlatformFileWrapper out_fd_w(out_path, PlatformFileWrapper::READ_WRITE);
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
   ASSERT_TRUE(reader.ExtractCurrentEntryToFd(out_fd_w.platform_file()));
   // Read the output file and compute the MD5.
   std::string output;
   ASSERT_TRUE(base::ReadFileToString(test_dir_.AppendASCII("quux.txt"),
                                      &output));
   const std::string md5 = base::MD5String(output);
-  const std::string kExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
-  EXPECT_EQ(kExpectedMD5, md5);
+  EXPECT_EQ(kQuuxExpectedMD5, md5);
   // quux.txt should be larger than kZipBufSize so that we can exercise
   // the loop in ExtractCurrentEntry().
   EXPECT_LT(static_cast<size_t>(internal::kZipBufSize), output.size());
 }
 #endif
 
 TEST_F(ZipReaderTest, ExtractCurrentEntryToFilePath_Directory) {
   ZipReader reader;
   ASSERT_TRUE(reader.Open(test_zip_file_));
   base::FilePath target_path(FILE_PATH_LITERAL("foo/"));
@@ skipping 10 matching lines @@
   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
   ASSERT_TRUE(reader.ExtractCurrentEntryIntoDirectory(test_dir_));
   // Sub directories should be created.
   ASSERT_TRUE(base::DirectoryExists(test_dir_.AppendASCII("foo/bar")));
   // And the file should be created.
   std::string output;
   ASSERT_TRUE(base::ReadFileToString(
       test_dir_.AppendASCII("foo/bar/quux.txt"), &output));
   const std::string md5 = base::MD5String(output);
-  const std::string kExpectedMD5 = "d1ae4ac8a17a0e09317113ab284b57a6";
-  EXPECT_EQ(kExpectedMD5, md5);
+  EXPECT_EQ(kQuuxExpectedMD5, md5);
 }
 
 TEST_F(ZipReaderTest, current_entry_info_RegularFile) {
   ZipReader reader;
   ASSERT_TRUE(reader.Open(test_zip_file_));
   base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
   ZipReader::EntryInfo* current_entry_info = reader.current_entry_info();
 
   EXPECT_EQ(target_path, current_entry_info->file_path());
@@ skipping 110 matching lines @@
   ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
   ASSERT_TRUE(reader.ExtractCurrentEntryToFilePath(
       test_dir_.AppendASCII("test.txt")));
 
   std::string actual;
   ASSERT_TRUE(base::ReadFileToString(
       test_dir_.AppendASCII("test.txt"), &actual));
   EXPECT_EQ(std::string("This is a test.\n"), actual);
 }
 
+// Verifies that the asynchronous extraction to a file works.
+TEST_F(ZipReaderTest, ExtractToFileAsync_RegularFile) {
+  mock_listener_->ExpectSuccessWithProgress();
+
+  ZipReader reader;
+  base::FilePath target_file = test_dir_.AppendASCII("quux.txt");
+  base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
+  reader.ExtractCurrentEntryToFilePathAsync(target_file,
+                                            message_loop_proxy_,
+                                            mock_listener_);
+
+  base::RunLoop().RunUntilIdle();
+
+  CompareFileAndMD5(target_file, kQuuxExpectedMD5);
+}
+
+// Verifies that the asynchronous extraction to a file works.
+TEST_F(ZipReaderTest, ExtractToFileAsync_Directory) {
+  mock_listener_->ExpectSuccess();
+
+  ZipReader reader;
+  base::FilePath target_path(FILE_PATH_LITERAL("foo/"));
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
+  reader.ExtractCurrentEntryToFilePathAsync(target_path,
+                                            message_loop_proxy_,
+                                            mock_listener_);
+
+  base::RunLoop().RunUntilIdle();
+
+  ASSERT_TRUE(base::DirectoryExists(target_path));
+}
+
+// Verifies that the asynchronous extraction to a directory works.
+TEST_F(ZipReaderTest, ExtractIntoDirectoryAsync_RegularFile) {
+  mock_listener_->ExpectSuccessWithProgress();
+
+  ZipReader reader;
+  base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  base::FilePath target_file = test_dir_.AppendASCII("foo/bar/quux.txt");
+  ASSERT_TRUE(reader.Open(test_zip_file_));
+  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
+  reader.ExtractCurrentEntryIntoDirectoryAsync(test_dir_,
+                                               message_loop_proxy_,
+                                               mock_listener_);
+
+  base::RunLoop().RunUntilIdle();
+
+  ASSERT_TRUE(base::DirectoryExists(test_dir_.AppendASCII("foo/bar")));
+  CompareFileAndMD5(target_file, kQuuxExpectedMD5);
+}
+
+#if defined(OS_POSIX)
+// Verifies that the asynchronous extraction to a file descriptor works.
+TEST_F(ZipReaderTest, ExtractToFdAsync) {
+  mock_listener_->ExpectSuccessWithProgress();
+
+  ZipReader reader;
+  PlatformFileWrapper zip_fd_wrapper(test_zip_file_,
+                                     PlatformFileWrapper::READ_ONLY);
+  ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
+  base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  base::FilePath out_path = test_dir_.AppendASCII("quux.txt");
+  PlatformFileWrapper out_fd_w(out_path, PlatformFileWrapper::READ_WRITE);
+  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
+  reader.ExtractCurrentEntryToFdAsync(out_fd_w.platform_file(),
+                                      message_loop_proxy_,
+                                      mock_listener_);
+
+  base::RunLoop().RunUntilIdle();
+
+  CompareFileAndMD5(out_path, kQuuxExpectedMD5);
+}
+#endif
+
+// Verifies that the asynchronous extraction to a platform file works.
+TEST_F(ZipReaderTest, ExtractToPlatformFileAsync) {
+  mock_listener_->ExpectSuccessWithProgress();
+
+  ZipReader reader;
+  PlatformFileWrapper zip_fd_wrapper(test_zip_file_,
+                                     PlatformFileWrapper::READ_ONLY);
+  ASSERT_TRUE(reader.OpenFromPlatformFile(zip_fd_wrapper.platform_file()));
+  base::FilePath target_path(FILE_PATH_LITERAL("foo/bar/quux.txt"));
+  base::FilePath out_path = test_dir_.AppendASCII("quux.txt");
+  PlatformFileWrapper out_fd_w(out_path, PlatformFileWrapper::READ_WRITE);
+  ASSERT_TRUE(reader.LocateAndOpenEntry(target_path));
+  reader.ExtractCurrentEntryToPlatformFileAsync(out_fd_w.platform_file(),
+                                                message_loop_proxy_,
+                                                mock_listener_);
+
+  base::RunLoop().RunUntilIdle();
+
+  CompareFileAndMD5(out_path, kQuuxExpectedMD5);
+}
+
 }  // namespace zip