Files.app: Add missing JSdoc for member methods/variables #2.

chrome/browser/resources/file_manager/js/metadata/exif_parser.js

 // 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.
 
 var EXIF_MARK_SOI = 0xffd8;  // Start of image data.
 var EXIF_MARK_SOS = 0xffda;  // Start of "stream" (the actual image data).
 var EXIF_MARK_SOF = 0xffc0;  // Start of "frame"
 var EXIF_MARK_EXIF = 0xffe1;  // Start of exif block.
 
 var EXIF_ALIGN_LITTLE = 0x4949;  // Indicates little endian exif data.
@@ skipping 10 matching lines @@
 var EXIF_TAG_ORIENTATION = 0x0112;
 var EXIF_TAG_X_DIMENSION = 0xA002;
 var EXIF_TAG_Y_DIMENSION = 0xA003;
 
 function ExifParser(parent) {
   ImageParser.call(this, parent, 'jpeg', /\.jpe?g$/i);
 }
 
 ExifParser.prototype = {__proto__: ImageParser.prototype};
 
+/**
+ * @param {File} file  //TODO(JSDOC).
+ * @param {Object} metadata  //TODO(JSDOC).
+ * @param {function} callback  //TODO(JSDOC).
+ * @param {function} errorCallback  //TODO(JSDOC).
+ */
 ExifParser.prototype.parse = function(file, metadata, callback, errorCallback) {
   this.requestSlice(file, callback, errorCallback, metadata, 0);
 };
 
+/**
+ * @param {File} file  //TODO(JSDOC).
+ * @param {function} callback  //TODO(JSDOC).
+ * @param {function} errorCallback  //TODO(JSDOC).
+ * @param {Object} metadata  //TODO(JSDOC).
+ * @param {number} filePos  //TODO(JSDOC).
+ * @param {number=} opt_length  //TODO(JSDOC).
+ */
 ExifParser.prototype.requestSlice = function(
     file, callback, errorCallback, metadata, filePos, opt_length) {
   // Read at least 1Kb so that we do not issue too many read requests.
   opt_length = Math.max(1024, opt_length || 0);
 
   var self = this;
   var reader = new FileReader();
   reader.onerror = errorCallback;
   reader.onload = function() { self.parseSlice(
       file, callback, errorCallback, metadata, filePos, reader.result);
   };
   reader.readAsArrayBuffer(file.slice(filePos, filePos + opt_length));
 };
 
+/**
+ * @param {File} file  //TODO(JSDOC).
+ * @param {function} callback  //TODO(JSDOC).
+ * @param {function} errorCallback  //TODO(JSDOC).
+ * @param {Object} metadata  //TODO(JSDOC).
+ * @param {number} filePos  //TODO(JSDOC).
+ * @param {ArrayBuffer} buf  //TODO(JSDOC).
+ */
 ExifParser.prototype.parseSlice = function(
     file, callback, errorCallback, metadata, filePos, buf) {
   try {
     var br = new ByteReader(buf);
 
     if (!br.canRead(4)) {
       // We never ask for less than 4 bytes. This can only mean we reached EOF.
       throw new Error('Unexpected EOF @' + (filePos + buf.byteLength));
     }
 
@@ skipping 46 matching lines @@
         return;
       }
 
       br.seek(nextSectionStart, ByteReader.SEEK_BEG);
     }
   } catch (e) {
     errorCallback(e.toString());
   }
 };
 
+/**
+ * @private
+ * @param {number} mark  //TODO(JSDOC).
+ * @return {boolean}  //TODO(JSDOC).
+ */
 ExifParser.isSOF_ = function(mark) {
   // There are 13 variants of SOF fragment format distinguished by the last
   // hex digit of the mark, but the part we want is always the same.
   if ((mark & ~0xF) != EXIF_MARK_SOF) return false;
 
   // If the last digit is 4, 8 or 12 it is not really a SOF.
   var type = mark & 0xF;
   return (type != 4 && type != 8 && type != 12);
 };
 
+/**
+ * @param {Object} metadata  //TODO(JSDOC).
+ * @param {ArrayBuffer} buf  //TODO(JSDOC).
+ * @param {ByteReader} br  //TODO(JSDOC).
+ */
 ExifParser.prototype.parseExifSection = function(metadata, buf, br) {
   var magic = br.readString(6);
   if (magic != 'Exif\0\0') {
     // Some JPEG files may have sections marked with EXIF_MARK_EXIF
     // but containing something else (e.g. XML text). Ignore such sections.
     this.vlog('Invalid EXIF magic: ' + magic + br.readString(100));
     return;
   }
 
   // Offsets inside the EXIF block are based after the magic string.
@@ skipping 63 matching lines @@
       EXIF_TAG_JPG_THUMB_LENGTH in metadata.ifd.thumbnail) {
     this.vlog('Read thumbnail image.');
     br.seek(metadata.ifd.thumbnail[EXIF_TAG_JPG_THUMB_OFFSET].value);
     metadata.thumbnailURL = br.readImage(
         metadata.ifd.thumbnail[EXIF_TAG_JPG_THUMB_LENGTH].value);
   } else {
     this.vlog('Image has EXIF data, but no JPG thumbnail.');
   }
 };
 
