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

content/browser/webui/web_ui_data_source_impl.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 "content/browser/webui/web_ui_data_source_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #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
 WebUIDataSource* WebUIDataSource::Create(const std::string& source_name) {
   return new WebUIDataSourceImpl(source_name);
 }
 
 // static
 void WebUIDataSource::Add(BrowserContext* browser_context,
                           WebUIDataSource* source) {
@@ skipping 199 matching lines @@
   std::map<std::string, int>::iterator result;
   // Remove the query string for named resource lookups.
   std::string file_path = path.substr(0, path.find_first_of('?'));
   result = path_to_idr_map_.find(file_path);
   if (result != path_to_idr_map_.end())
     resource_id = result->second;
   DCHECK_NE(resource_id, -1);
   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") {
     std::string replaced = ui::ReplaceTemplateExpressions(
         base::StringPiece(response->front_as<char>(), response->size()),
         replacements_);
     response = base::RefCountedString::TakeString(&replaced);
   }
 
   callback.Run(response.get());
 }
 
 void WebUIDataSourceImpl::SendLocalizedStringsAsJSON(
     const URLDataSource::GotDataCallback& callback) {
   std::string template_data;
   webui::AppendJsonJS(&localized_strings_, &template_data);
   callback.Run(base::RefCountedString::TakeString(&template_data));
 }
 
 }  // namespace content