Run tools/clang-format-js on chrome/browser/resources/hotword/

chrome/browser/resources/hotword/page_audio_manager.js

 // Copyright 2014 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('hotword', function() {
   'use strict';
 
   /**
    * Class used to manage the interaction between hotwording and the
    * NTP/google.com. Injects a content script to interact with NTP/google.com
@@ skipping 44 matching lines @@
 
   PageAudioManager.prototype = {
     /**
      * Helper function to test if a URL path is eligible for hotwording.
      * @param {!string} url URL to check.
      * @param {!string} base Base URL to compare against..
      * @return {boolean} True if url is an eligible hotword URL.
      * @private
      */
     checkUrlPathIsEligible_: function(url, base) {
-      if (url == base ||
-          url == base + '/' ||
+      if (url == base || url == base + '/' ||
           url.startsWith(base + '/_/chrome/newtab?') ||  // Appcache NTP.
-          url.startsWith(base + '/?') ||
-          url.startsWith(base + '/#') ||
-          url.startsWith(base + '/webhp') ||
-          url.startsWith(base + '/search') ||
+          url.startsWith(base + '/?') || url.startsWith(base + '/#') ||
+          url.startsWith(base + '/webhp') || url.startsWith(base + '/search') ||
           url.startsWith(base + '/imghp')) {
         return true;
       }
       return false;
     },
 
     /**
      * Determines if a URL is eligible for hotwording. For now, the valid pages
      * are the Google HP and SERP (this will include the NTP).
      * @param {!string} url URL to check.
      * @return {boolean} True if url is an eligible hotword URL.
      * @private
      */
     isEligibleUrl_: function(url) {
       if (!url)
         return false;
 
       var baseGoogleUrls = [
-        'https://encrypted.google.',
-        'https://images.google.',
+        'https://encrypted.google.', 'https://images.google.',
         'https://www.google.'
       ];
       // TODO(amistry): Get this list from a file in the shared module instead.
       var tlds = [
-        'at',
-        'ca',
-        'com',
-        'com.au',
-        'com.mx',
-        'com.br',
-        'co.jp',
-        'co.kr',
-        'co.nz',
-        'co.uk',
-        'co.za',
-        'de',
-        'es',
-        'fr',
-        'it',
-        'ru'
+        'at', 'ca', 'com', 'com.au', 'com.mx', 'com.br', 'co.jp', 'co.kr',
+        'co.nz', 'co.uk', 'co.za', 'de', 'es', 'fr', 'it', 'ru'
       ];
 
       // Check for the new tab page first.
       if (this.checkUrlPathIsEligible_(url, 'chrome://newtab'))
         return true;
 
       // Check URLs with each type of local-based TLD.
       for (var i = 0; i < baseGoogleUrls.length; i++) {
         for (var j = 0; j < tlds.length; j++) {
           var base = baseGoogleUrls[i] + tlds[j];
           if (this.checkUrlPathIsEligible_(url, base))
             return true;
         }
       }
       return false;
     },
 
     /**
      * Locates the current active tab in the current focused window and
      * performs a callback with the tab as the parameter.
      * @param {function(?Tab)} callback Function to call with the
      *     active tab or null if not found. The function's |this| will be set to
      *     this object.
      * @private
      */
     findCurrentTab_: function(callback) {
-      chrome.windows.getAll(
-          {'populate': true},
-          function(windows) {
-            for (var i = 0; i < windows.length; ++i) {
-              if (!windows[i].focused)
-                continue;
+      chrome.windows.getAll({'populate': true}, function(windows) {
+        for (var i = 0; i < windows.length; ++i) {
+          if (!windows[i].focused)
+            continue;
 
-              for (var j = 0; j < windows[i].tabs.length; ++j) {
-                var tab = windows[i].tabs[j];
-                if (tab.active) {
-                  callback.call(this, tab);
-                  return;
-                }
-              }
+          for (var j = 0; j < windows[i].tabs.length; ++j) {
+            var tab = windows[i].tabs[j];
+            if (tab.active) {
+              callback.call(this, tab);
+              return;
             }
-            callback.call(this, null);
-          }.bind(this));
+          }
+        }
+        callback.call(this, null);
+      }.bind(this));
     },
 
     /**
      * This function is called when a tab is activated (comes into focus).
      * @param {Tab} tab Current active tab.
      * @private
      */
     activateTab_: function(tab) {
       if (!tab) {
         this.stopHotwording_();
@@ skipping 10 matching lines @@
     /**
      * Prepare a new or updated tab by injecting the content script.
      * @param {!Tab} tab Newly updated or created tab.
      * @private
      */
     prepareTab_: function(tab) {
       if (!this.isEligibleUrl_(tab.url))
         return;
 
       chrome.tabs.executeScript(
-          tab.id,
-          {'file': 'audio_client.js'},
-          function(results) {
+          tab.id, {'file': 'audio_client.js'}, function(results) {
             if (chrome.runtime.lastError) {
               // Ignore this error. For new tab pages, even though the URL is
               // reported to be chrome://newtab/, the actual URL is a
               // country-specific google domain. Since we don't have permission
               // to inject on every page, an error will happen when the user is
               // in an unsupported country.
               //
               // The property still needs to be accessed so that the error
               // condition is cleared. If it isn't, exectureScript will log an
               // error the next time it is called.
@@ skipping 69 matching lines @@
 
     /**
      * Handles a content script attempting to connect.
      * @param {!Port} port Communications port from the client.
      * @private
      */
     handleConnect_: function(port) {
       if (port.name != hotword.constants.CLIENT_PORT_NAME)
         return;
 
-      var tab = /** @type {!Tab} */(port.sender.tab);
+      var tab = /** @type {!Tab} */ (port.sender.tab);
       // An existing port from the same tab might already exist. But that port
       // may be from the previous page, so just overwrite the port.
       this.portMap_[tab.id] = port;
       port.onDisconnect.addListener(function() {
         this.handleClientDisconnect_(port);
       }.bind(this));
       port.onMessage.addListener(function(msg) {
         this.handleMessage_(msg, port.sender, port.postMessage);
       }.bind(this));
     },
@@ skipping 63 matching lines @@
           this.sendClient_(CommandToPage.HOTWORD_VOICE_TRIGGER, tab.id);
       });
     },
 
     /**
      * Starts hotwording.
      * @private
      */
     startHotwording_: function() {
       this.stateManager_.startSession(
-          hotword.constants.SessionSource.NTP,
-          function() {
+          hotword.constants.SessionSource.NTP, function() {
             this.sendAllClients_(CommandToPage.HOTWORD_STARTED);
-          }.bind(this),
-          this.hotwordTriggered_.bind(this));
+          }.bind(this), this.hotwordTriggered_.bind(this));
     },
 
     /**
      * Starts hotwording if the currently active tab is eligible for hotwording
      * (e.g. google.com).
      * @private
      */
     startHotwordingIfEligible_: function() {
       this.findCurrentTab_(function(tab) {
         if (!tab) {
@@ skipping 61 matching lines @@
      * @return {boolean} Whether to maintain the port open to call sendResponse.
      * @private
      */
     handleMessageFromPage_: function(request, sender, sendResponse) {
       switch (request.type) {
         case CommandFromPage.PAGE_WAKEUP:
           if (sender.tab && this.isEligibleUrl_(sender.tab.url)) {
             chrome.hotwordPrivate.getStatus(
                 true /* getOptionalFields */,
                 this.statusDone_.bind(
-                    this,
-                    request.tab || sender.tab || {incognito: true},
+                    this, request.tab || sender.tab || {incognito: true},
                     sendResponse));
             return true;
           }
 
           // Do not show the opt-in promo for ineligible urls.
           this.sendResponse_({'doNotShowOptinMessage': true}, sendResponse);
           break;
         case CommandFromPage.CLICKED_OPTIN:
           chrome.hotwordPrivate.setEnabled(true);
           break;
@@ skipping 61 matching lines @@
       chrome.runtime.onConnect.addListener(this.connectListener_);
       chrome.tabs.onCreated.addListener(this.tabCreatedListener_);
       chrome.tabs.onUpdated.addListener(this.tabUpdatedListener_);
       chrome.tabs.onActivated.addListener(this.tabActivatedListener_);
       chrome.windows.onFocusChanged.addListener(
           this.windowFocusChangedListener_);
       chrome.hotwordPrivate.onMicrophoneStateChanged.addListener(
           this.microphoneStateChangedListener_);
       if (chrome.runtime.onMessage.hasListener(this.messageListener_))
         return;
-      chrome.runtime.onMessageExternal.addListener(
-          this.messageListener_);
+      chrome.runtime.onMessageExternal.addListener(this.messageListener_);
     },
 
     /**
      * Remove event listeners.
      * @private
      */
     removeListeners_: function() {
       chrome.runtime.onConnect.removeListener(this.connectListener_);
       chrome.tabs.onCreated.removeListener(this.tabCreatedListener_);
       chrome.tabs.onUpdated.removeListener(this.tabUpdatedListener_);
@@ skipping 14 matching lines @@
       if (this.stateManager_.isSometimesOnEnabled()) {
         this.setupListeners_();
       } else {
         this.removeListeners_();
         this.stopHotwording_();
         this.disconnectAllClients_();
       }
     }
   };
 
-  return {
-    PageAudioManager: PageAudioManager
-  };
+  return {PageAudioManager: PageAudioManager};
 });