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

ui/base/resource/resource_bundle.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 "ui/base/resource/resource_bundle.h"
 
 #include <stdint.h>
 
 #include <limits>
 #include <utility>
 #include <vector>
 
 #include "base/big_endian.h"
 #include "base/command_line.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/stl_util.h"
 #include "base/strings/string_piece.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/lock.h"
+#include "base/sys_byteorder.h"
 #include "build/build_config.h"
 #include "skia/ext/image_operations.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 #include "third_party/skia/include/core/SkColor.h"
+#include "third_party/zlib/zlib.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/resource/data_pack.h"
 #include "ui/base/ui_base_paths.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/ui_features.h"
 #include "ui/display/display.h"
 #include "ui/display/screen.h"
 #include "ui/gfx/codec/jpeg_codec.h"
@@ skipping 65 matching lines @@
 #endif  // OS_WIN
 }
 
 SkBitmap CreateEmptyBitmap() {
   SkBitmap bitmap;
   bitmap.allocN32Pixels(32, 32);
   bitmap.eraseARGB(255, 255, 255, 0);
   return bitmap;
 }
 
+// Decodes given gzip input via zlib.
+base::RefCountedBytes* 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::vector<unsigned char> output(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 new base::RefCountedBytes(output);
+}
+
 }  // namespace
 
 // An ImageSkiaSource that loads bitmaps for the requested scale factor from
 // ResourceBundle on demand for a given |resource_id|. If the bitmap for the
 // requested scale factor does not exist, it will return the 1x bitmap scaled
 // by the scale factor. This may lead to broken UI if the correct size of the
 // scaled image is not exactly |scale_factor| * the size of the 1x resource.
 // When --highlight-missing-scaled-resources flag is specified, scaled 1x images
 // are higlighted by blending them with red.
 class ResourceBundle::ResourceBundleImageSource : public gfx::ImageSkiaSource {
@@ skipping 322 matching lines @@
 
 base::RefCountedMemory* ResourceBundle::LoadDataResourceBytesForScale(
     int resource_id,
     ScaleFactor scale_factor) const {
   base::RefCountedMemory* bytes = NULL;
   if (delegate_)
     bytes = delegate_->LoadDataResourceBytes(resource_id, scale_factor);
 
   if (!bytes) {
     base::StringPiece data =
-        GetRawDataResourceForScale(resource_id, scale_factor);
+        DoGetRawDataResourceForScale(resource_id, scale_factor);
     if (!data.empty()) {
-      bytes = new base::RefCountedStaticMemory(data.data(), data.length());
+      if (data.starts_with(CUSTOM_GZIP_HEADER)) {
+        // Jump past special identification byte prepended to header
+        const unsigned char* gzip_start =
+            reinterpret_cast<const unsigned char*>(data.data()) + 1;
+        bytes = DecodeGzipData(gzip_start, data.length() - 1);
+      } else {
+        bytes = new base::RefCountedStaticMemory(data.data(), data.length());
+      }
     }
   }
 
   return bytes;
 }
 
 base::StringPiece ResourceBundle::GetRawDataResource(int resource_id) const {
   return GetRawDataResourceForScale(resource_id, ui::SCALE_FACTOR_NONE);
 }
 
 base::StringPiece ResourceBundle::GetRawDataResourceForScale(
     int resource_id,
     ScaleFactor scale_factor) const {
+  base::StringPiece data =
+      DoGetRawDataResourceForScale(resource_id, scale_factor);
+
+  // Do not allow this function to retrieve gzip compressed resources

[agrieve, 2016/05/27 17:40:00]

nit: missing trailing .

[smaier, 2016/05/27 17:48:47]

Done.

+  CHECK(!data.starts_with(CUSTOM_GZIP_HEADER));
+
+  return data;
+}
+
+base::StringPiece ResourceBundle::DoGetRawDataResourceForScale(
+    int resource_id,
+    ScaleFactor scale_factor) const {
   base::StringPiece data;
   if (delegate_ &&
       delegate_->GetRawDataResource(resource_id, scale_factor, &data))
     return data;
 
   if (scale_factor != ui::SCALE_FACTOR_100P) {
     for (size_t i = 0; i < data_packs_.size(); i++) {
       if (data_packs_[i]->GetScaleFactor() == scale_factor &&
           data_packs_[i]->GetStringPiece(static_cast<uint16_t>(resource_id),
                                          &data))
@@ skipping 413 matching lines @@
 // static
 bool ResourceBundle::DecodePNG(const unsigned char* buf,
                                size_t size,
                                SkBitmap* bitmap,
                                bool* fell_back_to_1x) {
   *fell_back_to_1x = PNGContainsFallbackMarker(buf, size);
   return gfx::PNGCodec::Decode(buf, size, bitmap);
 }
 
 }  // namespace ui