web_dev_style: check webui browser tests as well.

chrome/browser/ui/webui/options/options_browsertest.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.
 
 GEN('#include "chrome/browser/ui/webui/options/options_browsertest.h"');
 
 /** @const */ var MANAGED_USERS_PREF = 'profile.managed_users';
 
 /**
  * Wait for the method specified by |methodName|, on the |object| object, to be
  * called, then execute |afterFunction|.
+ * @param {*} object Object with callable property named |methodName|.
+ * @param {string} methodName The name of the property on |object| to use as a
+ *     callback.
+ * @param {!Function} afterFunction A function to call after object.methodName()
+ *     is called.
  */
 function waitForResponse(object, methodName, afterFunction) {
   var originalCallback = object[methodName];
 
   // Install a wrapper that temporarily replaces the original function.
   object[methodName] = function() {
     object[methodName] = originalCallback;
     originalCallback.apply(this, arguments);
     afterFunction();
   };
 }
 
 /**
   * Wait for the global window.onpopstate callback to be called (after a tab
   * history navigation), then execute |afterFunction|.
+  * @param {!Function} afterFunction A function to call after pop state events.
   */
 function waitForPopstate(afterFunction) {
   waitForResponse(window, 'onpopstate', afterFunction);
 }
 
 /**
  * TestFixture for OptionsPage WebUI testing.
  * @extends {testing.Test}
  * @constructor
  */
@@ skipping 99 matching lines @@
   assertNotEquals(defaultZoomFactor, null);
 
   // Verify that the zoom factor element has a reasonable number of choices.
   expectGE(defaultZoomFactor.options.length, defaultZoomFactorMinimumLength);
 
   // Simulate a change event, selecting the highest zoom value.  Verify that
   // the javascript handler was invoked once.
   this.mockHandler.expects(once()).defaultZoomFactorAction(NOT_NULL).
       will(callFunction(function() { }));
   defaultZoomFactor.selectedIndex = defaultZoomFactor.options.length - 1;
-  var event = { target: defaultZoomFactor };
+  var event = {target: defaultZoomFactor};
   if (defaultZoomFactor.onchange) defaultZoomFactor.onchange(event);
   testDone();
 });
 
-// If |confirmInterstitial| is true, the OK button of the Do Not Track
-// interstitial is pressed, otherwise the abort button is pressed.
+/**
+ * If |confirmInterstitial| is true, the OK button of the Do Not Track
+ * interstitial is pressed, otherwise the abort button is pressed.
+ * @param {boolean} confirmInterstitial Whether to confirm the Do Not Track
+ *     interstitial.
+ */
 OptionsWebUITest.prototype.testDoNotTrackInterstitial =
     function(confirmInterstitial) {
-  Preferences.prefsFetchedCallback({'enable_do_not_track': {'value': false } });
-  var buttonToClick = confirmInterstitial ? $('do-not-track-confirm-ok')
-                                          : $('do-not-track-confirm-cancel');
+  Preferences.prefsFetchedCallback({'enable_do_not_track': {'value': false}});
+  var buttonToClick = confirmInterstitial ? $('do-not-track-confirm-ok') :
+                                            $('do-not-track-confirm-cancel');
   var dntCheckbox = $('do-not-track-enabled');
   var dntOverlay = OptionsPage.registeredOverlayPages['donottrackconfirm'];
   assertFalse(dntCheckbox.checked);
 
   var visibleChangeCounter = 0;
   var visibleChangeHandler = function() {
     ++visibleChangeCounter;
     switch (visibleChangeCounter) {
       case 1:
         window.setTimeout(function() {
           assertTrue(dntOverlay.visible);
           buttonToClick.click();
         }, 0);
         break;
       case 2:
         window.setTimeout(function() {
           assertFalse(dntOverlay.visible);
           assertEquals(confirmInterstitial, dntCheckbox.checked);
           dntOverlay.removeEventListener(visibleChangeHandler);
           testDone();
         }, 0);
         break;
       default:
         assertTrue(false);
     }
-  }
+  };
   dntOverlay.addEventListener('visibleChange', visibleChangeHandler);
 
   if (confirmInterstitial) {
     this.mockHandler.expects(once()).setBooleanPref(
         ['enable_do_not_track', true, 'Options_DoNotTrackCheckbox']);
   } else {
     // The mock handler complains if setBooleanPref is called even though
     // it should not be.
   }
 
   dntCheckbox.click();
