New Zip::ZipFromMemory API.

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/file_util.h"
 #include "base/logging.h"
+#include "base/memory/ref_counted_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "net/base/file_stream.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"
@@ skipping 325 matching lines @@
         break;
       }
     }
   }
 
   unzCloseCurrentFile(zip_file_);
   return success;
 }
 #endif  // defined(OS_POSIX)
 
+bool ZipReader::ExtractCurrentEntryToRefCountedMemory(
+    int max_read_bytes,
+    base::RefCountedMemory** output) const {
+  DCHECK(output);
+  DCHECK(zip_file_);
+  DCHECK(max_read_bytes > 0);
+
+  if (current_entry_info()->is_directory()) {
+    *output = NULL;
+    return true;
+  }
+
+  const int open_result = unzOpenCurrentFile(zip_file_);
+  if (open_result != UNZ_OK)
+    return false;
+
+  // The original_size() is the best hint for the real size, so it saves
+  // doing reallocations for the common case when the uncompressed size is
+  // correct. However, we need to assume that the uncompressed size could be
+  // incorrect therefore this function needs to read as much data as possible.
+  std::vector<unsigned char> contents(std::min<int64>(
+      max_read_bytes, current_entry_info()->original_size()) + 1, 0);
+
+  int buffer_index = 0;
+  bool success = true;
+  while (true) {
+    const int bytes_to_read = contents.size() - buffer_index;
+    const int bytes_read = unzReadCurrentFile(
+        zip_file_,
+        &(contents[buffer_index]),
+        bytes_to_read);
+    DCHECK(bytes_read <= bytes_to_read);
+
+    if (bytes_read == 0) {
+      contents.resize(buffer_index, 0);
+      // Reached the end of the file.
+      break;
+    } else if (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)
+      buffer_index += bytes_read;
+
+      if (buffer_index > max_read_bytes) {
+        success = false;
+        break;
+      }
+
+      if (bytes_read == bytes_to_read) {
+        // Filled up the buffer, no more space left, need to resize.
+        contents.resize(contents.size() + internal::kZipBufSize, 0);
+      } else {
+        contents.resize(buffer_index, 0);
+        // Read less bytes than asked. That means it reached end of file.
+        break;
+      }
+    }
+  }
+
+  unzCloseCurrentFile(zip_file_);
+  if (success)
+    *output = base::RefCountedBytes::TakeVector(&contents);
+
+  return success;
+}
+
+bool ZipReader::ExtractCurrentEntryToRefCountedMemory(
+    int max_read_bytes,
+    scoped_refptr<base::RefCountedMemory>* output) const {
+  DCHECK(output);
+  base::RefCountedMemory* ptr = NULL;
+  bool result = ExtractCurrentEntryToRefCountedMemory(max_read_bytes, &ptr);
+  if (result && ptr)
+    *output = make_scoped_refptr(ptr);
+  return result;
+}
+
 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 53 matching lines @@
                    success_callback,
                    failure_callback,
                    progress_callback,
                    current_progress));
 
   }
 }
 
 
 }  // namespace zip