Revert of 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 317 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.
+  // To simplify things, convert the event into device coordinates if it is
+  // a mouse event.
   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());
 
-      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;
+  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;
     }
+    default:
+      break;
   }
-
-  if (engine_->HandleEvent(event_device_res))
+  if (engine_->HandleEvent(offset_event))
     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_) {
-    scroll_offset_ = view.GetScrollOffset();
+    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() - 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_ = 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 = callback_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 =
       callback_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 348 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