Add a scroll offset to PDF documents to account for the top material design toolbar.

chrome/browser/resources/pdf/viewport.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.
 
 /**
  * Returns the height of the intersection of two rectangles.
  * @param {Object} rect1 the first rect
  * @param {Object} rect2 the second rect
  * @return {number} the height of the intersection of the rects
  */
 function getIntersectionHeight(rect1, rect2) {
   return Math.max(0,
       Math.min(rect1.y + rect1.height, rect2.y + rect2.height) -
       Math.max(rect1.y, rect2.y));
 }
 
 /**
  * Create a new viewport.
  * @constructor
  * @param {Window} window the window
  * @param {Object} sizer is the element which represents the size of the
  *     document in the viewport
  * @param {Function} viewportChangedCallback is run when the viewport changes
  * @param {Function} beforeZoomCallback is run before a change in zoom
  * @param {Function} afterZoomCallback is run after a change in zoom
  * @param {number} scrollbarWidth the width of scrollbars on the page
  * @param {number} defaultZoom The default zoom level.
+ * @param {number} topToolbarHeight The number of pixels that should initially
+ *     be left blank above the document for the toolbar.
  */
 function Viewport(window,
                   sizer,
                   viewportChangedCallback,
                   beforeZoomCallback,
                   afterZoomCallback,
                   scrollbarWidth,
-                  defaultZoom) {
+                  defaultZoom,
+                  topToolbarHeight) {
   this.window_ = window;
   this.sizer_ = sizer;
   this.viewportChangedCallback_ = viewportChangedCallback;
   this.beforeZoomCallback_ = beforeZoomCallback;
   this.afterZoomCallback_ = afterZoomCallback;
   this.allowedToChangeZoom_ = false;
   this.zoom_ = 1;
   this.documentDimensions_ = null;
   this.pageDimensions_ = [];
   this.scrollbarWidth_ = scrollbarWidth;
   this.fittingType_ = Viewport.FittingType.NONE;
   this.defaultZoom_ = defaultZoom;
+  this.topToolbarHeight_ = topToolbarHeight;
 
   window.addEventListener('scroll', this.updateViewport_.bind(this));
   window.addEventListener('resize', this.resize_.bind(this));
 }
 
 /**
  * Enumeration of page fitting types.
  * @enum {string}
  */
 Viewport.FittingType = {
@@ skipping 74 matching lines @@
   },
 
   /**
    * @private
    * Helper function called when the zoomed document size changes.
    */
   contentSizeChanged_: function() {
     if (this.documentDimensions_) {
       this.sizer_.style.width =
           this.documentDimensions_.width * this.zoom_ + 'px';
-      this.sizer_.style.height =
-          this.documentDimensions_.height * this.zoom_ + 'px';
+      this.sizer_.style.height = this.documentDimensions_.height * this.zoom_ +
+          this.topToolbarHeight_ + 'px';
     }
   },
 
   /**
    * @private
    * Called when the viewport should be updated.
    */
   updateViewport_: function() {
     this.viewportChangedCallback_();
   },
