[Cleanup] Files.app: Adds missing JSdoc annotations in file_manager/*.js.

chrome/browser/resources/file_manager/js/file_tasks.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.
 
 /**
  * This object encapsulates everything related to tasks execution.
+ *
  * @param {FileManager} fileManager FileManager instance.
  * @param {object} opt_params File manager load parameters.
+ * @constructor
  */
 function FileTasks(fileManager, opt_params) {
   this.fileManager_ = fileManager;
   this.params_ = opt_params;
   this.tasks_ = null;
   this.defaultTask_ = null;
 
   /**
    * List of invocations to be called once tasks are available.
+   *
+   * @private
+   * @type {Array,<Object>}
    */
   this.pendingInvocations_ = [];
 }
 
 /**
 * Location of the Chrome Web Store.
+*
+* @const
+* @type {string}
 */
 FileTasks.CHROME_WEB_STORE_URL = 'https://chrome.google.com/webstore';
 
 /**
 * Location of the FAQ about the file actions.
+*
+* @const
+* @type {string}
 */
 FileTasks.NO_ACTION_FOR_FILE_URL = 'http://support.google.com/chromeos/bin/' +
     'answer.py?answer=1700055&topic=29026&ctx=topic';
 
 /**
  * Complete the initialization.
  *
  * @param {Array.<string>} urls List of file urls.
  * @param {Array.<string>=} opt_mimeTypes List of MIME types for each
  *     of the files.
  */
 FileTasks.prototype.init = function(urls, opt_mimeTypes) {
   this.urls_ = urls;
   if (urls.length > 0)
     chrome.fileBrowserPrivate.getFileTasks(urls, opt_mimeTypes || [],
       this.onTasks_.bind(this));
 };
 
 /**
  * Returns amount of tasks.
- * @return {number=} amount of tasks.
+ *
+ * @return {number} amount of tasks.
  */
 FileTasks.prototype.size = function() {
   return (this.tasks_ && this.tasks_.length) || 0;
 };
 
 /**
  * Callback when tasks found.
+ *
  * @param {Array.<Object>} tasks The tasks.
  * @private
  */
 FileTasks.prototype.onTasks_ = function(tasks) {
   this.processTasks_(tasks);
   for (var index = 0; index < this.pendingInvocations_.length; index++) {
     var name = this.pendingInvocations_[index][0];
     var args = this.pendingInvocations_[index][1];
     this[name].apply(this, args);
   }
   this.pendingInvocations_ = [];
 };
 
 /**
  * Processes internal tasks.
+ *
  * @param {Array.<Object>} tasks The tasks.
  * @private
  */
 FileTasks.prototype.processTasks_ = function(tasks) {
   this.tasks_ = [];
   var id = util.platform.getAppId();
   var is_on_drive = false;
   for (var index = 0; index < this.urls_.length; ++index) {
     if (FileType.isOnDrive(this.urls_[index])) {
       is_on_drive = true;
@@ skipping 67 matching lines @@
   if (!this.defaultTask_ && this.tasks_.length > 0) {
     // If we haven't picked a default task yet, then just pick the first one.
     // This is not the preferred way we want to pick this, but better this than
     // no default at all if the C++ code didn't set one.
     this.defaultTask_ = this.tasks_[0];
   }
 };
 
 /**
  * Executes default task.
+ *
  * @private
  */
 FileTasks.prototype.executeDefault_ = function() {
   if (this.defaultTask_ != null) {
     this.execute_(this.defaultTask_.taskId);
     return;
   }
 
   // We don't have tasks, so try to show a file in a browser tab.
   // We only do that for single selection to avoid confusion.
@@ skipping 14 matching lines @@
     this.checkAvailability_(function() {
       chrome.fileBrowserPrivate.viewFiles(this.urls_, 'default', callback);
     }.bind(this));
   }
 
   // Do nothing for multiple urls.
 };
 
 /**
  * Executes a single task.
+ *
  * @param {string} taskId Task identifier.
  * @param {Array.<string>=} opt_urls Urls to execute on instead of |this.urls_|.
  * @private
  */
 FileTasks.prototype.execute_ = function(taskId, opt_urls) {
   var urls = opt_urls || this.urls_;
   this.checkAvailability_(function() {
     var task_parts = taskId.split('|');
     if (task_parts[0] == util.platform.getAppId() && task_parts[1] == 'file') {
       // For internal tasks we do not listen to the event to avoid
       // handling the same task instance from multiple tabs.
       // So, we manually execute the task.
       this.executeInternalTask_(task_parts[2], urls);
     } else {
       chrome.fileBrowserPrivate.executeTask(taskId, urls);
     }
   }.bind(this));
 };
 
 /**
  * Checks whether the remote files are available right now.
+ *
  * @param {function} callback The callback.
  * @private
  */
 FileTasks.prototype.checkAvailability_ = function(callback) {
   var areAll = function(props, name) {
     var isOne = function(e) {
       // If got no properties, we safely assume that item is unavailable.
       return e && e[name];
     };
     return props.filter(isOne).length == props.length;
@@ skipping 48 matching lines @@
       });
     });
     return;
   }
 
   callback();
 };
 
 /**
  * Executes an internal task.
+ *
  * @param {string} id The short task id.
  * @param {Array.<string>} urls The urls to execute on.
  * @private
  */
 FileTasks.prototype.executeInternalTask_ = function(id, urls) {
   var fm = this.fileManager_;
 
   if (id == 'play') {
     var position = 0;
     if (urls.length == 1) {
@@ skipping 45 matching lines @@
     chrome.fileBrowserPrivate.viewFiles(urls, id, function(success) {
       if (!success)
         console.error('chrome.fileBrowserPrivate.viewFiles failed', urls);
     });
     return;
   }
 };
 
 /**
  * Mounts archives.
+ *
  * @param {Array.<string>} urls Mount file urls list.
  * @private
  */
 FileTasks.prototype.mountArchives_ = function(urls) {
   var fm = this.fileManager_;
 
   var tracker = fm.directoryModel_.createDirectoryChangeTracker();
   tracker.start();
 
   fm.resolveSelectResults_(urls, function(urls) {
     for (var index = 0; index < urls.length; ++index) {
       fm.volumeManager_.mountArchive(urls[index], function(mountPath) {
         console.log('Mounted at: ', mountPath);
         tracker.stop();
         if (!tracker.hasChanged)
           fm.directoryModel_.changeDirectory(mountPath);
       }, function(url, error) {
         var path = util.extractFilePath(url);
         tracker.stop();
         var namePos = path.lastIndexOf('/');
         fm.alert.show(strf('ARCHIVE_MOUNT_FAILED',
                            path.substr(namePos + 1), error));
       }.bind(null, urls[index]));
     }
   });
 };
 
 /**
  * Open the Gallery.
+ *
  * @param {Array.<string>} urls List of selected urls.
  */
 FileTasks.prototype.openGallery = function(urls) {
   var fm = this.fileManager_;
 
   var allUrls =
       fm.getAllUrlsInCurrentDirectory().filter(FileType.isImageOrVideo);
 
   var galleryFrame = fm.document_.createElement('iframe');
   galleryFrame.className = 'overlay-pane';
@@ skipping 57 matching lines @@
     };
     galleryFrame.contentWindow.Gallery.open(context, allUrls, urls);
   }.bind(this);
 
   galleryFrame.src = 'gallery.html';
   fm.openFilePopup_(galleryFrame, fm.updateTitle_.bind(fm));
 };
 
 /**
  * Displays the list of tasks in a task picker combobutton.
+ *
  * @param {cr.ui.ComboButton} combobutton The task picker element.
  * @private
  */
 FileTasks.prototype.display_ = function(combobutton) {
   if (this.tasks_.length == 0) {
     combobutton.hidden = true;
     return;
   }
 
   combobutton.clear();
@@ skipping 13 matching lines @@
 
     combobutton.addSeparator();
     combobutton.addDropDownItem({
           label: loadTimeData.getString('CHANGE_DEFAULT_MENU_ITEM')
         });
   }
 };
 
 /**
  * Creates sorted array of available task descriptions such as title and icon.
+ *
  * @return {Array} created array can be used to feed combobox, menus and so on.
  * @private
  */
 FileTasks.prototype.createItems_ = function() {
   var items = [];
   var title = this.defaultTask_.title + ' ' +
               loadTimeData.getString('DEFAULT_ACTION_LABEL');
   items.push(this.createCombobuttonItem_(this.defaultTask_, title, true));
 
   for (var index = 0; index < this.tasks_.length; index++) {
     var task = this.tasks_[index];
     if (task != this.defaultTask_)
       items.push(this.createCombobuttonItem_(task));
   }
 
   items.sort(function(a, b) {
     return a.label.localeCompare(b.label);
   });
 
   return items;
 };
 
 /**
  * Updates context menu with default item.
  * @private
  */
