Compressing .pak resources with new option: "type=GZIPPABLE_BINDATA"

content/browser/webui/web_ui_data_source_impl.cc

Index: content/browser/webui/web_ui_data_source_impl.cc
diff --git a/content/browser/webui/web_ui_data_source_impl.cc b/content/browser/webui/web_ui_data_source_impl.cc
index 0a4c341649709c106323a5199d3900d3afbed755..8053526f59038263a7493475320752a185e033f0 100644
--- a/content/browser/webui/web_ui_data_source_impl.cc
+++ b/content/browser/webui/web_ui_data_source_impl.cc
@@ -13,13 +13,45 @@
 #include "base/memory/ref_counted_memory.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/sys_byteorder.h"
 #include "content/grit/content_resources.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/common/content_client.h"
+#include "third_party/zlib/zlib.h"
 #include "ui/base/template_expressions.h"
 #include "ui/base/webui/jstemplate_builder.h"
 #include "ui/base/webui/web_ui_util.h"
 
+namespace {
+// Decodes given gzip input via zlib.
+scoped_refptr<base::RefCountedString> DecodeGzipData(
+    const unsigned char* input_buffer,
+    size_t input_size) {
+  z_stream infstream;
+  infstream.zalloc = Z_NULL;
+  infstream.zfree = Z_NULL;
+  infstream.opaque = Z_NULL;
+
+  infstream.avail_in = input_size;
+  infstream.next_in = const_cast<Bytef*>(input_buffer);
+
+  // Size of output comes from footer of gzip file format, found as the last 4
+  // bytes in the compressed file, which are stored little endian.
+  infstream.avail_out = base::ByteSwapToLE32(
+      *reinterpret_cast<const uint32_t*>(&input_buffer[input_size - 4]));
+
+  std::string output;
+  output.resize(infstream.avail_out);
+  infstream.next_out = reinterpret_cast<Bytef*>(&output[0]);  // output buffer
+
+  CHECK(inflateInit2(&infstream, 16) == Z_OK);
+  CHECK(inflate(&infstream, Z_FINISH) == Z_STREAM_END);
+  CHECK(inflateEnd(&infstream) == Z_OK);
+
+  return base::RefCountedString::TakeString(&output);
+}
+}  // end of anynomous namespace
+
 namespace content {
 
 // static
@@ -239,6 +271,13 @@ void WebUIDataSourceImpl::StartDataRequest(
   scoped_refptr<base::RefCountedMemory> response(
       GetContentClient()->GetDataResourceBytes(resource_id));
 
+  const unsigned char* response_array = response->front();
+  if (response_array[0] == 0x1f && response_array[1] == 0x8b) {

[flackr, 2016/05/13 23:02:16]

I'm concerned with detecting gzipped resources by the header bytes since we know
which resources have been gzipped when packing them, and also only decompressing
them in the WebUIDataSource (other places in the code might try to use the
gzipped files as is). I've given some thought about how we could handle this
without looking for the magic bytes:

1) Ideally we would have some way to decompress this in
DataPack::GetStringPiece, but doing that would probably require changing our
data pack format to have some flags for each resource (We could generate a
header with id -> extra_data map but that feels somewhat brittle). If we change
the data pack format we'd probably have to special case it so as not to break
other grit clients.

2) Alternately, we could generate the extra bit about whether each resource is
compressed when we build a resource map. This wouldn't handle the general case
but at least provides a way to figure out which resources have been compressed.

3) Last but not least, we could consider having a separate pak for compressed
resources and DataPack::GetStringPiece would know that everything in that pak
must be gzip decoded.

+    // We are assuming that since we have hit the "magic header" (1f:8b) of a
+    // gzipped file, we can now decode it.
+    response = DecodeGzipData(response_array, response->size());
+  }
+
   // TODO(dschuyler): improve filtering of which resource to run template
   // expansion upon.
   if (GetMimeType(path) == "text/html") {