@@ skipping 10 matching lines @@
     else
       this.updateViewport_();
   },
 
   /**
    * @type {Object} the scroll position of the viewport.
    */
   get position() {
     return {
       x: this.window_.pageXOffset,
-      y: this.window_.pageYOffset
+      y: this.window_.pageYOffset - this.topToolbarHeight_
     };
   },
 
   /**
    * Scroll the viewport to the specified position.
    * @type {Object} position the position to scroll to.
    */
   set position(position) {
-    this.window_.scrollTo(position.x, position.y);
+    this.window_.scrollTo(position.x, position.y + this.topToolbarHeight_);
   },
 
   /**
    * @type {Object} the size of the viewport excluding scrollbars.
    */
   get size() {
     var needsScrollbars = this.documentNeedsScrollbars_(this.zoom_);
     var scrollbarWidth = needsScrollbars.vertical ? this.scrollbarWidth_ : 0;
     var scrollbarHeight = needsScrollbars.horizontal ? this.scrollbarWidth_ : 0;
     return {
@@ skipping 28 matching lines @@
    * @private
    * Sets the zoom of the viewport.
    * @param {number} newZoom the zoom level to zoom to.
    */
   setZoomInternal_: function(newZoom) {
     if (!this.allowedToChangeZoom_) {
       throw 'Called Viewport.setZoomInternal_ without calling ' +
             'Viewport.mightZoom_.';
     }
     // Record the scroll position (relative to the top-left of the window).
-    var currentScrollPos = [
-      this.window_.pageXOffset / this.zoom_,
-      this.window_.pageYOffset / this.zoom_
-    ];
+    var currentScrollPos = {
+      x: this.position.x / this.zoom_,
+      y: this.position.y / this.zoom_
+    };
     this.zoom_ = newZoom;
     this.contentSizeChanged_();
     // Scroll to the scaled scroll position.
-    this.window_.scrollTo(currentScrollPos[0] * newZoom,
-                          currentScrollPos[1] * newZoom);
+    this.position = {
+      x: currentScrollPos.x * newZoom,
+      y: currentScrollPos.y * newZoom
+    };
   },
 
   /**
    * Sets the zoom to the given zoom level.
    * @param {number} newZoom the zoom level to zoom to.
    */
   setZoom: function(newZoom) {
     this.fittingType_ = Viewport.FittingType.NONE;
     newZoom = Math.max(Viewport.ZOOM_FACTOR_RANGE.min,
                        Math.min(newZoom, Viewport.ZOOM_FACTOR_RANGE.max));
@@ skipping 168 matching lines @@
       this.fittingType_ = Viewport.FittingType.FIT_TO_PAGE;
       if (!this.documentDimensions_)
         return;
       var page = this.getMostVisiblePage();
       // Fit to the current page's height and the widest page's width.
       var dimensions = {
         width: this.documentDimensions_.width,
         height: this.pageDimensions_[page].height,
       };
       this.setZoomInternal_(this.computeFittingZoom_(dimensions, false));
-      if (scrollToTopOfPage)
-        this.window_.scrollTo(0, this.pageDimensions_[page].y * this.zoom_);
+      if (scrollToTopOfPage) {
+        this.position = {
+          x: 0,
+          y: this.pageDimensions_[page].y * this.zoom_
+        };
+      }
       this.updateViewport_();
     }.bind(this));
   },
 
   /**
    * Zoom the viewport so that a page consumes the entire viewport. Also scrolls
    * the viewport to the top of the current page.
    */
   fitToPage: function() {
     this.fitToPageInternal_(true);
@@ skipping 37 matching lines @@
    */
   goToPage: function(page) {
     this.mightZoom_(function() {
       if (this.pageDimensions_.length === 0)
         return;
       if (page < 0)
         page = 0;
       if (page >= this.pageDimensions_.length)
         page = this.pageDimensions_.length - 1;
       var dimensions = this.pageDimensions_[page];
-      this.window_.scrollTo(dimensions.x * this.zoom_,
-                            dimensions.y * this.zoom_);
+      var toolbarOffset = 0;
+      // Unless we're in fit to page mode, scroll above the page by
+      // |this.topToolbarHeight_| so that the toolbar isn't covering it
+      // initially.
+      if (this.fittingType_ != Viewport.FittingType.FIT_TO_PAGE)
+        toolbarOffset = this.topToolbarHeight_;
+      this.position = {
+        x: dimensions.x * this.zoom_,
+        y: dimensions.y * this.zoom_ - toolbarOffset
+      };
       this.updateViewport_();
     }.bind(this));
   },
 
   /**
    * Set the dimensions of the document.
    * @param {Object} documentDimensions the dimensions of the document
    */
   setDocumentDimensions: function(documentDimensions) {
     this.mightZoom_(function() {
       var initialDimensions = !this.documentDimensions_;
       this.documentDimensions_ = documentDimensions;
       this.pageDimensions_ = this.documentDimensions_.pageDimensions;
       if (initialDimensions) {
         this.setZoomInternal_(
             Math.min(this.defaultZoom_,
                      this.computeFittingZoom_(this.documentDimensions_, true)));
-        this.window_.scrollTo(0, 0);
+        this.position = {
+          x: 0,
+          y: -this.topToolbarHeight_
+        };
       }
       this.contentSizeChanged_();
       this.resize_();
     }.bind(this));
   },
 
   /**
    * Get the coordinates of the page contents (excluding the page shadow)
    * relative to the screen.
    * @param {number} page the index of the page to get the rect for.
@@ skipping 35 matching lines @@
     spaceOnLeft = Math.max(spaceOnLeft, 0);
 
     return {
       x: x * this.zoom_ + spaceOnLeft - this.window_.pageXOffset,
       y: insetDimensions.y * this.zoom_ - this.window_.pageYOffset,
       width: insetDimensions.width * this.zoom_,
       height: insetDimensions.height * this.zoom_
     };
   }
 };