+
 FileTasks.prototype.updateMenuItem_ = function() {
   this.fileManager_.updateContextMenuActionItems(this.defaultTask_,
       this.tasks_.length > 1);
 };
 
 /**
  * Creates combobutton item based on task.
+ *
  * @param {Object} task Task to convert.
  * @param {string=} opt_title Title.
  * @param {boolean} opt_bold Make a menu item bold.
  * @return {Object} Item appendable to combobutton drop-down list.
  * @private
  */
 FileTasks.prototype.createCombobuttonItem_ = function(task, opt_title,
                                                       opt_bold) {
   return {
     label: opt_title || task.title,
     iconUrl: task.iconUrl,
     iconType: task.iconType,
     task: task,
     bold: opt_bold || false
   };
 };
 
 
 /**
  * Decorates a FileTasks method, so it will be actually executed after the tasks
  * are available.
  * This decorator expects an implementation called |method + '_'|.
+ *
  * @param {string} method The method name.
  */
 FileTasks.decorate = function(method) {
   var privateMethod = method + '_';
   FileTasks.prototype[method] = function() {
     if (this.tasks_) {
       this[privateMethod].apply(this, arguments);
     } else {
       this.pendingInvocations_.push([privateMethod, arguments]);
     }
@@ skipping 23 matching lines @@
       title,
       message,
       items, defaultIdx,
       onSuccess);
 };
 
 FileTasks.decorate('display');
 FileTasks.decorate('updateMenuItem');
 FileTasks.decorate('execute');
 FileTasks.decorate('executeDefault');