-}
+};
 
 TEST_F('OptionsWebUITest', 'EnableDoNotTrackAndConfirmInterstitial',
        function() {
   this.testDoNotTrackInterstitial(true);
 });
 
 TEST_F('OptionsWebUITest', 'EnableDoNotTrackAndCancelInterstitial',
        function() {
   this.testDoNotTrackInterstitial(false);
 });
 
 // Check that the "Do not Track" preference can be correctly disabled.
 // In order to do that, we need to enable it first.
 TEST_F('OptionsWebUITest', 'EnableAndDisableDoNotTrack', function() {
-  Preferences.prefsFetchedCallback({'enable_do_not_track': {'value': false } });
+  Preferences.prefsFetchedCallback({'enable_do_not_track': {'value': false}});
   var dntCheckbox = $('do-not-track-enabled');
-  var dntOverlay = OptionsPage.registeredOverlayPages['donottrackconfirm'];
+  var dntOverlay = OptionsPage.registeredOverlayPages.donottrackconfirm;
   assertFalse(dntCheckbox.checked);
 
   var visibleChangeCounter = 0;
   var visibleChangeHandler = function() {
     ++visibleChangeCounter;
     switch (visibleChangeCounter) {
       case 1:
         window.setTimeout(function() {
           assertTrue(dntOverlay.visible);
           $('do-not-track-confirm-ok').click();
         }, 0);
         break;
       case 2:
         window.setTimeout(function() {
           assertFalse(dntOverlay.visible);
           assertTrue(dntCheckbox.checked);
           dntOverlay.removeEventListener(visibleChangeHandler);
           dntCheckbox.click();
         }, 0);
         break;
       default:
         assertNotReached();
     }
   }
   dntOverlay.addEventListener('visibleChange', visibleChangeHandler);
 
   this.mockHandler.expects(once()).setBooleanPref(
-      eq(["enable_do_not_track", true, 'Options_DoNotTrackCheckbox']));
+      eq(['enable_do_not_track', true, 'Options_DoNotTrackCheckbox']));
 
   var verifyCorrectEndState = function() {
     window.setTimeout(function() {
       assertFalse(dntOverlay.visible);
       assertFalse(dntCheckbox.checked);
       testDone();
-    }, 0)
+    }, 0);
   }
   this.mockHandler.expects(once()).setBooleanPref(
-      eq(["enable_do_not_track", false, 'Options_DoNotTrackCheckbox'])).will(
+      eq(['enable_do_not_track', false, 'Options_DoNotTrackCheckbox'])).will(
           callFunction(verifyCorrectEndState));
 
   dntCheckbox.click();
 });
 
 // Verify that preventDefault() is called on 'Enter' keydown events that trigger
 // the default button. If this doesn't happen, other elements that may get
 // focus (by the overlay closing for instance), will execute in addition to the
 // default button. See crbug.com/268336.
 TEST_F('OptionsWebUITest', 'EnterPreventsDefault', function() {
@@ skipping 64 matching lines @@
 
   testGenPreamble: function() {
     // Start with no supervised users managed by this profile.
     GEN('  ClearPref("' + MANAGED_USERS_PREF + '");');
   },
 
   /** @override */
   isAsync: true,
 
   /** @override */
-  setUp: function () {
+  setUp: function() {
       // user-image-stream is a streaming video element used for capturing a
       // user image during OOBE.
       this.accessibilityAuditConfig.ignoreSelectors('videoWithoutCaptions',
                                                     '.user-image-stream');
   },
 
   /**
    * Asserts that two non-nested arrays are equal. The arrays must contain only
    * plain data types, no nested arrays or other objects.
    * @param {Array} expected An array of expected values.
@@ skipping 102 matching lines @@
   prohibitChangesToOverlay_: function(overlay) {
     overlay.initializePage =
         overlay.didShowPage =
         overlay.didClosePage = function() {
           assertTrue(false,
                      'Overlay was affected when changes were prohibited.');
         };
   },
 };
 
-/*
+/**
  * Set by verifyHistory_ to incorporate a followup callback, then called by the
  * C++ fixture with the navigation history to be verified.
  * @type {Function}
  */
 OptionsWebUIExtendedTest.verifyHistoryCallback = null;
 
 // Show the search page with no query string, to fall back to the settings page.
 // Test disabled because it's flaky. crbug.com/303841
 TEST_F('OptionsWebUIExtendedTest', 'DISABLED_ShowSearchPageNoQuery',
        function() {
@@ skipping 280 matching lines @@
   chrome.send('optionsTestSetPref', [MANAGED_USERS_PREF, {key: 'value'}]);
   waitForResponse(BrowserOptions, 'updateManagesSupervisedUsers', function() {
     assertFalse($('profiles-supervised-dashboard-tip').hidden);
     chrome.send('optionsTestSetPref', [MANAGED_USERS_PREF, {}]);
     waitForResponse(BrowserOptions, 'updateManagesSupervisedUsers', function() {
       assertTrue($('profiles-supervised-dashboard-tip').hidden);
       testDone();
     });
   });
 });