Fix all remaining print preview closure compiler errors

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) {
   var e = document.createEvent('Event');
-  e.initEvent('keydown');
+  e.initEvent('keydown', true, true);
   e.keyCode = dict.keyCode;
   e.shiftKey = dict.shiftKey;
   e.ctrlKey = dict.ctrlKey;
   e.altKey = dict.altKey;
   e.metaKey = dict.metaKey;
   e.fromScriptingAPI = true;
   return e;
 }
 
 /**
  * Turn a key event into a dictionary which can be sent over postMessage.
  * @param {Event} event A key event.
  * @return {Object} A dictionary representing the key event.
  */
 function SerializeKeyEvent(event) {
   return {
     keyCode: event.keyCode,
     shiftKey: event.shiftKey,
     ctrlKey: event.ctrlKey,
     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'
 };
 
 /**
  * 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);
       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_(event.data.pageX,
-                                        event.data.pageY,
-                                        event.data.pageWidth,
-                                        event.data.viewportWidth,
-                                        event.data.viewportHeight);
+          this.viewportChangedCallback_(viewportData.pageX,
+                                        viewportData.pageY,
+                                        viewportData.pageWidth,
+                                        viewportData.viewportWidth,
+                                        viewportData.viewportHeight);
         break;
       case 'documentLoaded':
-        this.loadState_ = event.data.load_state;
+        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_) {
-          this.selectedTextCallback_(event.data.selectedText);
+          this.selectedTextCallback_(data.selectedText);
           this.selectedTextCallback_ = null;
         }
         break;
       case 'sendKeyEvent':
         if (this.keyEventCallback_)
           this.keyEventCallback_(DeserializeKeyEvent(event.data.keyEvent));
         break;
     }
   }.bind(this), false);
 }
@@ skipping 141 matching lines @@
 
 /**
  * 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);
-  var iframe = window.document.createElement('iframe');
+  var client = new PDFScriptingAPI(window, null);
+  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;
 }