DO NOT SUBMIT: what chrome/browser/resources/ could eventually look like with clang-format

chrome/browser/resources/ntp4/apps_page.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.
 
 cr.define('ntp', function() {
   'use strict';
 
   var APP_LAUNCH = {
     // The histogram buckets (keep in sync with extension_constants.h).
     NTP_APPS_MAXIMIZED: 0,
     NTP_APPS_COLLAPSED: 1,
     NTP_APPS_MENU: 2,
     NTP_MOST_VISITED: 3,
     NTP_APP_RE_ENABLE: 16,
     NTP_WEBSTORE_FOOTER: 18,
     NTP_WEBSTORE_PLUS_ICON: 19,
   };
 
   // Histogram buckets for UMA tracking of where a DnD drop came from.
   var DRAG_SOURCE = {
     SAME_APPS_PANE: 0,
     OTHER_APPS_PANE: 1,
     MOST_VISITED_PANE: 2,  // Deprecated.
-    BOOKMARKS_PANE: 3,  // Deprecated.
+    BOOKMARKS_PANE: 3,     // Deprecated.
     OUTSIDE_NTP: 4
   };
   var DRAG_SOURCE_LIMIT = DRAG_SOURCE.OUTSIDE_NTP + 1;
 
   /**
    * App context menu. The class is designed to be used as a singleton with
    * the app that is currently showing a context menu stored in this.app_.
    * @constructor
    */
   function AppContextMenu() {
@@ skipping 14 matching lines @@
 
       menu.appendChild(cr.ui.MenuItem.createSeparator());
       this.launchRegularTab_ = this.appendMenuItem_('applaunchtyperegular');
       this.launchPinnedTab_ = this.appendMenuItem_('applaunchtypepinned');
       if (loadTimeData.getBoolean('canHostedAppsOpenInWindows'))
         this.launchNewWindow_ = this.appendMenuItem_('applaunchtypewindow');
       this.launchFullscreen_ = this.appendMenuItem_('applaunchtypefullscreen');
 
       var self = this;
       this.forAllLaunchTypes_(function(launchTypeButton, id) {
-        launchTypeButton.addEventListener('activate',
-            self.onLaunchTypeChanged_.bind(self));
+        launchTypeButton.addEventListener(
+            'activate', self.onLaunchTypeChanged_.bind(self));
       });
 
       this.launchTypeMenuSeparator_ = cr.ui.MenuItem.createSeparator();
       menu.appendChild(this.launchTypeMenuSeparator_);
       this.options_ = this.appendMenuItem_('appoptions');
       this.uninstall_ = this.appendMenuItem_('appuninstall');
 
       if (loadTimeData.getBoolean('canShowAppInfoDialog')) {
         this.appinfo_ = this.appendMenuItem_('appinfodialog');
-        this.appinfo_.addEventListener('activate',
-                                       this.onShowAppInfo_.bind(this));
+        this.appinfo_.addEventListener(
+            'activate', this.onShowAppInfo_.bind(this));
       } else {
         this.details_ = this.appendMenuItem_('appdetails');
-        this.details_.addEventListener('activate',
-                                       this.onShowDetails_.bind(this));
+        this.details_.addEventListener(
+            'activate', this.onShowDetails_.bind(this));
       }
 
-      this.options_.addEventListener('activate',
-                                     this.onShowOptions_.bind(this));
-      this.uninstall_.addEventListener('activate',
-                                       this.onUninstall_.bind(this));
+      this.options_.addEventListener(
+          'activate', this.onShowOptions_.bind(this));
+      this.uninstall_.addEventListener(
+          'activate', this.onUninstall_.bind(this));
 
       if (!cr.isChromeOS) {
         this.createShortcutSeparator_ =
             menu.appendChild(cr.ui.MenuItem.createSeparator());
         this.createShortcut_ = this.appendMenuItem_('appcreateshortcut');
         this.createShortcut_.addEventListener(
             'activate', this.onCreateShortcut_.bind(this));
       }
 
       document.body.appendChild(menu);
@@ skipping 16 matching lines @@
 
     /**
      * Iterates over all the launch type menu items.
      * @param {function(cr.ui.MenuItem, number)} f The function to call for each
      *     menu item. The parameters to the function include the menu item and
      *     the associated launch ID.
      * @private
      */
     forAllLaunchTypes_: function(f) {
       // Order matters: index matches launchType id.
-      var launchTypes = [this.launchPinnedTab_,
-                         this.launchRegularTab_,
-                         this.launchFullscreen_,
-                         this.launchNewWindow_];
+      var launchTypes = [
+        this.launchPinnedTab_, this.launchRegularTab_, this.launchFullscreen_,
+        this.launchNewWindow_
+      ];
 
       for (var i = 0; i < launchTypes.length; ++i) {
         if (!launchTypes[i])
           continue;
 
         f(launchTypes[i], i);
       }
     },
 
     /**
@@ skipping 13 matching lines @@
         // There are three cases when a launch type is hidden:
         //  1. packaged apps hide all launch types
         //  2. canHostedAppsOpenInWindows is false and type is launchTypeWindow
         //  3. enableNewBookmarkApps is true and type is anything except
         //     launchTypeWindow
         launchTypeButton.hidden = app.appData.packagedApp ||
             (!loadTimeData.getBoolean('canHostedAppsOpenInWindows') &&
              launchTypeButton == launchTypeWindow) ||
             (loadTimeData.getBoolean('enableNewBookmarkApps') &&
              launchTypeButton != launchTypeWindow);
-        if (!launchTypeButton.hidden) hasLaunchType = true;
+        if (!launchTypeButton.hidden)
+          hasLaunchType = true;
       });
 
       this.launchTypeMenuSeparator_.hidden =
           app.appData.packagedApp || !hasLaunchType;
 
       this.options_.disabled = !app.appData.optionsUrl || !app.appData.enabled;
       if (this.details_)
         this.details_.disabled = !app.appData.detailsUrl;
       this.uninstall_.disabled = !app.appData.mayDisable;
 
@@ skipping 16 matching lines @@
      * @private
      */
     onLaunchTypeChanged_: function(e) {
       var pressed = e.currentTarget;
       var app = this.app_;
       var targetLaunchType = pressed;
       // When bookmark apps are enabled, hosted apps can only toggle between
       // open as window and open as tab.
       if (loadTimeData.getBoolean('enableNewBookmarkApps')) {
         targetLaunchType = this.launchNewWindow_.checked ?
-            this.launchRegularTab_ : this.launchNewWindow_;
+            this.launchRegularTab_ :
+            this.launchNewWindow_;
       }
       this.forAllLaunchTypes_(function(launchTypeButton, id) {
         if (launchTypeButton == targetLaunchType) {
           chrome.send('setLaunchType', [app.appId, id]);
           // Manually update the launch type. We will only get
           // appsPrefChangeCallback calls after changes to other NTP instances.
           app.appData.launch_type = id;
         }
       });
     },
@@ skipping 52 matching lines @@
       assert(this.appData_.id, 'Got an app without an ID');
       this.id = this.appData_.id;
       this.setAttribute('role', 'menuitem');
 
       this.className = 'app focusable';
 
       this.appContents_ = $('app-icon-template').cloneNode(true);
       this.appContents_.id = '';
       this.appendChild(this.appContents_);
 
-      this.appImgContainer_ = /** @type {HTMLElement} */(
-          this.querySelector('.app-img-container'));
+      this.appImgContainer_ =
+          /** @type {HTMLElement} */ (this.querySelector('.app-img-container'));
       this.appImg_ = this.appImgContainer_.querySelector('img');
       this.setIcon();
 
       this.addLaunchClickTarget_(this.appImgContainer_);
       this.appImgContainer_.title = this.appData_.full_name;
 
       // The app's full name is shown in the tooltip, whereas the short name
       // is used for the label.
-      var appSpan = /** @type {HTMLElement} */(
+      var appSpan = /** @type {HTMLElement} */ (
           this.appContents_.querySelector('.title'));
       appSpan.textContent = this.appData_.title;
       appSpan.title = this.appData_.full_name;
       this.addLaunchClickTarget_(appSpan);
 
       this.addEventListener('keydown', cr.ui.contextMenuHandler);
       this.addEventListener('keyup', cr.ui.contextMenuHandler);
 
       // This hack is here so that appContents.contextMenu will be the same as
       // this.contextMenu.
       var self = this;
       this.appContents_.__defineGetter__('contextMenu', function() {
         return self.contextMenu;
       });
 
       if (!this.appData_.kioskMode) {
-        this.appContents_.addEventListener('contextmenu',
-                                           cr.ui.contextMenuHandler);
+        this.appContents_.addEventListener(
+            'contextmenu', cr.ui.contextMenuHandler);
       }
 
       this.addEventListener('mousedown', this.onMousedown_, true);
       this.addEventListener('keydown', this.onKeydown_);
       this.addEventListener('blur', this.onBlur_);
     },
 
     /**
      * Removes the app tile from the page. Should be called after the app has
      * been uninstalled.
@@ skipping 62 matching lines @@
       this.classList.remove('click-focus');
       this.appContents_.classList.remove('suppress-active');
     },
 
     /**
      * Invoked when an app is clicked.
      * @param {Event} e The click/auxclick event.
      * @private
      */
     onClick_: function(e) {
-      if (/** @type {MouseEvent} */(e).button > 1)
+      if (/** @type {MouseEvent} */ (e).button > 1)
         return;
 
-      chrome.send('launchApp',
-                  [this.appId, APP_LAUNCH.NTP_APPS_MAXIMIZED, 'chrome-ntp-icon',
-                   e.button, e.altKey, e.ctrlKey, e.metaKey, e.shiftKey]);
+      chrome.send('launchApp', [
+        this.appId, APP_LAUNCH.NTP_APPS_MAXIMIZED, 'chrome-ntp-icon', e.button,
+        e.altKey, e.ctrlKey, e.metaKey, e.shiftKey
+      ]);
 
       // Don't allow the click to trigger a link or anything
       e.preventDefault();
     },
 
     /**
      * Invoked when the user presses a key while the app is focused.
      * @param {Event} e The key event.
      * @private
      */
     onKeydown_: function(e) {
       if (e.key == 'Enter') {
-        chrome.send('launchApp',
-                    [this.appId, APP_LAUNCH.NTP_APPS_MAXIMIZED, '',
-                     0, e.altKey, e.ctrlKey, e.metaKey, e.shiftKey]);
+        chrome.send('launchApp', [
+          this.appId, APP_LAUNCH.NTP_APPS_MAXIMIZED, '', 0, e.altKey, e.ctrlKey,
+          e.metaKey, e.shiftKey
+        ]);
         e.preventDefault();
         e.stopPropagation();
       }
     },
 
     /**
      * Adds a node to the list of targets that will launch the app. This list
      * is also used in onMousedown to determine whether the app contents should
      * be shown as active (if we don't do this, then clicking anywhere in
      * appContents, even a part that is outside the ideally clickable region,
@@ skipping 15 matching lines @@
      * @param {Event} e The mousedown event.
      * @private
      */
     onMousedown_: function(e) {
       // If the current platform uses middle click to autoscroll and this
       // mousedown isn't handled, onClick_() will never fire. crbug.com/142939
       if (e.button == 1)
         e.preventDefault();
 
       if (e.button == 2 ||
-          !findAncestorByClass(/** @type {Element} */(e.target),
-                               'launch-click-target')) {
+          !findAncestorByClass(
+              /** @type {Element} */ (e.target), 'launch-click-target')) {
         this.appContents_.classList.add('suppress-active');
       } else {
         this.appContents_.classList.remove('suppress-active');
       }
 
       // This class is here so we don't show the focus state for apps that
       // gain keyboard focus via mouse clicking.
       this.classList.add('click-focus');
     },
 
     /**
      * Change the appData and update the appearance of the app.
      * @param {AppInfo} appData The new data object that describes the app.
      */
     replaceAppData: function(appData) {
       this.appData_ = appData;
       this.setIcon();
       this.loadIcon();
     },
 
     /**
      * The data and preferences for this app.
      * @type {Object}
      */
-    set appData(data) { this.appData_ = data; },
-    get appData() { return this.appData_; },
+    set appData(data) {
+      this.appData_ = data;
+    },
+    get appData() {
+      return this.appData_;
+    },
 
     /** @type {string} */
-    get appId() { return this.appData_.id; },
+    get appId() {
+      return this.appData_.id;
+    },
 
     /**
      * Returns a pointer to the context menu for this app. All apps share the
      * singleton AppContextMenu. This function is called by the
      * ContextMenuHandler in response to the 'contextmenu' event.
      * @type {cr.ui.Menu}
      */
     get contextMenu() {
       var menu = AppContextMenu.getInstance();
       menu.setupForApp(this);
       return menu.menu;
     },
 
     /**
      * Returns whether this element can be 'removed' from chrome (i.e. whether
      * the user can drag it onto the trash and expect something to happen).
      * @return {boolean} True if the app can be uninstalled.
      */
-    canBeRemoved: function() { return this.appData_.mayDisable; },
+    canBeRemoved: function() {
+      return this.appData_.mayDisable;
+    },
 
     /**
      * Uninstalls the app after it's been dropped on the trash.
      */
     removeFromChrome: function() {
       chrome.send('uninstallApp', [this.appData_.id, true]);
       this.tile.tilePage.removeTile(this.tile, true);
     },
 
     /**
@@ skipping 131 matching lines @@
         this.setDropEffect(e.dataTransfer);
       }
     },
 
     /** @override */
     shouldAcceptDrag: function(e) {
       if (ntp.getCurrentlyDraggingTile())
         return true;
       if (!e.dataTransfer || !e.dataTransfer.types)
         return false;
-      return Array.prototype.indexOf.call(e.dataTransfer.types,
-                                          'text/uri-list') != -1;
+      return Array.prototype.indexOf.call(
+                 e.dataTransfer.types, 'text/uri-list') != -1;
     },
 
     /** @override */
     addDragData: function(dataTransfer, index) {
       var sourceId = -1;
       var currentlyDraggingTile = ntp.getCurrentlyDraggingTile();
       if (currentlyDraggingTile) {
         var tileContents = currentlyDraggingTile.firstChild;
         if (tileContents.classList.contains('app')) {
           var originalPage = currentlyDraggingTile.tilePage;
           var samePageDrag = originalPage == this;
           sourceId = samePageDrag ? DRAG_SOURCE.SAME_APPS_PANE :
                                     DRAG_SOURCE.OTHER_APPS_PANE;
-          this.tileGrid_.insertBefore(currentlyDraggingTile,
-                                      this.tileElements_[index]);
+          this.tileGrid_.insertBefore(
+              currentlyDraggingTile, this.tileElements_[index]);
           this.tileMoved(currentlyDraggingTile);
           if (!samePageDrag) {
             originalPage.fireRemovedEvent(currentlyDraggingTile, index, true);
             this.fireAddedEvent(currentlyDraggingTile, index, true);
           }
         }
       } else {
         this.addOutsideData_(dataTransfer);
         sourceId = DRAG_SOURCE.OUTSIDE_NTP;
       }
 
       assert(sourceId != -1);
-      chrome.send('metricsHandler:recordInHistogram',
+      chrome.send(
+          'metricsHandler:recordInHistogram',
           ['NewTabPage.AppsPageDragSource', sourceId, DRAG_SOURCE_LIMIT]);
     },
 
     /**
      * Adds drag data that has been dropped from a source that is not a tile.
      * @param {Object} dataTransfer The data transfer object that holds drop
      *     data.
      * @private
      */
     addOutsideData_: function(dataTransfer) {
@@ skipping 72 matching lines @@
     chrome.send('launchApp', [appId, APP_LAUNCH.NTP_APP_RE_ENABLE]);
   }
 
   return {
     APP_LAUNCH: APP_LAUNCH,
     App: App,
     AppsPage: AppsPage,
     launchAppAfterEnable: launchAppAfterEnable,
   };
 });