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

pdf/out_of_process_instance.cc

 // Copyright (c) 2012 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.
 
 #include "pdf/out_of_process_instance.h"
 
 #include <algorithm>  // for min/max()
 #define _USE_MATH_DEFINES  // for M_PI
 #include <cmath>      // for log() and pow()
 #include <math.h>
@@ skipping 260 matching lines @@
       document_load_state_(LOAD_STATE_LOADING),
       preview_document_load_state_(LOAD_STATE_COMPLETE),
       uma_(this),
       told_browser_about_unsupported_feature_(false),
       print_preview_page_count_(0),
       last_progress_sent_(0),
       recently_sent_find_update_(false),
       received_viewport_message_(false),
       did_call_start_loading_(false),
       stop_scrolling_(false),
-      background_color_(kBackgroundColor) {
+      background_color_(kBackgroundColor),
+      top_toolbar_height_(0) {
   loader_factory_.Initialize(this);
   timer_factory_.Initialize(this);
   form_factory_.Initialize(this);
   print_callback_factory_.Initialize(this);
   engine_.reset(PDFEngine::Create(this));
   pp::Module::Get()->AddPluginInterface(kPPPPdfInterface, &ppp_private);
   AddPerInstanceObject(kPPPPdfInterface, this);
 
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
@@ skipping 56 matching lines @@
   bool is_material = false;
   for (uint32_t i = 0; i < argc; ++i) {
     if (strcmp(argn[i], "src") == 0)
       original_url = argv[i];
     else if (strcmp(argn[i], "stream-url") == 0)
       stream_url = argv[i];
     else if (strcmp(argn[i], "headers") == 0)
       headers = argv[i];
     else if (strcmp(argn[i], "is-material") == 0)
       is_material = true;
+    else if (strcmp(argn[i], "top-toolbar-height") == 0)
+      base::StringToInt(argv[i], &top_toolbar_height_);
   }
 
   if (is_material)
     background_color_ = kBackgroundColorMaterial;
   else
     background_color_ = kBackgroundColor;
 
   if (!original_url)
     return false;
 
@@ skipping 217 matching lines @@
     if (image_data_.is_null()) {
       DCHECK(plugin_size_.IsEmpty());
       return;
     }
 
     OnGeometryChanged(zoom_, old_device_scale);
   }
 
   if (!stop_scrolling_) {
     pp::Point scroll_offset(view.GetScrollOffset());
+    // Because view messages come from the DOM, the coordinates of the viewport
+    // are 0-based (i.e. they do not correspond to the viewport's coordinates in
+    // JS), so we need to subtract the toolbar height to convert them into
+    // viewport coordinates.
     pp::FloatPoint scroll_offset_float(scroll_offset.x(),
-                                       scroll_offset.y());
+                                       scroll_offset.y() - top_toolbar_height_);
     scroll_offset_float = BoundScrollOffsetToDocument(scroll_offset_float);
     engine_->ScrolledToXPosition(scroll_offset_float.x() * device_scale_);
     engine_->ScrolledToYPosition(scroll_offset_float.y() * device_scale_);
   }
 }
 
 void OutOfProcessInstance::GetPrintPresetOptionsFromDocument(
     PP_PdfPrintPresetOptions_Dev* options) {
   options->is_scaling_disabled = PP_FromBool(IsPrintScalingDisabled());
   options->duplex =
@@ skipping 112 matching lines @@
         pdf_ready[j].Offset(available_area_.point());
         ready->push_back(
             PaintManager::ReadyRect(pdf_ready[j], image_data_, false));
       }
       for (size_t j = 0; j < pdf_pending.size(); ++j) {
         pdf_pending[j].Offset(available_area_.point());
         pending->push_back(pdf_pending[j]);
       }
     }
 
+    // Ensure the region above the first page (if any) is filled;
+    int32_t first_page_ypos = engine_->GetNumberOfPages() == 0 ?
+        0 : engine_->GetPageScreenRect(0).y();
+    if (rect.y() < first_page_ypos) {
+      pp::Rect region = rect.Intersect(pp::Rect(
+          pp::Point(), pp::Size(plugin_size_.width(), first_page_ypos)));
+      ready->push_back(PaintManager::ReadyRect(region, image_data_, false));
+      FillRect(region, background_color_);
+    }
+
     for (size_t j = 0; j < background_parts_.size(); ++j) {
       pp::Rect intersection = background_parts_[j].location.Intersect(rect);
       if (!intersection.IsEmpty()) {
         FillRect(intersection, background_parts_[j].color);
         ready->push_back(
             PaintManager::ReadyRect(intersection, image_data_, false));
       }
     }
   }
 
@@ skipping 391 matching lines @@
   if (!engine_->HasPermission(PDFEngine::PERMISSION_COPY))
     content_restrictions |= CONTENT_RESTRICTION_COPY;
 
   if (!engine_->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY) &&
       !engine_->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY)) {
     content_restrictions |= CONTENT_RESTRICTION_PRINT;
   }
 
   pp::PDF::SetContentRestriction(this, content_restrictions);
 
-  uma_.HistogramCustomCounts("PDF.PageCount", page_count,
-                             1, 1000000, 50);
+  uma_.HistogramCustomCounts("PDF.PageCount", page_count, 1, 1000000, 50);
 }
 
 void OutOfProcessInstance::RotateClockwise() {
   engine_->RotateClockwise();
 }
 
 void OutOfProcessInstance::RotateCounterclockwise() {
   engine_->RotateCounterclockwise();
 }
 
@@ skipping 125 matching lines @@
                                              float old_device_scale) {
   if (zoom_ != old_zoom || device_scale_ != old_device_scale)
     engine_->ZoomUpdated(zoom_ * device_scale_);
 
   available_area_ = pp::Rect(plugin_size_);
   int doc_width = GetDocumentPixelWidth();
   if (doc_width < available_area_.width()) {
     available_area_.Offset((available_area_.width() - doc_width) / 2, 0);
     available_area_.set_width(doc_width);
   }
-  int doc_height = GetDocumentPixelHeight();
-  if (doc_height < available_area_.height()) {
-    available_area_.set_height(doc_height);
-  }
+  int bottom_of_document =
+      GetDocumentPixelHeight() + (top_toolbar_height_ * device_scale_);
+  if (bottom_of_document < available_area_.height())
+    available_area_.set_height(bottom_of_document);
 
   CalculateBackgroundParts();
   engine_->PageOffsetUpdated(available_area_.point());
   engine_->PluginSizeUpdated(available_area_.size());
 
   if (!document_size_.GetArea())
     return;
   paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
 }
 
@@ skipping 105 matching lines @@
 void OutOfProcessInstance::UserMetricsRecordAction(
     const std::string& action) {
   // TODO(raymes): Move this function to PPB_UMA_Private.
   pp::PDF::UserMetricsRecordAction(this, pp::Var(action));
 }
 
 pp::FloatPoint OutOfProcessInstance::BoundScrollOffsetToDocument(
     const pp::FloatPoint& scroll_offset) {
   float max_x = document_size_.width() * zoom_ - plugin_dip_size_.width();
   float x = std::max(std::min(scroll_offset.x(), max_x), 0.0f);
+  float min_y = -top_toolbar_height_;
   float max_y = document_size_.height() * zoom_ - plugin_dip_size_.height();
-  float y = std::max(std::min(scroll_offset.y(), max_y), 0.0f);
+  float y = std::max(std::min(scroll_offset.y(), max_y), min_y);
   return pp::FloatPoint(x, y);
 }
 
 }  // namespace chrome_pdf