Modify pdf_scripting_api.js to support postMessage using BrowserPlugin

chrome/browser/resources/pdf/pdf.js

 // Copyright 2013 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.
 
 'use strict';
 
 /**
  * @return {number} Width of a scrollbar in pixels
  */
 function getScrollbarWidth() {
@@ skipping 25 matching lines @@
  */
 PDFViewer.MIN_TOOLBAR_OFFSET = 15;
 
 /**
  * Creates a new PDFViewer. There should only be one of these objects per
  * document.
  * @param {Object} streamDetails The stream object which points to the data
  *     contained in the PDF.
  */
 function PDFViewer(streamDetails) {
-  this.streamDetails = streamDetails;
-  this.loaded = false;
+  this.streamDetails_ = streamDetails;
+  this.loaded_ = false;
+  this.parentWindow_ = null;
 
   // The sizer element is placed behind the plugin element to cause scrollbars
   // to be displayed in the window. It is sized according to the document size
   // of the pdf and zoom level.
   this.sizer_ = $('sizer');
   this.toolbar_ = $('toolbar');
   this.pageIndicator_ = $('page-indicator');
   this.progressBar_ = $('progress-bar');
   this.passwordScreen_ = $('password-screen');
   this.passwordScreen_.addEventListener('password-submitted',
@@ skipping 15 matching lines @@
   // NOTE: The plugin's 'id' field must be set to 'plugin' since
   // chrome/renderer/printing/print_web_view_helper.cc actually references it.
   this.plugin_.id = 'plugin';
   this.plugin_.type = 'application/x-google-chrome-pdf';
   this.plugin_.addEventListener('message', this.handlePluginMessage_.bind(this),
                                 false);
 
   // Handle scripting messages from outside the extension that wish to interact
   // with it. We also send a message indicating that extension has loaded and
   // is ready to receive messages.
-  window.addEventListener('message', this.handleScriptingMessage_.bind(this),
+  window.addEventListener('message', this.handleScriptingMessage.bind(this),
                           false);
-  this.sendScriptingMessage_({type: 'readyToReceive'});
 
-  document.title = getFilenameFromURL(this.streamDetails.originalUrl);
-  this.plugin_.setAttribute('src', this.streamDetails.originalUrl);
-  this.plugin_.setAttribute('stream-url', this.streamDetails.streamUrl);
+  document.title = getFilenameFromURL(this.streamDetails_.originalUrl);
+  this.plugin_.setAttribute('src', this.streamDetails_.originalUrl);
+  this.plugin_.setAttribute('stream-url', this.streamDetails_.streamUrl);
   var headers = '';
-  for (var header in this.streamDetails.responseHeaders) {
+  for (var header in this.streamDetails_.responseHeaders) {
     headers += header + ': ' +
-        this.streamDetails.responseHeaders[header] + '\n';
+        this.streamDetails_.responseHeaders[header] + '\n';
   }
   this.plugin_.setAttribute('headers', headers);
 
-  if (!this.streamDetails.embedded)
+  if (!this.streamDetails_.embedded)
     this.plugin_.setAttribute('full-frame', '');
   document.body.appendChild(this.plugin_);
 
-  // TODO(raymes): Remove this spurious message once crbug.com/388606 is fixed.
-  // This is a hack to initialize pepper sync scripting and avoid re-entrancy.
-  this.plugin_.postMessage({
-    type: 'viewport',
-    zoom: 1,
-    xOffset: 0,
-    yOffset: 0
-  });
-
   // Setup the button event listeners.
   $('fit-to-width-button').addEventListener('click',
       this.viewport_.fitToWidth.bind(this.viewport_));
   $('fit-to-page-button').addEventListener('click',
       this.viewport_.fitToPage.bind(this.viewport_));
   $('zoom-in-button').addEventListener('click',
       this.viewport_.zoomIn.bind(this.viewport_));
   $('zoom-out-button').addEventListener('click',
       this.viewport_.zoomOut.bind(this.viewport_));
   $('save-button').addEventListener('click', this.save_.bind(this));
   $('print-button').addEventListener('click', this.print_.bind(this));
 
   // Setup the keyboard event listener.
   document.onkeydown = this.handleKeyEvent_.bind(this);
 
   // Set up the zoom API.
   if (this.shouldManageZoom_()) {
-    chrome.tabs.setZoomSettings(this.streamDetails.tabId,
+    chrome.tabs.setZoomSettings(this.streamDetails_.tabId,
                                 {mode: 'manual', scope: 'per-tab'},
                                 this.afterZoom_.bind(this));
     chrome.tabs.onZoomChange.addListener(function(zoomChangeInfo) {
-      if (zoomChangeInfo.tabId != this.streamDetails.tabId)
+      if (zoomChangeInfo.tabId != this.streamDetails_.tabId)
         return;
       // If the zoom level is close enough to the current zoom level, don't
       // change it. This avoids us getting into an infinite loop of zoom changes
       // due to floating point error.
       var MIN_ZOOM_DELTA = 0.01;
       var zoomDelta = Math.abs(this.viewport_.zoom -
                                zoomChangeInfo.newZoomFactor);
       // We should not change zoom level when we are responsible for initiating
       // the zoom. onZoomChange() is called before setZoomComplete() callback
       // when we initiate the zoom.
       if ((zoomDelta > MIN_ZOOM_DELTA) && !this.setZoomInProgress_)
         this.viewport_.setZoom(zoomChangeInfo.newZoomFactor);
     }.bind(this));
   }
 
   // Parse open pdf parameters.
-  var paramsParser = new OpenPDFParamsParser(this.streamDetails.originalUrl);
+  var paramsParser = new OpenPDFParamsParser(this.streamDetails_.originalUrl);
   this.urlParams_ = paramsParser.urlParams;
 }
 
 PDFViewer.prototype = {
   /**
    * @private
    * Handle key events. These may come from the user directly or via the
    * scripting API.
    * @param {KeyboardEvent} e the event to handle.
    */
@@ skipping 162 matching lines @@
       this.toolbar_.style.visibility = 'hidden';
       if (this.passwordScreen_.active) {
         this.passwordScreen_.deny();
         this.passwordScreen_.active = false;
       }
     } else if (progress == 100) {
       // Document load complete.
       if (this.lastViewportPosition_)
         this.viewport_.position = this.lastViewportPosition_;
       this.handleURLParams_();
-      this.loaded = true;
-      var loadEvent = new Event('pdfload');
-      window.dispatchEvent(loadEvent);
+      this.loaded_ = true;
       this.sendScriptingMessage_({
         type: 'documentLoaded'
       });
     }
   },
 
   /**
    * @private
    * An event handler for handling password-submitted events. These are fired
    * when an event is entered into the password screen.
@@ skipping 65 matching lines @@
           position.y = message.data.y;
         this.viewport_.position = position;
         break;
       case 'setTranslatedStrings':
         this.passwordScreen_.text = message.data.getPasswordString;
         this.progressBar_.text = message.data.loadingString;
         this.progressBar_.style.visibility = 'visible';
         this.errorScreen_.text = message.data.loadFailedString;
         break;
       case 'cancelStreamUrl':
-        chrome.streamsPrivate.abort(this.streamDetails.streamUrl);
+        chrome.streamsPrivate.abort(this.streamDetails_.streamUrl);
         break;
     }
   },
 
   /**
    * @private
    * A callback that's called before the zoom changes. Notify the plugin to stop
    * reacting to scroll events while zoom is taking place to avoid flickering.
    */
   beforeZoom_: function() {
     this.plugin_.postMessage({
       type: 'stopScrolling'
     });
   },
 
   /**
    * @private
    * A callback that's called after the zoom changes. Notify the plugin of the
    * zoom change and to continue reacting to scroll events.
    */
   afterZoom_: function() {
     var position = this.viewport_.position;
     var zoom = this.viewport_.zoom;
     if (this.shouldManageZoom_() && !this.setZoomInProgress_) {
       this.setZoomInProgress_ = true;
-      chrome.tabs.setZoom(this.streamDetails.tabId, zoom,
+      chrome.tabs.setZoom(this.streamDetails_.tabId, zoom,
                           this.setZoomComplete_.bind(this, zoom));
     }
     this.plugin_.postMessage({
       type: 'viewport',
       zoom: zoom,
       xOffset: position.x,
       yOffset: position.y
     });
   },
 
   /**
    * @private
    * A callback that's called after chrome.tabs.setZoom is complete. This will
    * call chrome.tabs.setZoom again if the zoom level has changed since it was
    * last called.
    * @param {number} lastZoom the zoom level that chrome.tabs.setZoom was called
    *     with.
    */
   setZoomComplete_: function(lastZoom) {
     var zoom = this.viewport_.zoom;
     if (zoom != lastZoom) {
-      chrome.tabs.setZoom(this.streamDetails.tabId, zoom,
+      chrome.tabs.setZoom(this.streamDetails_.tabId, zoom,
                           this.setZoomComplete_.bind(this, zoom));
     } else {
       this.setZoomInProgress_ = false;
     }
   },
 
   /**
    * @private
    * A callback that's called after the viewport changes.
    */
@@ skipping 50 matching lines @@
     });
   },
 
   /**
    * @private
    * Handle a scripting message from outside the extension (typically sent by
    * PDFScriptingAPI in a page containing the extension) to interact with the
    * plugin.
    * @param {MessageObject} message the message to handle.
    */
-  handleScriptingMessage_: function(message) {
+  handleScriptingMessage: function(message) {
     switch (message.data.type.toString()) {
       case 'getAccessibilityJSON':
       case 'loadPreviewPage':
         this.plugin_.postMessage(message.data);
         break;
       case 'resetPrintPreviewMode':
         if (!this.inPrintPreviewMode_) {
           this.inPrintPreviewMode_ = true;
           this.viewport_.fitToPage();
         }
@@ skipping 21 matching lines @@
           pageCount: (message.data.modifiable ?
                       message.data.pageNumbers.length : 0)
         });
         break;
       case 'sendKeyEvent':
         var e = document.createEvent('Event');
         e.initEvent('scriptingKeypress');
         e.keyCode = message.data.keyCode;
         this.handleKeyEvent_(e);
         break;
+      case 'setParentWindow':
+        if (this.parentWindow_ != message.source) {
+          this.parentWindow_ = message.source;
+          // If the document has already loaded, we always send a message that
+          // indicates that so that the embedder is aware.
+          if (this.loaded_) {
+            this.sendScriptingMessage_({
+              type: 'documentLoaded'
+            });
+          }
+        }
+        break;
     }
-
   },
 
   /**
    * @private
    * Send a scripting message outside the extension (typically to
    * PDFScriptingAPI in a page containing the extension).
    * @param {Object} message the message to send.
    */
   sendScriptingMessage_: function(message) {
-    window.parent.postMessage(message, '*');
+    if (this.parentWindow_)
+      this.parentWindow_.postMessage(message, '*');
   },
 
   /**
    * @private
    * Return whether this PDFViewer should manage zoom for its containing page.
    * @return {boolean} Whether this PDFViewer should manage zoom for its
    *     containing page.
    */
   shouldManageZoom_: function() {
-    return !!(chrome.tabs && !this.streamDetails.embedded &&
-              this.streamDetails.tabId != -1);
+    return !!(chrome.tabs && !this.streamDetails_.embedded &&
+              this.streamDetails_.tabId != -1);
   },
 
   /**
    * @type {Viewport} the viewport of the PDF viewer.
    */
   get viewport() {
     return this.viewport_;
   }
 };