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

chrome/browser/resources/pdf/pdf_scripting_api.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.
 
 /**
  * Turn a dictionary received from postMessage into a key event.
  * @param {Object} dict A dictionary representing the key event.
  * @return {Event} A key event.
  */
 function DeserializeKeyEvent(dict) {
@@ skipping 21 matching lines @@
     altKey: event.altKey,
     metaKey: event.metaKey
   };
 }
 
 /**
  * An enum containing a value specifying whether the PDF is currently loading,
  * has finished loading or failed to load.
  * @enum {string}
  */
-var LoadState = {
-  LOADING: 'loading',
-  SUCCESS: 'success',
-  FAILED: 'failed'
-};
+var LoadState = {LOADING: 'loading', SUCCESS: 'success', FAILED: 'failed'};
 
 /**
  * Create a new PDFScriptingAPI. This provides a scripting interface to
  * the PDF viewer so that it can be customized by things like print preview.
  * @param {Window} window the window of the page containing the pdf viewer.
  * @param {Object} plugin the plugin element containing the pdf viewer.
  * @constructor
  */
 function PDFScriptingAPI(window, plugin) {
   this.loadState_ = LoadState.LOADING;
   this.pendingScriptingMessages_ = [];
   this.setPlugin(plugin);
 
   window.addEventListener('message', function(event) {
     if (event.origin != 'chrome-extension://mhjfbmdgcfjbbpaeojofohoefgiehjai' &&
         event.origin != 'chrome://print') {
-      console.error('Received message that was not from the extension: ' +
-                    event);
+      console.error(
+          'Received message that was not from the extension: ' + event);
       return;
     }
     switch (event.data.type) {
       case 'viewport':
         /**
          * @type {{
          *   pageX: number,
          *   pageY: number,
          *   pageWidth: number,
          *   viewportWidth: number,
          *   viewportHeight: number
          * }}
          */
         var viewportData = event.data;
         if (this.viewportChangedCallback_)
-          this.viewportChangedCallback_(viewportData.pageX,
-                                        viewportData.pageY,
-                                        viewportData.pageWidth,
-                                        viewportData.viewportWidth,
-                                        viewportData.viewportHeight);
+          this.viewportChangedCallback_(
+              viewportData.pageX, viewportData.pageY, viewportData.pageWidth,
+              viewportData.viewportWidth, viewportData.viewportHeight);
         break;
       case 'documentLoaded':
         var data = /** @type {{load_state: LoadState}} */ (event.data);
         this.loadState_ = data.load_state;
         if (this.loadCallback_)
           this.loadCallback_(this.loadState_ == LoadState.SUCCESS);
         break;
       case 'getSelectedTextReply':
         var data = /** @type {{selectedText: string}} */ (event.data);
         if (this.selectedTextCallback_) {
@@ skipping 17 matching lines @@
    * can happen in print preview).
    * @param {Object} message The message to send.
    */
   sendMessage_: function(message) {
     if (this.plugin_)
       this.plugin_.postMessage(message, '*');
     else
       this.pendingScriptingMessages_.push(message);
   },
 
- /**
-  * Sets the plugin element containing the PDF viewer. The element will usually
-  * be passed into the PDFScriptingAPI constructor but may also be set later.
-  * @param {Object} plugin the plugin element containing the PDF viewer.
-  */
+  /**
+   * Sets the plugin element containing the PDF viewer. The element will usually
+   * be passed into the PDFScriptingAPI constructor but may also be set later.
+   * @param {Object} plugin the plugin element containing the PDF viewer.
+   */
   setPlugin: function(plugin) {
     this.plugin_ = plugin;
 
     if (this.plugin_) {
       // Send a message to ensure the postMessage channel is initialized which
       // allows us to receive messages.
-      this.sendMessage_({
-        type: 'initialize'
-      });
+      this.sendMessage_({type: 'initialize'});
       // Flush pending messages.
       while (this.pendingScriptingMessages_.length > 0)
         this.sendMessage_(this.pendingScriptingMessages_.shift());
     }
   },
 
   /**
    * Sets the callback which will be run when the PDF viewport changes.
    * @param {Function} callback the callback to be called.
    */
@@ skipping 37 matching lines @@
       modifiable: modifiable
     });
   },
 
   /**
    * Load a page into the document while in print preview mode.
    * @param {string} url the url of the pdf page to load.
    * @param {number} index the index of the page to load.
    */
   loadPreviewPage: function(url, index) {
-    this.sendMessage_({
-      type: 'loadPreviewPage',
-      url: url,
-      index: index
-    });
+    this.sendMessage_({type: 'loadPreviewPage', url: url, index: index});
   },
 
   /**
    * Select all the text in the document. May only be called after document
    * load.
    */
   selectAll: function() {
-    this.sendMessage_({
-      type: 'selectAll'
-    });
+    this.sendMessage_({type: 'selectAll'});
   },
 
   /**
    * Get the selected text in the document. The callback will be called with the
    * text that is selected. May only be called after document load.
    * @param {Function} callback a callback to be called with the selected text.
    * @return {boolean} true if the function is successful, false if there is an
    *     outstanding request for selected text that has not been answered.
    */
   getSelectedText: function(callback) {
     if (this.selectedTextCallback_)
       return false;
     this.selectedTextCallback_ = callback;
-    this.sendMessage_({
-      type: 'getSelectedText'
-    });
+    this.sendMessage_({type: 'getSelectedText'});
     return true;
   },
 
   /**
    * Print the document. May only be called after document load.
    */
   print: function() {
-    this.sendMessage_({
-      type: 'print'
-    });
+    this.sendMessage_({type: 'print'});
   },
 
   /**
    * Send a key event to the extension.
    * @param {Event} keyEvent the key event to send to the extension.
    */
   sendKeyEvent: function(keyEvent) {
-    this.sendMessage_({
-      type: 'sendKeyEvent',
-      keyEvent: SerializeKeyEvent(keyEvent)
-    });
+    this.sendMessage_(
+        {type: 'sendKeyEvent', keyEvent: SerializeKeyEvent(keyEvent)});
   },
 };
 
 /**
  * Creates a PDF viewer with a scripting interface. This is basically 1) an
  * iframe which is navigated to the PDF viewer extension and 2) a scripting
  * interface which provides access to various features of the viewer for use
  * by print preview and accessibility.
  * @param {string} src the source URL of the PDF to load initially.
  * @return {HTMLIFrameElement} the iframe element containing the PDF viewer.
  */
 function PDFCreateOutOfProcessPlugin(src) {
   var client = new PDFScriptingAPI(window, null);
-  var iframe = assertInstanceof(window.document.createElement('iframe'),
-                                HTMLIFrameElement);
+  var iframe = assertInstanceof(
+      window.document.createElement('iframe'), HTMLIFrameElement);
   iframe.setAttribute('src', 'pdf_preview.html?' + src);
   // Prevent the frame from being tab-focusable.
   iframe.setAttribute('tabindex', '-1');
 
   iframe.onload = function() {
     client.setPlugin(iframe.contentWindow);
   };
 
   // Add the functions to the iframe so that they can be called directly.
   iframe.setViewportChangedCallback =
       client.setViewportChangedCallback.bind(client);
   iframe.setLoadCallback = client.setLoadCallback.bind(client);
   iframe.setKeyEventCallback = client.setKeyEventCallback.bind(client);
   iframe.resetPrintPreviewMode = client.resetPrintPreviewMode.bind(client);
   iframe.loadPreviewPage = client.loadPreviewPage.bind(client);
   iframe.sendKeyEvent = client.sendKeyEvent.bind(client);
   return iframe;
 }