Add accessibility function to PDFScriptingAPI

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.
 
 /**
  * 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 {string} extensionUrl the url of the PDF extension.
  */
 function PDFScriptingAPI(window, extensionUrl) {
   this.extensionUrl_ = extensionUrl;
-  this.readyToReceive = false;
   this.messageQueue_ = [];
   window.addEventListener('message', function(event) {
-    if (event.origin != this.extensionUrl_)
+    if (event.origin != this.extensionUrl_) {
+      console.error('Received message that was not from the extension: ' +
+                    event);
       return;
+    }
     switch (event.data.type) {
       case 'readyToReceive':
-        this.pdfWindow_ = event.source;
-        this.flushPendingMessages_();
+        this.setDestinationWindow(event.source);
         break;
       case 'viewport':
         if (this.viewportChangedCallback_)
           this.viewportChangedCallback_(event.data.pageX,
                                         event.data.pageY,
                                         event.data.pageWidth,
                                         event.data.viewportWidth,
                                         event.data.viewportHeight);
         break;
       case 'documentLoaded':
         if (this.loadCallback_)
           this.loadCallback_();
         break;
+      case 'getAccessibilityJSONReply':
+        if (this.accessibilityCallback_) {
+          this.accessibilityCallback_(event.data.json);
+          this.accessibilityCallback_ = null;
+        }
+        break;
     }
   }.bind(this), false);
 }
 
 PDFScriptingAPI.prototype = {
   /**
    * @private
    * Send a message to the extension. If we try to send messages prior to the
    * extension being ready to receive messages (i.e. before it has finished
    * loading) we queue up the messages and flush them later.
-   * @param {MessageObject} the message to send.
+   * @param {Object} the message to send.
    */
   sendMessage_: function(message) {
-    if (!this.readyToReceive) {
+    if (!this.pdfWindow_) {
       this.messageQueue_.push(message);
       return;
     }
 
     this.pdfWindow_.postMessage(message, this.extensionUrl_);
   },
 
   /**
-   * @private
-   * Flushes all pending messages to the extension.
+   * Sets the destination window containing the PDF viewer. This will be called
+   * when a 'readyToReceive' message is received from the PDF viewer or it can
+   * be called during tests. It then flushes any pending messages to the window.
+   * @param {Window} pdfWindow the window containing the PDF viewer.
    */
-  flushPendingMessages_: function() {
-    this.readyToReceive = true;
+  setDestinationWindow: function(pdfWindow) {
+    this.pdfWindow_ = pdfWindow;
     while (this.messageQueue_.length != 0) {
       this.pdfWindow_.postMessage(this.messageQueue_.shift(),
                                   this.extensionUrl_);
     }
   },
 
   /**
    * Sets the callback which will be run when the PDF viewport changes.
    * @param {Function} callback the callback to be called.
    */
@@ skipping 34 matching lines @@
    */
   loadPreviewPage: function(url, index) {
     this.sendMessage_({
       type: 'loadPreviewPage',
       url: url,
       index: index
     });
   },
 
   /**
+   * Get accessibility JSON for the document.
+   * @param {Function} callback a callback to be called with the accessibility
+   *     json that has been retrieved.
+   * @param {number} [page] the index of the page to get accessibility data for.

[Lei Zhang, 2014/05/08 06:42:53]

Is this 0 indexed or 1 indexed?

[raymes, 2014/05/09 06:19:45]

0 indexed.

+   *     If this is not provided, data about the entire document is returned.
+   * @return {boolean} true if the function is successful, false if there is an

[Lei Zhang, 2014/05/08 06:42:53]

Should we leave this as is, or queue up the requests and handle them?

Dominic may have an opinion on this.

[dmazzoni, 2014/05/08 13:33:56]

This should be fine, we can wait for the first page to return before requesting
the second.

+   *     outstanding request for accessibility data that has not been answered.
+   */
+  getAccessibilityJSON: function(callback, page) {
+    if (this.accessibilityCallback_)
+      return false;
+    this.accessibilityCallback_ = callback;
+    var message = {
+      type: 'getAccessibilityJSON',
+    };
+    if (page || page == 0)
+      message.page = page;
+    this.sendMessage_(message);
+    return true;
+  },
+
+  /**
    * Send a key event to the extension.
    * @param {number} keyCode the key code to send to the extension.
    */
   sendKeyEvent: function(keyCode) {
     // TODO(raymes): Figure out a way to do this. It's only used to do scrolling
     // the viewport, so probably just expose viewport controls instead.
   },
 };
 
 /**
@@ skipping 12 matching lines @@
 
   // 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.resetPrintPreviewMode = client.resetPrintPreviewMode.bind(client);
   iframe.loadPreviewPage = client.loadPreviewPage.bind(client);
   iframe.sendKeyEvent = client.sendKeyEvent.bind(client);
   return iframe;
 }