Run tools/clang-format-js on some of chrome/browser/resources/

chrome/browser/resources/gaia_auth_host/post_message_channel.js

 // Copyright 2015 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.
 
 /**
  * @fileoverview
  * Provides a HTML5 postMessage channel to the injected JS to talk back
  * to Authenticator.
  */
 'use strict';
 
-<include src="../gaia_auth/channel.js">
+// <include src="../gaia_auth/channel.js">
 
 var PostMessageChannel = (function() {
   /**
    * Allowed origins of the hosting page.
    * @type {Array<string>}
    */
-  var ALLOWED_ORIGINS = [
-    'chrome://oobe',
-    'chrome://chrome-signin'
-  ];
+  var ALLOWED_ORIGINS = ['chrome://oobe', 'chrome://chrome-signin'];
 
   /** @const */
   var PORT_MESSAGE = 'post-message-port-message';
 
   /** @const */
   var CHANNEL_INIT_MESSAGE = 'post-message-channel-init';
 
   /** @const */
   var CHANNEL_CONNECT_MESSAGE = 'post-message-channel-connect';
 
@@ skipping 109 matching lines @@
         port.setTarget(opt_targetWindow, opt_targetOrigin);
       this.channels_[channelId] = port;
       return port;
     },
 
     /*
      * Returns a message forward handler for the given proxy port.
      * @private
      */
     getProxyPortForwardHandler_: function(proxyPort) {
-      return function(msg) { proxyPort.postMessage(msg); };
+      return function(msg) {
+        proxyPort.postMessage(msg);
+      };
     },
 
     /**
      * Creates a forwarding porxy port.
      * @param {number} channelId
      * @param {string} channelName
      * @param {!DOMWindow} targetWindow
      * @param {!string} targetOrigin
      */
     createProxyPort: function(
         channelId, channelName, targetWindow, targetOrigin) {
-      var port = this.createPort(
-          channelId, channelName, targetWindow, targetOrigin);
+      var port =
+          this.createPort(channelId, channelName, targetWindow, targetOrigin);
       port.onMessage.addListener(this.getProxyPortForwardHandler_(port));
       return port;
     },
 
     /**
      * Creates a connecting port to the daemon and request connection.
      * @param {string} name
      * @return {PostMessagePort}
      */
     connectToDaemon: function(name) {
@@ skipping 30 matching lines @@
         return;
       }
 
       port.handleWindowMessage(e);
     },
 
     /**
      * Window 'message' handler.
      */
     onMessage_: function(e) {
-      if (typeof e.data != 'object' ||
-          !e.data.hasOwnProperty('type')) {
+      if (typeof e.data != 'object' || !e.data.hasOwnProperty('type')) {
         return;
       }
 
       if (e.data.type === PORT_MESSAGE) {
         // Dispatch port message to ports if this is the daemon page or
         // the message is from upperWindow. In case of null upperWindow,
         // the message is assumed to be forwarded to upperWindow and queued.
         if (this.isDaemon ||
             (this.upperWindow && e.source === this.upperWindow)) {
           this.dispatchMessageToPort_(e);
         } else {
           this.postToUpperWindow(e.data);
         }
       } else if (e.data.type === CHANNEL_CONNECT_MESSAGE) {
         var channelId = e.data.channelId;
         var channelName = e.data.channelName;
 
         if (this.isDaemon) {
-          var port = this.createPort(
-              channelId, channelName, e.source, e.origin);
+          var port =
+              this.createPort(channelId, channelName, e.source, e.origin);
           this.onConnect.dispatch(port);
         } else {
           this.createProxyPort(channelId, channelName, e.source, e.origin);
           this.postToUpperWindow(e.data);
         }
       } else if (e.data.type === CHANNEL_INIT_MESSAGE) {
         if (ALLOWED_ORIGINS.indexOf(e.origin) == -1)
           return;
 
         this.upperWindow = e.source;
         this.upperOrigin = e.origin;
 
         for (var i = 0; i < this.deferredUpperWindowMessages_.length; ++i) {
-          this.upperWindow.postMessage(this.deferredUpperWindowMessages_[i],
-                                       this.upperOrigin);
+          this.upperWindow.postMessage(
+              this.deferredUpperWindowMessages_[i], this.upperOrigin);
         }
         this.deferredUpperWindowMessages_ = [];
 
         for (var i = 0; i < this.deferredUpperWindowPorts_.length; ++i) {
-          this.deferredUpperWindowPorts_[i].setTarget(this.upperWindow,
-                                                      this.upperOrigin);
+          this.deferredUpperWindowPorts_[i].setTarget(
+              this.upperWindow, this.upperOrigin);
         }
         this.deferredUpperWindowPorts_ = [];
       }
     }
   };
 
   /**
    * Singleton instance of ChannelManager.
    * @type {ChannelManager}
    */
@@ skipping 30 matching lines @@
       }
       this.deferredMessages_ = [];
     },
 
     postMessage: function(msg) {
       if (!this.targetWindow) {
         this.deferredMessages_.push(msg);
         return;
       }
 
-      this.targetWindow.postMessage({
-        type: PORT_MESSAGE,
-        channelId: this.channelId,
-        payload: msg
-      }, this.targetOrigin);
+      this.targetWindow.postMessage(
+          {type: PORT_MESSAGE, channelId: this.channelId, payload: msg},
+          this.targetOrigin);
     },
 
     handleWindowMessage: function(e) {
       this.onMessage.dispatch(e.data.payload);
     }
   };
 
   /**
    * A message channel based on PostMessagePort.
    * @extends {Channel}
@@ skipping 11 matching lines @@
       this.port_ = channelManager.connectToDaemon(name);
       this.port_.onMessage.addListener(this.onMessage_.bind(this));
     },
   };
 
   /**
    * Initialize webview content window for postMessage channel.
    * @param {DOMWindow} webViewContentWindow Content window of the webview.
    */
   PostMessageChannel.init = function(webViewContentWindow) {
-    webViewContentWindow.postMessage({
-      type: CHANNEL_INIT_MESSAGE
-    }, '*');
+    webViewContentWindow.postMessage({type: CHANNEL_INIT_MESSAGE}, '*');
   };
 
   /**
    * Run in daemon mode and listen for incoming connections. Note that the
    * current implementation assumes the daemon runs in the hosting page
    * at the upper layer of the DOM tree. That is, all connect requests go
    * up the DOM tree instead of going into sub frames.
    * @param {function(PostMessagePort)} callback Invoked when a connection is
    *     made.
    */
   PostMessageChannel.runAsDaemon = function(callback) {
     channelManager.isDaemon = true;
 
     var onConnect = function(port) {
       callback(port);
     };
     channelManager.onConnect.addListener(onConnect);
   };
 
   return PostMessageChannel;
 })();
 
 /** @override */
 Channel.create = function() {
   return new PostMessageChannel();
 };