OOP PDF: Allow print preview to handle key events when the plugin has focus

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.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
+  };
+}
+
+/**
  * 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.
  */
 function PDFScriptingAPI(window, plugin) {
   this.loaded_ = false;
   this.pendingScriptingMessages_ = [];
   this.setPlugin(plugin);
 
@@ skipping 22 matching lines @@
           this.accessibilityCallback_(event.data.json);
           this.accessibilityCallback_ = null;
         }
         break;
       case 'getSelectedTextReply':
         if (this.selectedTextCallback_) {
           this.selectedTextCallback_(event.data.selectedText);
           this.selectedTextCallback_ = null;
         }
         break;
+      case 'sendKeyEvent':
+        if (this.keyEventCallback_)
+          this.keyEventCallback_(DeserializeKeyEvent(event.data.keyEvent));
+        break;
     }
   }.bind(this), false);
 }
 
 PDFScriptingAPI.prototype = {
   /**
    * @private
    * Send a message to the extension. If messages try to get sent before there
    * is a plugin element set, then we queue them up and send them later (this
    * can happen in print preview).
@@ skipping 39 matching lines @@
    * loading. If the document is already loaded, it will be run immediately.
    * @param {Function} callback the callback to be called.
    */
   setLoadCallback: function(callback) {
     this.loadCallback_ = callback;
     if (this.loaded_ && this.loadCallback_)
       this.loadCallback_();
   },
 
   /**
+   * Sets a callback that gets run when a key event is fired in the PDF viewer.
+   * @param {Function} callback the callback to be called with a key event.
+   */
+  setKeyEventCallback: function(callback) {
+    this.keyEventCallback_ = callback;
+  },
+
+  /**
    * Resets the PDF viewer into print preview mode.
    * @param {string} url the url of the PDF to load.
    * @param {boolean} grayscale whether or not to display the PDF in grayscale.
    * @param {Array.<number>} pageNumbers an array of the page numbers.
    * @param {boolean} modifiable whether or not the document is modifiable.
    */
   resetPrintPreviewMode: function(url, grayscale, pageNumbers, modifiable) {
     this.loaded_ = false;
     this.sendMessage_({
       type: 'resetPrintPreviewMode',
@@ skipping 72 matching lines @@
    * Print the document. May only be called after document load.
    */
   print: function() {
     this.sendMessage_({
       type: 'print'
     });
   },
 
   /**
    * Send a key event to the extension.
-   * @param {number} keyCode the key code to send to the extension.
+   * @param {Event} keyEvent the key event to send to the extension.
    */
-  sendKeyEvent: function(keyCode) {
+  sendKeyEvent: function(keyEvent) {
     this.sendMessage_({
       type: 'sendKeyEvent',
-      keyCode: keyCode
+      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 iframe = window.document.createElement('iframe');
   iframe.setAttribute(
       'src',
       'chrome-extension://mhjfbmdgcfjbbpaeojofohoefgiehjai/index.html?' + src);
   var client = new PDFScriptingAPI(window);
   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;
 }