Prevent the in-process PDF plugin re-entering into JS during blink layout

pdf/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/instance.h"
 
 #include <algorithm>  // for min()
 #define _USE_MATH_DEFINES  // for M_PI
 #include <cmath>      // for log() and pow()
 #include <math.h>
@@ skipping 277 matching lines @@
       first_paint_(true),
       painted_first_page_(false),
       show_page_indicator_(false),
       document_load_state_(LOAD_STATE_LOADING),
       preview_document_load_state_(LOAD_STATE_COMPLETE),
       told_browser_about_unsupported_feature_(false),
       print_preview_page_count_(0) {
   loader_factory_.Initialize(this);
   timer_factory_.Initialize(this);
   form_factory_.Initialize(this);
-  print_callback_factory_.Initialize(this);
+  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_WHEEL);
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_TOUCH);
 }
 
@@ skipping 816 matching lines @@
     paint_manager_.InvalidateRect(autoscroll_rect_);
 
   if (show_page_indicator_) {
     page_indicator_.set_current_page(GetPageNumberToDisplay());
     page_indicator_.Splash();
   }
 
   if (page_indicator_.visible())
     paint_manager_.InvalidateRect(page_indicator_.rect());
 
-  if (on_scroll_callback_.is_string())
-    ExecuteScript(on_scroll_callback_);
+  // Run the scroll callback asynchronously. This function can be invoked by a
+  // layout change which should not re-enter into JS synchronously.
+  pp::CompletionCallback callback =
+      callback_factory_.NewCallback(&Instance::RunCallback,
+                                    on_scroll_callback_);
+  pp::Module::Get()->core()->CallOnMainThread(0, callback);
 }
 
 void Instance::ScrollToX(int position) {
   if (!h_scrollbar_.get()) {
     NOTREACHED();
     return;
   }
   int position_dip = static_cast<int>(position / device_scale_);
   h_scrollbar_->SetValue(position_dip);
 }
@@ skipping 220 matching lines @@
 }
 
 void Instance::Print() {
   if (!printing_enabled_ ||
       (!engine_->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY) &&
        !engine_->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY))) {
     return;
   }
 
   pp::CompletionCallback callback =
-      print_callback_factory_.NewCallback(&Instance::OnPrint);
+      callback_factory_.NewCallback(&Instance::OnPrint);
   pp::Module::Get()->core()->CallOnMainThread(0, callback);
 }
 
 void Instance::OnPrint(int32_t) {
   pp::PDF::Print(this);
 }
 
 void Instance::SaveAs() {
   pp::PDF::SaveAs(this);
 }
@@ skipping 722 matching lines @@
 #endif
 
   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_));
 
-  if (on_plugin_size_changed_callback_.is_string())
-    ExecuteScript(on_plugin_size_changed_callback_);
+  // Run the plugin size change callback asynchronously. This function can be
+  // invoked by a layout change which should not re-enter into JS synchronously.
+  pp::CompletionCallback callback =
+      callback_factory_.NewCallback(&Instance::RunCallback,
+                                    on_plugin_size_changed_callback_);
+  pp::Module::Get()->core()->CallOnMainThread(0, callback);
+}
+
+void Instance::RunCallback(int32_t, pp::Var callback) {
+  if (callback.is_string())
+    ExecuteScript(callback);
 }
 
 void Instance::CreateHorizontalScrollbar() {
   if (h_scrollbar_.get())
     return;
 
   h_scrollbar_.reset(new pp::Scrollbar_Dev(this, false));
 }
 
 void Instance::CreateVerticalScrollbar() {
@@ skipping 594 matching lines @@
   return instance_->HasScriptableMethod(name, exception);
 }
 
 pp::Var PDFScriptableObject::Call(const pp::Var& method,
                                   const std::vector<pp::Var>& args,
                                   pp::Var* exception) {
   return instance_->CallScriptableMethod(method, args, exception);
 }
 
 }  // namespace chrome_pdf