+/**
+ * @param {Object} metadata  //TODO(JSDOC).
+ * @param {number} width  //TODO(JSDOC).
+ * @param {number} height  //TODO(JSDOC).
+ */
 ExifParser.setImageSize = function(metadata, width, height) {
   if (metadata.imageTransform && metadata.imageTransform.rotate90) {
     metadata.width = height;
     metadata.height = width;
   } else {
     metadata.width = width;
     metadata.height = height;
   }
 };
 
+/**
+ * @param {ByteReader} br  //TODO(JSDOC).
+ * @return {number}  //TODO(JSDOC).
+ */
 ExifParser.prototype.readMark = function(br) {
   return br.readScalar(2);
 };
 
+/**
+ * @param {ByteReader} br  //TODO(JSDOC).
+ * @return {number}  //TODO(JSDOC).
+ */
 ExifParser.prototype.readMarkLength = function(br) {
   // Length includes the 2 bytes used to store the length.
   return br.readScalar(2) - 2;
 };
 
+/**
+ * @param {ByteReader} br  //TODO(JSDOC).
+ * @param {Array.<Object>} tags  //TODO(JSDOC).
+ * @return {number}  //TODO(JSDOC).
+ */
 ExifParser.prototype.readDirectory = function(br, tags) {
   var entryCount = br.readScalar(2);
   for (var i = 0; i < entryCount; i++) {
     var tagId = br.readScalar(2);
     var tag = tags[tagId] = {id: tagId};
     tag.format = br.readScalar(2);
     tag.componentCount = br.readScalar(4);
     this.readTagValue(br, tag);
   }
 
   return br.readScalar(4);
 };
 
+/**
+ * @param {ByteReader} br  //TODO(JSDOC).
+ * @param {Object} tag  //TODO(JSDOC).
+ */
 ExifParser.prototype.readTagValue = function(br, tag) {
   var self = this;
 
   function safeRead(size, readFunction, signed) {
     try {
       unsafeRead(size, readFunction, signed);
     } catch (ex) {
       self.log('error reading tag 0x' + tag.id.toString(16) + '/' +
                tag.format + ', size ' + tag.componentCount + '*' + size + ' ' +
                (ex.stack || '<no stack>') + ': ' + ex);
@@ skipping 83 matching lines @@
       this.vlog('Unknown tag format 0x' + Number(tag.id).toString(16) +
                 ': ' + tag.format);
       safeRead(4);
       break;
   }
 
   this.vlog('Read tag: 0x' + tag.id.toString(16) + '/' + tag.format + ': ' +
             tag.value);
 };
 
-//TODO(JSDOC)
+/**
+ * TODO(JSDOC)
+ * @const
+ * @type {Array.<number>}
+ */
 ExifParser.SCALEX = [1, -1, -1, 1, 1, 1, -1, -1];
 
-//TODO(JSDOC)
+/**
+ * TODO(JSDOC)
+ * @const
+ * @type {Array.<number>}
+ */
 ExifParser.SCALEY = [1, 1, -1, -1, -1, 1, 1, -1];
 
-//TODO(JSDOC)
+/**
+ * TODO(JSDOC)
+ * @const
+ * @type {Array.<number>}
+ */
 ExifParser.ROTATE90 = [0, 0, 0, 0, 1, 1, 1, 1];
 
 /**
  * Transform exif-encoded orientation into a set of parameters compatible with
  * CSS and canvas transforms (scaleX, scaleY, rotation).
  *
  * @param {Object} ifd exif property dictionary (image or thumbnail).
  * @return {Object} //TODO(JSDOC).
  */
 ExifParser.prototype.parseOrientation = function(ifd) {
   if (ifd[EXIF_TAG_ORIENTATION]) {
     var index = (ifd[EXIF_TAG_ORIENTATION].value || 1) - 1;
     return {
       scaleX: ExifParser.SCALEX[index],
       scaleY: ExifParser.SCALEY[index],
       rotate90: ExifParser.ROTATE90[index]
     };
   }
   return null;
 };
 
 MetadataDispatcher.registerParserClass(ExifParser);