Delay printing OOP PDF until loading is complete

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 237 matching lines @@
 }  // namespace
 
 OutOfProcessInstance::OutOfProcessInstance(PP_Instance instance)
     : pp::Instance(instance),
       pp::Find_Private(this),
       pp::Printing_Dev(this),
       pp::Selection_Dev(this),
       cursor_(PP_CURSORTYPE_POINTER),
       zoom_(1.0),
       device_scale_(1.0),
-      printing_enabled_(true),
       full_(false),
       paint_manager_(this, this, true),
       first_paint_(true),
       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) {
+      stop_scrolling_(false),
+      delay_print_(false) {
   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 681 matching lines @@
   message.Set(pp::Var(kJSEmailBcc),
               pp::Var(net::EscapeUrlEncodedData(bcc, false)));
   message.Set(pp::Var(kJSEmailSubject),
               pp::Var(net::EscapeUrlEncodedData(subject, false)));
   message.Set(pp::Var(kJSEmailBody),
               pp::Var(net::EscapeUrlEncodedData(body, false)));
   PostMessage(message);
 }
 
 void OutOfProcessInstance::Print() {
-  if (!printing_enabled_ ||
-      (!engine_->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY) &&
-       !engine_->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY))) {
+  if (document_load_state_ == LOAD_STATE_LOADING) {
+    delay_print_ = true;
     return;
   }
 
+  if (!engine_->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY) &&
+      !engine_->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY)) {
+    return;
+  }
+
   pp::CompletionCallback callback =
       print_callback_factory_.NewCallback(&OutOfProcessInstance::OnPrint);
   pp::Module::Get()->core()->CallOnMainThread(0, callback);
 }
 
 void OutOfProcessInstance::OnPrint(int32_t) {
   pp::PDF::Print(this);
 }
 
 void OutOfProcessInstance::SubmitForm(const std::string& url,
@@ skipping 92 matching lines @@
   }
 
   pp::VarDictionary named_destinations_message;
   pp::VarDictionary named_destinations = engine_->GetNamedDestinations();
   named_destinations_message.Set(pp::Var(kType),
                                  pp::Var(kJSSetNamedDestinationsType));
   named_destinations_message.Set(pp::Var(kJSNamedDestinations),
                                  pp::Var(named_destinations));
   PostMessage(named_destinations_message);
 
+  pp::VarDictionary bookmarks_message;
+  bookmarks_message.Set(pp::Var(kType), pp::Var(kJSBookmarksType));
+  bookmarks_message.Set(pp::Var(kJSBookmarks), engine_->GetBookmarks());
+  PostMessage(bookmarks_message);
+
   pp::VarDictionary progress_message;
   progress_message.Set(pp::Var(kType), pp::Var(kJSLoadProgressType));
   progress_message.Set(pp::Var(kJSProgressPercentage), pp::Var(100));
   PostMessage(progress_message);
 
-  pp::VarDictionary bookmarksMessage;
-  bookmarksMessage.Set(pp::Var(kType), pp::Var(kJSBookmarksType));
-  bookmarksMessage.Set(pp::Var(kJSBookmarks), engine_->GetBookmarks());
-  PostMessage(bookmarksMessage);
+  if (full_) {
+    if (did_call_start_loading_) {
+      pp::PDF::DidStopLoading(this);
+      did_call_start_loading_ = false;
+    }
 
-  if (!full_)
-    return;
+    int content_restrictions =
+        CONTENT_RESTRICTION_CUT | CONTENT_RESTRICTION_PASTE;
+    if (!engine_->HasPermission(PDFEngine::PERMISSION_COPY))
+      content_restrictions |= CONTENT_RESTRICTION_COPY;
 
-  if (did_call_start_loading_) {
-    pp::PDF::DidStopLoading(this);
-    did_call_start_loading_ = false;
+    pp::PDF::SetContentRestriction(this, content_restrictions);
+
+    uma_.HistogramCustomCounts("PDF.PageCount", page_count,
+                               1, 1000000, 50);
   }
 
-  int content_restrictions =
-      CONTENT_RESTRICTION_CUT | CONTENT_RESTRICTION_PASTE;
-  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)) {
-    printing_enabled_ = false;
-  }
-
-  pp::PDF::SetContentRestriction(this, content_restrictions);
-
-  uma_.HistogramCustomCounts("PDF.PageCount", page_count,
-                             1, 1000000, 50);
+  if (delay_print_)
+    Print();
 }
 
 void OutOfProcessInstance::RotateClockwise() {
   engine_->RotateClockwise();
 }
 
 void OutOfProcessInstance::RotateCounterclockwise() {
   engine_->RotateCounterclockwise();
 }
 
@@ skipping 249 matching lines @@
 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 max_y = document_size_.height() * zoom_ - plugin_dip_size_.height();
   float y = std::max(std::min(scroll_offset.y(), max_y), 0.0f);
   return pp::FloatPoint(x, y);
 }
 
 }  // namespace chrome_pdf