text: /*
   * Copyright (C) 2009, 2012 Google Inc. All rights reserved.
   *
   * Redistribution and use in source and binary forms, with or without
   * modification, are permitted provided that the following conditions are
   * met:
   *
   *     * Redistributions of source code must retain the above copyright
   * notice, this list of conditions and the following disclaimer.
   *     * Redistributions in binary form must reproduce the above
   * copyright notice, this list of conditions and the following disclaimer
   * in the documentation and/or other materials provided with the
   * distribution.
   *     * Neither the name of Google Inc. nor the names of its
   * contributors may be used to endorse or promote products derived from
   * this software without specific prior written permission.
   *
   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
   * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
   * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
   * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   */
  
  #include "config.h"
  #include "web/ContextMenuClientImpl.h"
  
  #include "bindings/core/v8/ExceptionStatePlaceholder.h"
  #include "core/CSSPropertyNames.h"
  #include "core/HTMLNames.h"
  #include "core/InputTypeNames.h"
  #include "core/css/CSSStyleDeclaration.h"
  #include "core/dom/Document.h"
  #include "core/dom/DocumentMarkerController.h"
  #include "core/editing/Editor.h"
  #include "core/editing/SpellChecker.h"
  #include "core/frame/FrameHost.h"
  #include "core/frame/FrameView.h"
  #include "core/frame/PinchViewport.h"
  #include "core/frame/Settings.h"
  #include "core/html/HTMLAnchorElement.h"
  #include "core/html/HTMLFormElement.h"
  #include "core/html/HTMLInputElement.h"
  #include "core/html/HTMLMediaElement.h"
  #include "core/html/HTMLPlugInElement.h"
  #include "core/html/MediaError.h"
  #include "core/loader/DocumentLoader.h"
  #include "core/loader/FrameLoader.h"
  #include "core/loader/HistoryItem.h"
  #include "core/page/ContextMenuController.h"
  #include "core/page/EventHandler.h"
  #include "core/page/Page.h"
  #include "core/rendering/HitTestResult.h"
  #include "core/rendering/RenderWidget.h"
  #include "platform/ContextMenu.h"
  #include "platform/Widget.h"
  #include "platform/text/TextBreakIterator.h"
  #include "platform/weborigin/KURL.h"
  #include "public/platform/WebPoint.h"
  #include "public/platform/WebString.h"
  #include "public/platform/WebURL.h"
  #include "public/platform/WebURLResponse.h"
  #include "public/platform/WebVector.h"
  #include "public/web/WebContextMenuData.h"
  #include "public/web/WebFormElement.h"
  #include "public/web/WebFrameClient.h"
  #include "public/web/WebMenuItemInfo.h"
  #include "public/web/WebPlugin.h"
  #include "public/web/WebSearchableFormData.h"
  #include "public/web/WebSpellCheckClient.h"
  #include "public/web/WebViewClient.h"
  #include "web/WebDataSourceImpl.h"
  #include "web/WebLocalFrameImpl.h"
  #include "web/WebPluginContainerImpl.h"
  #include "web/WebViewImpl.h"
  #include "wtf/text/WTFString.h"
  
  namespace blink {
  
  // Figure out the URL of a page or subframe. Returns |page_type| as the type,
  // which indicates page or subframe, or ContextNodeType::NONE if the URL could not
  // be determined for some reason.
  static WebURL urlFromFrame(LocalFrame* frame)
  {
      if (frame) {
          DocumentLoader* dl = frame->loader().documentLoader();
          if (dl) {
              WebDataSource* ds = WebDataSourceImpl::fromDocumentLoader(dl);
              if (ds)
                  return ds->hasUnreachableURL() ? ds->unreachableURL() : ds->request().url();
          }
      }
      return WebURL();
  }
  
  // Helper function to determine whether text is a single word.
  static bool isASingleWord(const String& text)
  {
      TextBreakIterator* it = wordBreakIterator(text, 0, text.length());
      return it && it->next() == static_cast<int>(text.length());
  }
  
  // Helper function to get misspelled word on which context menu
  // is to be invoked. This function also sets the word on which context menu
  // has been invoked to be the selected word, as required. This function changes
  // the selection only when there were no selected characters on OS X.
  static String selectMisspelledWord(LocalFrame* selectedFrame)
  {
      // First select from selectedText to check for multiple word selection.
      String misspelledWord = selectedFrame->selectedText().stripWhiteSpace();
  
      // If some texts were already selected, we don't change the selection.
      if (!misspelledWord.isEmpty()) {
          // Don't provide suggestions for multiple words.
          if (!isASingleWord(misspelledWord))
              return String();
          return misspelledWord;
      }
  
      // Selection is empty, so change the selection to the word under the cursor.
      HitTestResult hitTestResult = selectedFrame->eventHandler().
          hitTestResultAtPoint(selectedFrame->page()->contextMenuController().hitTestResult().pointInInnerNodeFrame());
      Node* innerNode = hitTestResult.innerNode();
      VisiblePosition pos(innerNode->renderer()->positionForPoint(
          hitTestResult.localPoint()));
  
      if (pos.isNull())
          return misspelledWord; // It is empty.
  
      WebLocalFrameImpl::selectWordAroundPosition(selectedFrame, pos);
      misspelledWord = selectedFrame->selectedText().stripWhiteSpace();
  
  #if OS(MACOSX)
      // If misspelled word is still empty, then that portion should not be
      // selected. Set the selection to that position only, and do not expand.
      if (misspelledWord.isEmpty())
          selectedFrame->selection().setSelection(VisibleSelection(pos));
  #else
      // On non-Mac, right-click should not make a range selection in any case.
      selectedFrame->selection().setSelection(VisibleSelection(pos));
  #endif
      return misspelledWord;
  }
  
  static bool IsWhiteSpaceOrPunctuation(UChar c)
  {
      return isSpaceOrNewline(c) || WTF::Unicode::isPunct(c);
  }
  
  static String selectMisspellingAsync(LocalFrame* selectedFrame, String& description, uint32_t& hash)
  {
      VisibleSelection selection = selectedFrame->selection().selection();
      if (!selection.isCaretOrRange())
          return String();
  
      // Caret and range selections always return valid normalized ranges.
      RefPtrWillBeRawPtr<Range> selectionRange = selection.toNormalizedRange();
      DocumentMarkerVector markers = selectedFrame->document()->markers().markersInRange(selectionRange.get(), DocumentMarker::MisspellingMarkers());
      if (markers.size() != 1)
          return String();
      description = markers[0]->description();
      hash = markers[0]->hash();
  
      // Cloning a range fails only for invalid ranges.
      RefPtrWillBeRawPtr<Range> markerRange = selectionRange->cloneRange();
      markerRange->setStart(markerRange->startContainer(), markers[0]->startOffset());
      markerRange->setEnd(markerRange->endContainer(), markers[0]->endOffset());
  
      if (markerRange->text().stripWhiteSpace(&IsWhiteSpaceOrPunctuation) != selectionRange->text().stripWhiteSpace(&IsWhiteSpaceOrPunctuation))
          return String();
  
      return markerRange->text();
  }
  
  void ContextMenuClientImpl::showContextMenu(const ContextMenu* defaultMenu)
  {
      // Displaying the context menu in this function is a big hack as we don't
      // have context, i.e. whether this is being invoked via a script or in
      // response to user input (Mouse event WM_RBUTTONDOWN,
      // Keyboard events KeyVK_APPS, Shift+F10). Check if this is being invoked
      // in response to the above input events before popping up the context menu.
      if (!m_webView->contextMenuAllowed())
          return;
  
      HitTestResult r = m_webView->page()->contextMenuController().hitTestResult();
  
      r.setToShadowHostIfInUserAgentShadowRoot();
  
      LocalFrame* selectedFrame = r.innerNodeFrame();
  
      WebContextMenuData data;
      IntPoint mousePoint = selectedFrame->view()->contentsToWindow(r.roundedPointInInnerNodeFrame());
  
      // FIXME(bokan): crbug.com/371902 - We shouldn't be making these scale
      // related coordinate transformatios in an ad hoc way.
      PinchViewport& pinchViewport = selectedFrame->host()->pinchViewport();
      mousePoint -= flooredIntSize(pinchViewport.visibleRect().location());
      mousePoint.scale(m_webView->pageScaleFactor(), m_webView->pageScaleFactor());
      data.mousePosition = mousePoint;
  
      // Compute edit flags.
      data.editFlags = WebContextMenuData::CanDoNone;
      if (toLocalFrame(m_webView->focusedCoreFrame())->editor().canUndo())
          data.editFlags |= WebContextMenuData::CanUndo;
      if (toLocalFrame(m_webView->focusedCoreFrame())->editor().canRedo())
          data.editFlags |= WebContextMenuData::CanRedo;
      if (toLocalFrame(m_webView->focusedCoreFrame())->editor().canCut())
          data.editFlags |= WebContextMenuData::CanCut;
      if (toLocalFrame(m_webView->focusedCoreFrame())->editor().canCopy())
          data.editFlags |= WebContextMenuData::CanCopy;
      if (toLocalFrame(m_webView->focusedCoreFrame())->editor().canPaste())
          data.editFlags |= WebContextMenuData::CanPaste;
      if (toLocalFrame(m_webView->focusedCoreFrame())->editor().canDelete())
          data.editFlags |= WebContextMenuData::CanDelete;
      if (isHTMLTextFormControlElement(r.innerNonSharedNode())) {
          if (!toHTMLTextFormControlElement(r.innerNonSharedNode())->value().isEmpty())
              data.editFlags |= WebContextMenuData::CanSelectAll;
      }
      data.editFlags |= WebContextMenuData::CanTranslate;
  
      // Links, Images, Media tags, and Image/Media-Links take preference over
      // all else.
      data.linkURL = r.absoluteLinkURL();
  
      if (isHTMLCanvasElement(r.innerNonSharedNode())) {
          data.mediaType = WebContextMenuData::MediaTypeCanvas;
          data.hasImageContents = true;
      } else if (!r.absoluteImageURL().isEmpty()) {
          data.srcURL = r.absoluteImageURL();
          data.mediaType = WebContextMenuData::MediaTypeImage;
          data.mediaFlags |= WebContextMenuData::MediaCanPrint;
  
          // An image can be null for many reasons, like being blocked, no image
          // data received from server yet.
          data.hasImageContents = r.image() && !r.image()->isNull();
      } else if (!r.absoluteMediaURL().isEmpty()) {
          data.srcURL = r.absoluteMediaURL();
  
          // We know that if absoluteMediaURL() is not empty, then this
          // is a media element.
          HTMLMediaElement* mediaElement = toHTMLMediaElement(r.innerNonSharedNode());
          if (isHTMLVideoElement(*mediaElement))
              data.mediaType = WebContextMenuData::MediaTypeVideo;
          else if (isHTMLAudioElement(*mediaElement))
              data.mediaType = WebContextMenuData::MediaTypeAudio;
  
          if (mediaElement->error())
              data.mediaFlags |= WebContextMenuData::MediaInError;
          if (mediaElement->paused())
              data.mediaFlags |= WebContextMenuData::MediaPaused;
          if (mediaElement->muted())
              data.mediaFlags |= WebContextMenuData::MediaMuted;
          if (mediaElement->loop())
              data.mediaFlags |= WebContextMenuData::MediaLoop;
          if (mediaElement->supportsSave())
              data.mediaFlags |= WebContextMenuData::MediaCanSave;
          if (mediaElement->hasAudio())
              data.mediaFlags |= WebContextMenuData::MediaHasAudio;
          // Media controls can be toggled only for video player. If we toggle
          // controls for audio then the player disappears, and there is no way to
          // return it back. Don't set this bit for fullscreen video, since
          // toggling is ignored in that case.
          if (mediaElement->hasVideo() && !mediaElement->isFullscreen())
              data.mediaFlags |= WebContextMenuData::MediaCanToggleControls;
          if (mediaElement->shouldShowControls())
              data.mediaFlags |= WebContextMenuData::MediaControls;
      } else if (isHTMLObjectElement(*r.innerNonSharedNode()) || isHTMLEmbedElement(*r.innerNonSharedNode())) {
          RenderObject* object = r.innerNonSharedNode()->renderer();
          if (object && object->isWidget()) {
              Widget* widget = toRenderWidget(object)->widget();
              if (widget && widget->isPluginContainer()) {
                  data.mediaType = WebContextMenuData::MediaTypePlugin;
                  WebPluginContainerImpl* plugin = toWebPluginContainerImpl(widget);
                  WebString text = plugin->plugin()->selectionAsText();
                  if (!text.isEmpty()) {
                      data.selectedText = text;
                      data.editFlags |= WebContextMenuData::CanCopy;
                  }
                  data.editFlags &= ~WebContextMenuData::CanTranslate;
                  data.linkURL = plugin->plugin()->linkAtPosition(data.mousePosition);
                  if (plugin->plugin()->supportsPaginatedPrint())
                      data.mediaFlags |= WebContextMenuData::MediaCanPrint;
  
                  HTMLPlugInElement* pluginElement = toHTMLPlugInElement(r.innerNonSharedNode());
                  data.srcURL = pluginElement->document().completeURL(pluginElement->url());
                  data.mediaFlags |= WebContextMenuData::MediaCanSave;
  
                  // Add context menu commands that are supported by the plugin.
                  if (plugin->plugin()->canRotateView())
                      data.mediaFlags |= WebContextMenuData::MediaCanRotate;
              }
          }
      }
  
      // If it's not a link, an image, a media element, or an image/media link,
      // show a selection menu or a more generic page menu.
      if (selectedFrame->document()->loader())
          data.frameEncoding = selectedFrame->document()->encodingName();
  
      // Send the frame and page URLs in any case.
      data.pageURL = urlFromFrame(m_webView->mainFrameImpl()->frame());
      if (selectedFrame != m_webView->mainFrameImpl()->frame()) {
          data.frameURL = urlFromFrame(selectedFrame);
          RefPtr<HistoryItem> historyItem = selectedFrame->loader().currentItem();
          if (historyItem)
              data.frameHistoryItem = WebHistoryItem(historyItem);
      }
  
      if (r.isSelected()) {
          if (!isHTMLInputElement(*r.innerNonSharedNode()) || toHTMLInputElement(r.innerNonSharedNode())->type() != InputTypeNames::password)
              data.selectedText = selectedFrame->selectedText().stripWhiteSpace();
      }
  
      if (r.isContentEditable()) {
          data.isEditable = true;
  
          // When Chrome enables asynchronous spellchecking, its spellchecker adds spelling markers to misspelled
          // words and attaches suggestions to these markers in the background. Therefore, when a user right-clicks
          // a mouse on a word, Chrome just needs to find a spelling marker on the word instead of spellchecking it.
          if (selectedFrame->settings() && selectedFrame->settings()->asynchronousSpellCheckingEnabled()) {
              String description;
              uint32_t hash = 0;
              data.misspelledWord = selectMisspellingAsync(selectedFrame, description, hash);
              data.misspellingHash = hash;
              if (description.length()) {
                  Vector<String> suggestions;
                  description.split('\n', suggestions);
                  data.dictionarySuggestions = suggestions;
              } else if (m_webView->spellCheckClient()) {
                  int misspelledOffset, misspelledLength;
                  m_webView->spellCheckClient()->spellCheck(data.misspelledWord, misspelledOffset, misspelledLength, &data.dictionarySuggestions);
              }
          } else {
              data.isSpellCheckingEnabled =
                  toLocalFrame(m_webView->focusedCoreFrame())->spellChecker().isContinuousSpellCheckingEnabled();
              // Spellchecking might be enabled for the field, but could be disabled on the node.
              if (toLocalFrame(m_webView->focusedCoreFrame())->spellChecker().isSpellCheckingEnabledInFocusedNode()) {
                  data.misspelledWord = selectMisspelledWord(selectedFrame);
                  if (m_webView->spellCheckClient()) {
                      int misspelledOffset, misspelledLength;
                      m_webView->spellCheckClient()->spellCheck(
                          data.misspelledWord, misspelledOffset, misspelledLength,
                          &data.dictionarySuggestions);
                      if (!misspelledLength)
                          data.misspelledWord.reset();
                  }
              }
          }
          HTMLFormElement* form = selectedFrame->selection().currentForm();
          if (form && isHTMLInputElement(*r.innerNonSharedNode())) {
              HTMLInputElement& selectedElement = toHTMLInputElement(*r.innerNonSharedNode());
              WebSearchableFormData ws = WebSearchableFormData(WebFormElement(form), WebInputElement(&selectedElement));
              if (ws.url().isValid())
                  data.keywordURL = ws.url();
          }
      }
  
      if (selectedFrame->editor().selectionHasStyle(CSSPropertyDirection, "ltr") != FalseTriState)
          data.writingDirectionLeftToRight |= WebContextMenuData::CheckableMenuItemChecked;
      if (selectedFrame->editor().selectionHasStyle(CSSPropertyDirection, "rtl") != FalseTriState)
          data.writingDirectionRightToLeft |= WebContextMenuData::CheckableMenuItemChecked;
  
      // Now retrieve the security info.
      DocumentLoader* dl = selectedFrame->loader().documentLoader();
      WebDataSource* ds = WebDataSourceImpl::fromDocumentLoader(dl);
      if (ds)
          data.securityInfo = ds->response().securityInfo();
  
      data.referrerPolicy = static_cast<WebReferrerPolicy>(selectedFrame->document()->referrerPolicy());
  
      // Filter out custom menu elements and add them into the data.
      populateCustomMenuItems(defaultMenu, &data);
  
      // Extract suggested filename for saving file.
      if (isHTMLAnchorElement(r.URLElement())) {
          HTMLAnchorElement* anchor = toHTMLAnchorElement(r.URLElement());
          data.suggestedFilename = anchor->fastGetAttribute(HTMLNames::downloadAttr);
      }
  
      data.node = r.innerNonSharedNode();
  
      WebLocalFrameImpl* selectedWebFrame = WebLocalFrameImpl::fromFrame(selectedFrame);
      if (selectedWebFrame->client())
          selectedWebFrame->client()->showContextMenu(data);
  }
  
  void ContextMenuClientImpl::clearContextMenu()
  {
      HitTestResult r = m_webView->page()->contextMenuController().hitTestResult();
      LocalFrame* selectedFrame = r.innerNodeFrame();
      if (!selectedFrame)
          return;
  
      WebLocalFrameImpl* selectedWebFrame = WebLocalFrameImpl::fromFrame(selectedFrame);
      if (selectedWebFrame->client())
          selectedWebFrame->client()->clearContextMenu();
  }
  
  static void populateSubMenuItems(const Vector<ContextMenuItem>& inputMenu, WebVector<WebMenuItemInfo>& subMenuItems)
  {
      Vector<WebMenuItemInfo> subItems;
      for (size_t i = 0; i < inputMenu.size(); ++i) {
          const ContextMenuItem* inputItem = &inputMenu.at(i);
          if (inputItem->action() < ContextMenuItemBaseCustomTag || inputItem->action() > ContextMenuItemLastCustomTag)
              continue;
  
          WebMenuItemInfo outputItem;
          outputItem.label = inputItem->title();
          outputItem.enabled = inputItem->enabled();
          outputItem.checked = inputItem->checked();
          outputItem.action = static_cast<unsigned>(inputItem->action() - ContextMenuItemBaseCustomTag);
          switch (inputItem->type()) {
          case ActionType:
              outputItem.type = WebMenuItemInfo::Option;
              break;
          case CheckableActionType:
              outputItem.type = WebMenuItemInfo::CheckableOption;
              break;
          case SeparatorType:
              outputItem.type = WebMenuItemInfo::Separator;
              break;
          case SubmenuType:
              outputItem.type = WebMenuItemInfo::SubMenu;
              populateSubMenuItems(inputItem->subMenuItems(), outputItem.subMenuItems);
              break;
          }
          subItems.append(outputItem);
      }
  
      WebVector<WebMenuItemInfo> outputItems(subItems.size());
      for (size_t i = 0; i < subItems.size(); ++i)
          outputItems[i] = subItems[i];
      subMenuItems.swap(outputItems);
  }
  
  void ContextMenuClientImpl::populateCustomMenuItems(const ContextMenu* defaultMenu, WebContextMenuData* data)
  {
      populateSubMenuItems(defaultMenu->items(), data->customItems);
  }
  
  } // namespace blink
  