More accurate EXIF parsing

chrome/browser/resources/file_manager/js/byte_reader.js

 // Copyright (c) 2011 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.
 
-ByteReader = function(arrayBuffer) {
-  this.buf_ = arrayBuffer;
-  this.view_ = new DataView(arrayBuffer);
+ByteReader = function(arrayBuffer, opt_offset, opt_length) {
+  opt_offset = opt_offset || 0;
+  opt_length = opt_length || (arrayBuffer.byteLength - opt_offset);
+  this.view_ = new DataView(arrayBuffer, opt_offset, opt_length);
   this.pos_ = 0;
   this.seekStack_ = [];
   this.setByteOrder(ByteReader.BIG_ENDIAN);
 };
 
 // Static const and methods.
 
 ByteReader.LITTLE_ENDIAN = 0;  // Intel, 0x1234 is [0x34, 0x12]
 ByteReader.BIG_ENDIAN = 1;  // Motorola, 0x1234 is [0x12, 0x34]
 
@@ skipping 119 matching lines @@
     format = 'unknown';
   }
 
   var b64 = ByteReader.readBase64(dataView, pos, size, opt_end);
   return 'data:image/' + format + ';base64,' + b64;
 };
 
 // Instance methods.
 
 /**
+ * Return true if the requested number of bytes can be read from the buffer.
+ */
+ByteReader.prototype.canRead = function(size) {
+   return this.pos_ + size <= this.view_.byteLength;
+},
+
+/**
  * Return true if the current position is past the end of the buffer.
  */
 ByteReader.prototype.eof = function() {
   return this.pos_ >= this.view_.byteLength;
 };
 
 /**
  * Return true if the current position is before the beginning of the buffer.
  */
 ByteReader.prototype.bof = function() {
   return this.pos_ < 0;
 };
 
 /**
- * Return true if the current position is oustide the buffer.
+ * Return true if the current position is outside the buffer.
  */
 ByteReader.prototype.beof = function() {
   return this.pos_ >= this.view_.byteLength || this.pos_ < 0;
 };
 
 /**
  * Set the expected byte ordering for future reads.
  */
 ByteReader.prototype.setByteOrder = function(order) {
   this.littleEndian_ = order == ByteReader.LITTLE_ENDIAN;
@@ skipping 84 matching lines @@
  * Read as an array of numbers.
  *
  * Adjusts the current position on success.  Throws an exception if the
  * read would go past the end of the buffer.
  */
 ByteReader.prototype.readSlice = function(size, opt_end,
                                           opt_arrayConstructor) {
   this.validateRead(width, opt_end);
 
   var arrayConstructor = opt_arrayConstructor || Uint8Array;
-  var slice = new arrayConstructor(this.buf_, this.pos_, size);
+  var slice = new arrayConstructor(
+      this.view_.buffer, this.view_.byteOffset + this.pos, size);
   this.pos_ += size;
 
   return slice;
 };
 
 /**
  * Read as a sequence of bytes, returning them as a single base64 encoded
  * string.
  *
  * Adjusts the current position on success.  Throws an exception if the
@@ skipping 25 matching lines @@
 
   var newPos;
   if (opt_seekStart == ByteReader.SEEK_CUR) {
     newPos = this.pos_ + pos;
   } else if (opt_seekStart == ByteReader.SEEK_END) {
     newPos = opt_end + pos;
   } else {
     newPos = pos;
   }
 
-  if (newPos < 0 || newPos >= this.view_.byteLength)
+  if (newPos < 0 || newPos > this.view_.byteLength)
     throw new Error('Seek outside of buffer: ' + (newPos - opt_end));
 
   this.pos_ = newPos;
 };
 
 /**
  * Seek to a given position relative to opt_seekStart, saving the current
  * position.
  *
  * Recover the current position with a call to seekPop.
@@ skipping 11 matching lines @@
 ByteReader.prototype.popSeek = function() {
   this.seek(this.seekStack_.pop());
 };
 
 /**
  * Return the current read position.
  */
 ByteReader.prototype.tell = function() {
   return this.pos_;
 };