[UseZoomForDSF] Support drag&drop

third_party/WebKit/Source/core/page/DragController.cpp

 /*
  * Copyright (C) 2007, 2009, 2010 Apple Inc. All rights reserved.
  * Copyright (C) 2008 Google Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 42 matching lines @@
 #include "core/frame/Settings.h"
 #include "core/html/HTMLAnchorElement.h"
 #include "core/html/HTMLFormElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLPlugInElement.h"
 #include "core/input/EventHandler.h"
 #include "core/layout/LayoutTheme.h"
 #include "core/layout/LayoutView.h"
 #include "core/loader/FrameLoadRequest.h"
 #include "core/loader/FrameLoader.h"
+#include "core/page/ChromeClient.h"
 #include "core/page/DragClient.h"
 #include "core/page/DragData.h"
 #include "core/page/DragSession.h"
 #include "core/page/DragState.h"
 #include "core/page/Page.h"
 #include "core/layout/HitTestRequest.h"
 #include "core/layout/HitTestResult.h"
 #include "core/layout/LayoutImage.h"
 #include "platform/DragImage.h"
 #include "platform/geometry/IntRect.h"
 #include "platform/graphics/BitmapImage.h"
 #include "platform/graphics/Image.h"
 #include "platform/graphics/ImageOrientation.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/weborigin/SecurityOrigin.h"
+#include "public/platform/WebScreenInfo.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/OwnPtr.h"
 #include "wtf/PassOwnPtr.h"
 #include "wtf/RefPtr.h"
 
 #if OS(WIN)
 #include <windows.h>
 #endif
 
 namespace blink {
@@ skipping 695 matching lines @@
 {
 #if OS(MACOSX)
     // Match Safari's drag image size.
     static const IntSize maxDragImageSize(400, 400);
 #else
     static const IntSize maxDragImageSize(200, 200);
 #endif
     return maxDragImageSize;
 }
 
-static PassOwnPtr<DragImage> dragImageForImage(Element* element, Image* image, const IntPoint& dragOrigin, const IntRect& imageRect, IntPoint& dragLocation)
+static PassOwnPtr<DragImage> dragImageForImage(Element* element, Image* image, const IntPoint& dragOrigin, const IntPoint& imageLocation, const IntSize& imageSizeInDIP, IntPoint& dragLocation)
 {
     OwnPtr<DragImage> dragImage;
     IntPoint origin;
 
     InterpolationQuality interpolationQuality = element->ensureComputedStyle()->imageRendering() == ImageRenderingPixelated ? InterpolationNone : InterpolationHigh;
     RespectImageOrientationEnum shouldRespectImageOrientation = LayoutObject::shouldRespectImageOrientation(element->layoutObject());
     ImageOrientation orientation;
 
     if (shouldRespectImageOrientation == RespectImageOrientation && image->isBitmapImage())
         orientation = toBitmapImage(image)->currentFrameOrientation();
 
     if (image->size().height() * image->size().width() <= MaxOriginalImageArea
         && (dragImage = DragImage::create(image, shouldRespectImageOrientation,
             1 /* deviceScaleFactor */, interpolationQuality, DragImageAlpha,
-            DragImage::clampedImageScale(orientation.usesWidthAsHeight() ? image->size().transposedSize() : image->size(), imageRect.size(), maxDragImageSize())))) {
-        IntSize originalSize = imageRect.size();
-        origin = imageRect.location();
+            DragImage::clampedImageScale(orientation.usesWidthAsHeight() ? image->size().transposedSize() : image->size(), imageSizeInDIP, maxDragImageSize())))) {
+        IntSize originalSize = imageSizeInDIP;
+        origin = imageLocation;
 
         IntSize newSize = dragImage->size();
 
         // Properly orient the drag image and orient it differently if it's smaller than the original
         float scale = newSize.width() / (float)originalSize.width();
         float dx = origin.x() - dragOrigin.x();
         dx *= scale;
         origin.setX((int)(dx + 0.5));
         float dy = origin.y() - dragOrigin.y();
         dy *= scale;
@@ skipping 58 matching lines @@
         if (imageURL.isEmpty() || !node || !node->isElementNode())
             return false;
         Element* element = toElement(node);
         Image* image = getImage(element);
         if (!image || image->isNull())
             return false;
         // We shouldn't be starting a drag for an image that can't provide an extension.
         // This is an early detection for problems encountered later upon drop.
         ASSERT(!image->filenameExtension().isEmpty());
         if (!dragImage) {
-            dragImage = dragImageForImage(element, image, dragOrigin, hitTestResult.imageRect(), dragLocation);
+            const IntRect& imageRect = hitTestResult.imageRect();
+            const IntSize& imageSizeInDIP = src->page()->chromeClient().viewportToScreen(imageRect).size();
+            dragImage = dragImageForImage(element, image, dragOrigin, imageRect.location(), imageSizeInDIP, dragLocation);

[dcheng, 2016/01/22 17:37:41]

I don't really understand what transformations are needed and when. Is there
better documentation about this? Why are some things scaled to viewport, but
others to dips?

[oshima, 2016/01/22 22:49:02]

This is because dragImageForImage clips the image in screen coordinates in DIP,
which means that when it's drawn on high DPI display it becomes blurry.
I'm not sure if that's intentional or it was left unimplemented. I can work on a
fix
(but in a separate CL) unless there is a reason not to so. 

Please let me know.

         }
         doSystemDrag(dragImage.get(), dragLocation, dragOrigin, dataTransfer, src, false);
     } else if (state.m_dragType == DragSourceActionLink) {
         if (linkURL.isEmpty())
             return false;
         if (src->selection().isCaret() && src->selection().isContentEditable()) {
             // a user can initiate a drag on a link without having any text
             // selected.  In this case, we should expand the selection to
             // the enclosing anchor element
             if (Node* node = enclosingAnchorElement(src->selection().base()))
                 src->selection().setSelection(VisibleSelection::selectionFromContentsOfNode(node));
         }
 
         if (!dragImage) {
             ASSERT(src->page());
-            float deviceScaleFactor = src->page()->deviceScaleFactor();
-            dragImage = dragImageForLink(linkURL, hitTestResult.textContent(), deviceScaleFactor, mouseDraggedPoint, dragLocation);
+            float screenDeviceScaleFactor = src->page()->chromeClient().screenInfo().deviceScaleFactor;
+            dragImage = dragImageForLink(linkURL, hitTestResult.textContent(), screenDeviceScaleFactor, mouseDraggedPoint, dragLocation);
         }
         doSystemDrag(dragImage.get(), dragLocation, mouseDraggedPoint, dataTransfer, src, true);
     } else if (state.m_dragType == DragSourceActionDHTML) {
         doSystemDrag(dragImage.get(), dragLocation, dragOrigin, dataTransfer, src, false);
     } else {
         ASSERT_NOT_REACHED();
         return false;
     }
 
     return true;
@@ skipping 46 matching lines @@
 
 DEFINE_TRACE(DragController)
 {
     visitor->trace(m_page);
     visitor->trace(m_documentUnderMouse);
     visitor->trace(m_dragInitiator);
     visitor->trace(m_fileInputElementUnderMouse);
 }
 
 } // namespace blink