Drag-and-drop across OOPIFs.

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 190 matching lines @@
 void DragController::cancelDrag() {
   m_page->dragCaretController().clear();
 }
 
 void DragController::dragEnded() {
   m_dragInitiator = nullptr;
   m_didInitiateDrag = false;
   m_page->dragCaretController().clear();
 }
 
-void DragController::dragExited(DragData* dragData) {
+void DragController::dragExited(DragData* dragData, LocalFrame& localRoot) {
   DCHECK(dragData);
-  LocalFrame* mainFrame = m_page->deprecatedLocalMainFrame();
 
-  FrameView* frameView(mainFrame->view());
+  FrameView* frameView(localRoot.view());
   if (frameView) {
     DataTransferAccessPolicy policy =
         (!m_documentUnderMouse ||
          m_documentUnderMouse->getSecurityOrigin()->isLocal())
             ? DataTransferReadable
             : DataTransferTypesReadable;
     DataTransfer* dataTransfer = createDraggingDataTransfer(policy, dragData);
     dataTransfer->setSourceOperation(dragData->draggingSourceOperationMask());
-    mainFrame->eventHandler().cancelDragAndDrop(createMouseEvent(dragData),
-                                                dataTransfer);
+    localRoot.eventHandler().cancelDragAndDrop(createMouseEvent(dragData),
+                                               dataTransfer);
     dataTransfer->setAccessPolicy(
         DataTransferNumb);  // invalidate clipboard here for security
   }
   mouseMovedIntoDocument(nullptr);
   if (m_fileInputElementUnderMouse)
     m_fileInputElementUnderMouse->setCanReceiveDroppedFiles(false);
   m_fileInputElementUnderMouse = nullptr;
 }
 
-bool DragController::performDrag(DragData* dragData) {
+bool DragController::performDrag(DragData* dragData, LocalFrame& localRoot) {
   DCHECK(dragData);
-  m_documentUnderMouse = m_page->deprecatedLocalMainFrame()->documentAtPoint(
-      dragData->clientPosition());
+  m_documentUnderMouse = localRoot.documentAtPoint(dragData->clientPosition());
   UserGestureIndicator gesture(DocumentUserGestureToken::create(
       m_documentUnderMouse, UserGestureToken::NewGesture));
   if ((m_dragDestinationAction & DragDestinationActionDHTML) &&
       m_documentIsHandlingDrag) {
-    LocalFrame* mainFrame = m_page->deprecatedLocalMainFrame();
     bool preventedDefault = false;
-    if (mainFrame->view()) {
+    if (localRoot.view()) {
       // Sending an event can result in the destruction of the view and part.
       DataTransfer* dataTransfer =
           createDraggingDataTransfer(DataTransferReadable, dragData);
       dataTransfer->setSourceOperation(dragData->draggingSourceOperationMask());
-      EventHandler& eventHandler = mainFrame->eventHandler();
+      EventHandler& eventHandler = localRoot.eventHandler();
       preventedDefault = eventHandler.performDragAndDrop(
                              createMouseEvent(dragData), dataTransfer) !=
                          WebInputEventResult::NotHandled;
       if (!preventedDefault) {
         // When drop target is plugin element and it can process drag, we
         // should prevent default behavior.
         const IntPoint point =
-            mainFrame->view()->rootFrameToContents(dragData->clientPosition());
+            localRoot.view()->rootFrameToContents(dragData->clientPosition());
         const HitTestResult result = eventHandler.hitTestResultAtPoint(point);
         preventedDefault |=
             isHTMLPlugInElement(*result.innerNode()) &&
             toHTMLPlugInElement(result.innerNode())->canProcessDrag();
       }
 
       // Invalidate clipboard here for security.
       dataTransfer->setAccessPolicy(DataTransferNumb);
     }
     if (preventedDefault) {
       m_documentUnderMouse = nullptr;
       cancelDrag();
       return true;
     }
   }
 
   if ((m_dragDestinationAction & DragDestinationActionEdit) &&
       concludeEditDrag(dragData)) {
     m_documentUnderMouse = nullptr;
     return true;
   }
 
   m_documentUnderMouse = nullptr;
 
-  if (operationForLoad(dragData) == DragOperationNone)
+  if (operationForLoad(dragData, localRoot) == DragOperationNone)
     return false;
 
   if (m_page->settings().navigateOnDragDrop()) {
     m_page->mainFrame()->navigate(
         FrameLoadRequest(nullptr, ResourceRequest(dragData->asURL())));
   }
   return true;
 }
 
 void DragController::mouseMovedIntoDocument(Document* newDocument) {
   if (m_documentUnderMouse == newDocument)
     return;
 
   // If we were over another document clear the selection
   if (m_documentUnderMouse)
     cancelDrag();
   m_documentUnderMouse = newDocument;
 }
 
-DragSession DragController::dragEnteredOrUpdated(DragData* dragData) {
+DragSession DragController::dragEnteredOrUpdated(DragData* dragData,
+                                                 LocalFrame& localRoot) {
   DCHECK(dragData);
-  DCHECK(m_page->mainFrame());
-  mouseMovedIntoDocument(m_page->deprecatedLocalMainFrame()->documentAtPoint(
-      dragData->clientPosition()));
+
+  mouseMovedIntoDocument(localRoot.documentAtPoint(dragData->clientPosition()));
 
   // TODO(esprehn): Replace acceptsLoadDrops with a Setting used in core.
   m_dragDestinationAction =
       m_page->chromeClient().acceptsLoadDrops()
           ? DragDestinationActionAny
           : static_cast<DragDestinationAction>(DragDestinationActionDHTML |
                                                DragDestinationActionEdit);
 
   DragSession dragSession;
-  m_documentIsHandlingDrag =
-      tryDocumentDrag(dragData, m_dragDestinationAction, dragSession);
+  m_documentIsHandlingDrag = tryDocumentDrag(dragData, m_dragDestinationAction,
+                                             dragSession, localRoot);
   if (!m_documentIsHandlingDrag &&
       (m_dragDestinationAction & DragDestinationActionLoad))
-    dragSession.operation = operationForLoad(dragData);
+    dragSession.operation = operationForLoad(dragData, localRoot);
   return dragSession;
 }
 
 static HTMLInputElement* asFileInput(Node* node) {
   DCHECK(node);
   for (; node; node = node->ownerShadowHost()) {
     if (isHTMLInputElement(*node) &&
         toHTMLInputElement(node)->type() == InputTypeNames::file)
       return toHTMLInputElement(node);
   }
@@ skipping 11 matching lines @@
   while (n && !n->isElementNode())
     n = n->parentOrShadowHostNode();
   if (n && n->isInShadowTree())
     n = n->ownerShadowHost();
 
   return toElement(n);
 }
 
 bool DragController::tryDocumentDrag(DragData* dragData,
                                      DragDestinationAction actionMask,
-                                     DragSession& dragSession) {
+                                     DragSession& dragSession,
+                                     LocalFrame& localRoot) {
   DCHECK(dragData);
 
   if (!m_documentUnderMouse)
     return false;
 
   if (m_dragInitiator &&
       !m_documentUnderMouse->getSecurityOrigin()->canAccess(
           m_dragInitiator->getSecurityOrigin()))
     return false;
 
   bool isHandlingDrag = false;
   if (actionMask & DragDestinationActionDHTML) {
-    isHandlingDrag = tryDHTMLDrag(dragData, dragSession.operation);
+    isHandlingDrag = tryDHTMLDrag(dragData, dragSession.operation, localRoot);
     // Do not continue if m_documentUnderMouse has been reset by tryDHTMLDrag.
     // tryDHTMLDrag fires dragenter event. The event listener that listens
     // to this event may create a nested message loop (open a modal dialog),
     // which could process dragleave event and reset m_documentUnderMouse in
     // dragExited.
     if (!m_documentUnderMouse)
       return false;
   }
 
   // It's unclear why this check is after tryDHTMLDrag.
   // We send drag events in tryDHTMLDrag and that may be the reason.
   FrameView* frameView = m_documentUnderMouse->view();
   if (!frameView)
     return false;
 
   if (isHandlingDrag) {
     m_page->dragCaretController().clear();
     return true;
   }
 
-  if ((actionMask & DragDestinationActionEdit) && canProcessDrag(dragData)) {
+  if ((actionMask & DragDestinationActionEdit) &&
+      canProcessDrag(dragData, localRoot)) {
     IntPoint point = frameView->rootFrameToContents(dragData->clientPosition());
     Element* element = elementUnderMouse(m_documentUnderMouse.get(), point);
     if (!element)
       return false;
 
     HTMLInputElement* elementAsFileInput = asFileInput(element);
     if (m_fileInputElementUnderMouse != elementAsFileInput) {
       if (m_fileInputElementUnderMouse)
         m_fileInputElementUnderMouse->setCanReceiveDroppedFiles(false);
       m_fileInputElementUnderMouse = elementAsFileInput;
@@ skipping 37 matching lines @@
 
   // We are not over an editable region. Make sure we're clearing any prior drag
   // cursor.
   m_page->dragCaretController().clear();
   if (m_fileInputElementUnderMouse)
     m_fileInputElementUnderMouse->setCanReceiveDroppedFiles(false);
   m_fileInputElementUnderMouse = nullptr;
   return false;
 }
 
-DragOperation DragController::operationForLoad(DragData* dragData) {
+DragOperation DragController::operationForLoad(DragData* dragData,
+                                               LocalFrame& localRoot) {
   DCHECK(dragData);
-  Document* doc = m_page->deprecatedLocalMainFrame()->documentAtPoint(
-      dragData->clientPosition());
+  Document* doc = localRoot.documentAtPoint(dragData->clientPosition());
 
   if (doc &&
       (m_didInitiateDrag || doc->isPluginDocument() || hasEditableStyle(*doc)))
     return DragOperationNone;
   return dragOperation(dragData);
 }
 
 // Returns true if node at |point| is editable with populating |dragCaret| and
 // |range|, otherwise returns false.
 // TODO(yosin): We should return |VisibleSelection| rather than three values.
@@ skipping 68 matching lines @@
     // fileInput should be the element we hit tested for, unless it was made
     // display:none in a drop event handler.
     if (fileInput->layoutObject())
       DCHECK_EQ(fileInput, element);
     if (fileInput->isDisabledFormControl())
       return false;
 
     return fileInput->receiveDroppedFiles(dragData);
   }
 
-  if (!m_page->dragController().canProcessDrag(dragData)) {
+  // TODO(paulmeyer): Isn't |m_page->dragController()| the same as |this|?
+  if (!m_page->dragController().canProcessDrag(dragData,
+                                               *innerFrame->localFrameRoot())) {
     m_page->dragCaretController().clear();
     return false;
   }
 
   if (m_page->dragCaretController().hasCaret()) {
     // TODO(xiaochengh): The use of updateStyleAndLayoutIgnorePendingStylesheets
     // needs to be audited.  See http://crbug.com/590369 for more details.
     m_page->dragCaretController()
         .caretPosition()
         .position()
@@ skipping 100 matching lines @@
   if (rootEditableElement) {
     if (LocalFrame* frame = rootEditableElement->document().frame()) {
       frame->eventHandler().updateDragStateAfterEditDragIfNeeded(
           rootEditableElement);
     }
   }
 
   return true;
 }
 
-bool DragController::canProcessDrag(DragData* dragData) {
+bool DragController::canProcessDrag(DragData* dragData, LocalFrame& localRoot) {
   DCHECK(dragData);
 
   if (!dragData->containsCompatibleContent())
     return false;
 
-  IntPoint point =
-      m_page->deprecatedLocalMainFrame()->view()->rootFrameToContents(
-          dragData->clientPosition());
-  if (m_page->deprecatedLocalMainFrame()->contentLayoutItem().isNull())
+  if (localRoot.contentLayoutItem().isNull())
     return false;
 
-  HitTestResult result =
-      m_page->deprecatedLocalMainFrame()->eventHandler().hitTestResultAtPoint(
-          point);
+  IntPoint point =
+      localRoot.view()->rootFrameToContents(dragData->clientPosition());
+
+  HitTestResult result = localRoot.eventHandler().hitTestResultAtPoint(point);
 
   if (!result.innerNode())
     return false;
 
   if (dragData->containsFiles() && asFileInput(result.innerNode()))
     return true;
 
   if (isHTMLPlugInElement(*result.innerNode())) {
     HTMLPlugInElement* plugin = toHTMLPlugInElement(result.innerNode());
     if (!plugin->canProcessDrag() && !hasEditableStyle(*result.innerNode()))
@@ skipping 22 matching lines @@
     return DragOperationCopy;
   if (srcOpMask & DragOperationLink)
     return DragOperationLink;
 
   // FIXME: Does IE really return "generic" even if no operations were allowed
   // by the source?
   return DragOperationGeneric;
 }
 
 bool DragController::tryDHTMLDrag(DragData* dragData,
-                                  DragOperation& operation) {
+                                  DragOperation& operation,
+                                  LocalFrame& localRoot) {
   DCHECK(dragData);
   DCHECK(m_documentUnderMouse);
-  LocalFrame* mainFrame = m_page->deprecatedLocalMainFrame();
-  if (!mainFrame->view())
+  if (!localRoot.view())
     return false;
 
   DataTransferAccessPolicy policy =
       m_documentUnderMouse->getSecurityOrigin()->isLocal()
           ? DataTransferReadable
           : DataTransferTypesReadable;
   DataTransfer* dataTransfer = createDraggingDataTransfer(policy, dragData);
   DragOperation srcOpMask = dragData->draggingSourceOperationMask();
   dataTransfer->setSourceOperation(srcOpMask);
 
   PlatformMouseEvent event = createMouseEvent(dragData);
-  if (mainFrame->eventHandler().updateDragAndDrop(event, dataTransfer) ==
+  if (localRoot.eventHandler().updateDragAndDrop(event, dataTransfer) ==
       WebInputEventResult::NotHandled) {
     dataTransfer->setAccessPolicy(
         DataTransferNumb);  // invalidate clipboard here for security
     return false;
   }
 
   operation = dataTransfer->destinationOperation();
   if (dataTransfer->dropEffectIsUninitialized()) {
     operation = defaultOperationForDrag(srcOpMask);
   } else if (!(srcOpMask & operation)) {
@@ skipping 480 matching lines @@
 }
 
 DEFINE_TRACE(DragController) {
   visitor->trace(m_page);
   visitor->trace(m_documentUnderMouse);
   visitor->trace(m_dragInitiator);
   visitor->trace(m_fileInputElementUnderMouse);
 }
 
 }  // namespace blink