Handle long press in PDF documents.

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 <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>       // for min/max()
@@ skipping 221 matching lines @@
   int page_index = 0;
   if (!base::StringToInt(url_substr[1], &page_index))
     return -1;
   return page_index;
 }
 
 bool IsPrintPreviewUrl(const std::string& url) {
   return url.substr(0, strlen(kChromePrint)) == kChromePrint;
 }
 
+void ScaleFloatPoint(float scale, pp::FloatPoint* point) {
+  point->set_x(point->x() * scale);
+  point->set_y(point->y() * scale);
+}
+
 void ScalePoint(float scale, pp::Point* point) {
   point->set_x(static_cast<int>(point->x() * scale));
   point->set_y(static_cast<int>(point->y() * scale));
 }
 
 void ScaleRect(float scale, pp::Rect* rect) {
   int left = static_cast<int>(floorf(rect->x() * scale));
   int top = static_cast<int>(floorf(rect->y() * scale));
   int right = static_cast<int>(ceilf((rect->x() + rect->width()) * scale));
   int bottom = static_cast<int>(ceilf((rect->y() + rect->height()) * scale));
@@ skipping 320 matching lines @@
     reply.Set(pp::Var(kType), pp::Var(kJSGetNamedDestinationReplyType));
     if (page_number >= 0)
       reply.Set(pp::Var(kJSNamedDestinationPageNumber), page_number);
     PostMessage(reply);
   } else {
     NOTREACHED();
   }
 }
 
 bool OutOfProcessInstance::HandleInputEvent(const pp::InputEvent& event) {
-  // To simplify things, convert the event into device coordinates if it is
-  // a mouse event.
+  // To simplify things, convert the event into device coordinates.
   pp::InputEvent event_device_res(event);
   {
     pp::MouseInputEvent mouse_event(event);
     if (!mouse_event.is_null()) {
       pp::Point point = mouse_event.GetPosition();
       pp::Point movement = mouse_event.GetMovement();
       ScalePoint(device_scale_, &point);
+      point.set_x(point.x() - available_area_.x());
+
       ScalePoint(device_scale_, &movement);
       mouse_event =
           pp::MouseInputEvent(this, event.GetType(), event.GetTimeStamp(),
                               event.GetModifiers(), mouse_event.GetButton(),
                               point, mouse_event.GetClickCount(), movement);
       event_device_res = mouse_event;
     }
   }
+  {
+    pp::TouchInputEvent touch_event(event);
+    if (!touch_event.is_null()) {
+      pp::TouchInputEvent new_touch_event = pp::TouchInputEvent(
+          this, touch_event.GetType(), touch_event.GetTimeStamp(),
+          touch_event.GetModifiers());
 
-  pp::InputEvent offset_event(event_device_res);
-  switch (offset_event.GetType()) {
-    case PP_INPUTEVENT_TYPE_MOUSEDOWN:
-    case PP_INPUTEVENT_TYPE_MOUSEUP:
-    case PP_INPUTEVENT_TYPE_MOUSEMOVE:
-    case PP_INPUTEVENT_TYPE_MOUSEENTER:
-    case PP_INPUTEVENT_TYPE_MOUSELEAVE: {
-      pp::MouseInputEvent mouse_event(event_device_res);
-      pp::MouseInputEvent mouse_event_dip(event);
-      pp::Point point = mouse_event.GetPosition();
-      point.set_x(point.x() - available_area_.x());
-      offset_event = pp::MouseInputEvent(
-          this, event.GetType(), event.GetTimeStamp(), event.GetModifiers(),
-          mouse_event.GetButton(), point, mouse_event.GetClickCount(),
-          mouse_event.GetMovement());
-      break;
+      for (uint32_t i = 0;
+           i < touch_event.GetTouchCount(PP_TOUCHLIST_TYPE_TARGETTOUCHES);
+           i++) {
+        pp::TouchPoint touch_point =
+            touch_event.GetTouchByIndex(PP_TOUCHLIST_TYPE_TARGETTOUCHES, i);
+
+        pp::FloatPoint point = touch_point.position();
+
+        // Account for the scroll position. Touch events are in DOM coordinates
+        // where mouse events appear to be in screen coordinates.
+        point.set_x(scroll_offset_.x() + point.x());
+        point.set_y(scroll_offset_.y() + point.y());
+        ScaleFloatPoint(device_scale_, &point);
+
+        point.set_x(point.x() - available_area_.x());
+
+        new_touch_event.AddTouchPoint(
+            PP_TOUCHLIST_TYPE_TARGETTOUCHES,
+            {touch_point.id(), point, touch_point.radii(),
+             touch_point.rotation_angle(), touch_point.pressure()});
+      }
+      event_device_res = new_touch_event;
     }
-    default:
-      break;
   }
-  if (engine_->HandleEvent(offset_event))
+
+  if (engine_->HandleEvent(event_device_res))
     return true;
 
   // Middle click is used for scrolling and is handled by the container page.
   pp::MouseInputEvent mouse_event(event_device_res);
   if (!mouse_event.is_null() &&
       mouse_event.GetButton() == PP_INPUTEVENT_MOUSEBUTTON_MIDDLE) {
     return false;
   }
 
   // Return true for unhandled clicks so the plugin takes focus.
@@ skipping 24 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());
+    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() - top_toolbar_height_);
+    pp::FloatPoint scroll_offset_float(
+        scroll_offset_.x(), 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 276 matching lines @@
 void OutOfProcessInstance::DidOpenPreview(int32_t result) {
   if (result == PP_OK) {
     preview_client_ = base::MakeUnique<PreviewModeClient>(this);
     preview_engine_.reset(PDFEngine::Create(preview_client_.get()));
     preview_engine_->HandleDocumentLoad(embed_preview_loader_);
   } else {
     NOTREACHED();
   }
 }
 
+void OutOfProcessInstance::OnClientTouchTimerFired(int32_t id) {
+  engine_->OnTouchTimerCallback(id);
+}
+
 void OutOfProcessInstance::OnClientTimerFired(int32_t id) {
   engine_->OnCallback(id);
 }
 
 void OutOfProcessInstance::CalculateBackgroundParts() {
   background_parts_.clear();
   int left_width = available_area_.x();
   int right_start = available_area_.right();
   int right_width = abs(plugin_size_.width() - available_area_.right());
   int bottom = std::min(available_area_.bottom(), plugin_size_.height());
@@ skipping 268 matching lines @@
     // Disable save and print until the document is fully loaded, since they
     // would generate an incomplete document.  Need to do this each time we
     // call DidStartLoading since that resets the content restrictions.
     pp::PDF::SetContentRestriction(
         this, CONTENT_RESTRICTION_SAVE | CONTENT_RESTRICTION_PRINT);
   }
 
   return CreateURLLoaderInternal();
 }
 
+void OutOfProcessInstance::ScheduleTouchTimerCallback(int id, int delay_in_ms) {
+  pp::CompletionCallback callback = timer_factory_.NewCallback(
+      &OutOfProcessInstance::OnClientTouchTimerFired);
+  pp::Module::Get()->core()->CallOnMainThread(delay_in_ms, callback, id);
+}
+
 void OutOfProcessInstance::ScheduleCallback(int id, int delay_in_ms) {
   pp::CompletionCallback callback =
       timer_factory_.NewCallback(&OutOfProcessInstance::OnClientTimerFired);
   pp::Module::Get()->core()->CallOnMainThread(delay_in_ms, callback, id);
 }
 
 void OutOfProcessInstance::SearchString(
     const base::char16* string,
     const base::char16* term,
     bool case_sensitive,
@@ skipping 355 matching lines @@
     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), min_y);
   return pp::FloatPoint(x, y);
 }
 
 }  // namespace chrome_pdf