Track positions of dimensions in image files

third_party/WebKit/Source/platform/image-decoders/jpeg/JPEGImageDecoder.cpp

 /*
  * Copyright (C) 2006 Apple Computer, Inc.
  *
  * Portions are Copyright (C) 2001-6 mozilla.org
  *
  * Other contributors:
  *   Stuart Parmenter <stuart@mozilla.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ skipping 20 matching lines @@
  * version of this file under the LGPL, indicate your decision by
  * deletingthe provisions above and replace them with the notice and
  * other provisions required by the MPL or the GPL, as the case may be.
  * If you do not delete the provisions above, a recipient may use your
  * version of this file under any of the LGPL, the MPL or the GPL.
  */
 
 #include "platform/image-decoders/jpeg/JPEGImageDecoder.h"
 
 #include "platform/PlatformInstrumentation.h"
+#include "public/platform/Platform.h"
+
+#include <stdint.h>
 
 extern "C" {
 #include <stdio.h> // jpeglib.h needs stdio FILE.
 #include "jpeglib.h"
 #if USE(ICCJPEG)
 #include "iccjpeg.h"
 #endif
 #if USE(QCMSLIB)
 #include "qcms.h"
 #endif
@@ skipping 18 matching lines @@
 inline bool colorSpaceHasAlpha(J_COLOR_SPACE) { return false; }
 #endif
 
 namespace {
 
 const int exifMarker = JPEG_APP0 + 1;
 
 // JPEG only supports a denominator of 8.
 const unsigned scaleDenominator = 8;
 
+
+// Returns a 16-bit integer with big-endian representation from a byte array.
+unsigned getUint16(const char* p)
+{
+    return ((*((unsigned char*)p)) << 8) + *((unsigned char*)(p + 1));
+}
+
+// Returns the number of bytes that must be fetched before the image dimensions can be determined.
+// Used for metrics only. Returns 0 if dimensions not found.
+size_t getDimensionsOffset(const RefPtr<blink::SharedBuffer>& m_data)
+{
+    const char* segment;
+    size_t pos = 0;
+    int height = 0, width = 0;
+    size_t length = m_data->getSomeData(segment, pos);
+    if (length < 2 || 0xFFD8 != getUint16(&segment[0]))
+        return 0;
+    pos += 2;
+    while ((length = m_data->getSomeData(segment, pos))) {
+        if (length < 2)
+            return 0;
+        int marker = getUint16(&segment[0]) & 0xfffc;
+        if (marker == 0xffc0)
+            break;
+        pos += 2 + getUint16(&segment[2]);
+    }
+    if (length < 8)
+        return 0;
+    // Height and width are two bytes each and are at bytes 5 and 7 of this segment, respectively.
+    return pos + 8;
+}
+
 } // namespace
 
 namespace blink {
 
 struct decoder_error_mgr {
     DISALLOW_NEW();
     struct jpeg_error_mgr pub; // "public" fields for IJG library
     int num_corrupt_warnings;  // Counts corrupt warning messages
     jmp_buf setjmp_buffer;     // For handling catastropic errors
 };
@@ skipping 374 matching lines @@
             // Calculate and set decoded size.
             m_info.scale_num = m_decoder->desiredScaleNumerator();
             m_info.scale_denom = scaleDenominator;
             // Scaling caused by running low on memory isn't supported by YUV decoding since
             // YUV decoding is performed on full sized images. At this point, buffers and various
             // image info structs have already been setup to the scaled size after reading the
             // image header using this decoder, so using the full size is no longer possible.
             if (m_info.scale_num != m_info.scale_denom)
                 overrideColorSpace = JCS_UNKNOWN;
             jpeg_calc_output_dimensions(&m_info);
+            m_decoder->setSizeOffset(m_nextReadPosition);
             m_decoder->setDecodedSize(m_info.output_width, m_info.output_height);
 
             m_decoder->setOrientation(readImageOrientation(info()));
 
 #if USE(QCMSLIB)
             // Allow color management of the decoded RGBA pixels if possible.
             if (!m_decoder->ignoresGammaAndColorProfile()) {
                 ColorProfile colorProfile;
                 readColorProfile(info(), colorProfile);
                 createColorTransform(colorProfile, colorSpaceHasAlpha(m_info.out_color_space));
@@ skipping 281 matching lines @@
     return reinterpret_cast_ptr<decoder_source_mgr*>(jd->src)->reader->fillBuffer();
 }
 
 void term_source(j_decompress_ptr jd)
 {
     reinterpret_cast_ptr<decoder_source_mgr*>(jd->src)->reader->decoder()->complete();
 }
 
 JPEGImageDecoder::JPEGImageDecoder(AlphaOption alphaOption, GammaAndColorProfileOption colorOptions, size_t maxDecodedBytes)
     : ImageDecoder(alphaOption, colorOptions, maxDecodedBytes)
-    , m_hasColorProfile(false)
+    , m_sizeOffset(0), m_sizeOffsetOptimized(0), m_hasColorProfile(false)
 {
 }
 
 JPEGImageDecoder::~JPEGImageDecoder()
 {
 }
 
 bool JPEGImageDecoder::setSize(unsigned width, unsigned height)
 {
     if (!ImageDecoder::setSize(width, height))
@@ skipping 278 matching lines @@
 
     if (!m_reader) {
         m_reader = adoptPtr(new JPEGImageReader(this));
         m_reader->setData(m_data.get());
     }
 
     // If we couldn't decode the image but have received all the data, decoding
     // has failed.
     if (!m_reader->decode(onlySize) && isAllDataReceived())
         setFailed();
+    // Decoding should happen only once.
+    if (!onlySize && isComplete(this, onlySize)) {
+        Platform::current()->histogramCustomCounts(
+            "Blink.Images.SizeOffsetOptimized_JPEG", getDimensionsOffset(m_data), 1, 1000000, 50);
+        Platform::current()->histogramCustomCounts(
+            "Blink.Images.SizeOffset_JPEG", m_sizeOffset, 1, 1000000, 50);
+    }
 
     // If decoding is done or failed, we don't need the JPEGImageReader anymore.
     if (isComplete(this, onlySize) || failed())
         m_reader.clear();
 }
 
 } // namespace blink