[Cleanup] Files.app: Misc style fixes in Javascript code.

chrome/browser/resources/file_manager/js/image_editor/image_view.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.
 
 /**
  * The overlay displaying the image.
- * @constructor
+ *
  * @param {HTMLElement} container The container element.
  * @param {Viewport} viewport The viewport.
  * @param {MetadataCache} metadataCache The metadataCache.
+ * @constructor
  */
 function ImageView(container, viewport, metadataCache) {
   this.container_ = container;
   this.viewport_ = viewport;
   this.document_ = container.ownerDocument;
   this.contentGeneration_ = 0;
   this.displayedContentGeneration_ = 0;
   this.displayedViewportGeneration_ = 0;
 
   this.imageLoader_ = new ImageUtil.ImageLoader(this.document_);
   // We have a separate image loader for prefetch which does not get cancelled
   // when the selection changes.
   this.prefetchLoader_ = new ImageUtil.ImageLoader(this.document_);
 
   // The content cache is used for prefetching the next image when going
   // through the images sequentially. The real life photos can be large
   // (18Mpix = 72Mb pixel array) so we want only the minimum amount of caching.
   this.contentCache_ = new ImageView.Cache(2);
 
   // We reuse previously generated screen-scale images so that going back to
   // a recently loaded image looks instant even if the image is not in
   // the content cache any more. Screen-scale images are small (~1Mpix)
   // so we can afford to cache more of them.
   this.screenCache_ = new ImageView.Cache(5);
   this.contentCallbacks_ = [];
 
   /**
    * The element displaying the current content.
+   *
    * @type {HTMLCanvasElement|HTMLVideoElement}
+   * @private
    */
   this.screenImage_ = null;
 
   this.localImageTransformFetcher_ = function(url, callback) {
     metadataCache.get(url, 'fetchedMedia', function(fetchedMedia) {
       callback(fetchedMedia.imageTransform);
     });
   };
 }
 
@@ skipping 713 matching lines @@
       oldScreenImage.parentNode.removeChild(oldScreenImage);
   }, effect.getSafeInterval());
 
   return effect.getSafeInterval();
 };
 
 
 /**
  * Generic cache with a limited capacity and LRU eviction.
  *
+ * @param {number} capacity Maximum number of cached item.
  * @constructor
- * @param {number} capacity Maximum number of cached item.
  */
 ImageView.Cache = function(capacity) {
   this.capacity_ = capacity;
   this.map_ = {};
   this.order_ = [];
 };
 
 /**
  * Fetch the item from the cache.
  *
@@ skipping 58 matching lines @@
   if (pos < 0)
     return;  // Not cached.
 
   this.order_[pos] = newId;
   this.map_[newId] = this.map_[oldId];
   delete this.map_[oldId];
 };
 
 /**
  * Disposes an object.
+ *
  * @param {object} item The item object.
  * @private
  */
 ImageView.Cache.prototype.deleteItem_ = function(item) {
   // Trick to reduce memory usage without waiting for gc.
   if (item instanceof HTMLCanvasElement) {
     // If the canvas is being used somewhere else (eg. displayed on the screen),
     // it will be cleared.
     item.width = 0;
     item.height = 0;
   }
 };
 
 /* Transition effects */
 
 /**
  * Base class for effects.
+ *
  * @param {number} duration Duration in ms.
  * @param {string} opt_timing CSS transition timing function name.
  * @constructor
  */
 ImageView.Effect = function(duration, opt_timing) {
   this.duration_ = duration;
   this.timing_ = opt_timing || 'linear';
 };
 
 /**
@@ skipping 165 matching lines @@
 
 /**
  * @param {HTMLCanvasElement|HTMLVideoElement} element Element.
  * @return {string} Transform string.
  */
 ImageView.Effect.Rotate.prototype.transform = function(element) {
   var ratio = ImageView.Effect.getPixelRatio_(element);
   return 'rotate(' + (this.rotate90_ * 90) + 'deg) ' +
          'scale(' + (this.scale_ / ratio) + ')';
 };