embedding/browser/nsContextMenuInfo.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #include "nsContextMenuInfo.h"
   7
   8 #include "nsIImageLoadingContent.h"
   9 #include "imgLoader.h"
  10 #include "nsIDOMDocument.h"
  11 #include "nsIDOMHTMLDocument.h"
  12 #include "nsIDOMHTMLElement.h"
  13 #include "nsIDOMHTMLHtmlElement.h"
  14 #include "nsIDOMHTMLAnchorElement.h"
  15 #include "nsIDOMHTMLImageElement.h"
  16 #include "nsIDOMHTMLAreaElement.h"
  17 #include "nsIDOMHTMLLinkElement.h"
  18 #include "nsIDOMWindow.h"
  19 #include "nsIDOMCSSStyleDeclaration.h"
  20 #include "nsIDOMCSSValue.h"
  21 #include "nsIDOMCSSPrimitiveValue.h"
  22 #include "nsNetUtil.h"
  23 #include "nsUnicharUtils.h"
  24 #include "nsIDocument.h"
  25 #include "nsIPrincipal.h"
  26 #include "nsIContentSecurityPolicy.h"
  27 #include "nsIContentPolicy.h"
  28 #include "nsAutoPtr.h"
  29 #include "imgRequestProxy.h"
  30
  31
  32 //*****************************************************************************
  33 // class nsContextMenuInfo
  34 //*****************************************************************************
  35
  36 NS_IMPL_ISUPPORTS(nsContextMenuInfo, nsIContextMenuInfo)
  37
  38 nsContextMenuInfo::nsContextMenuInfo()
  39 {
  40 }
  41
  42 nsContextMenuInfo::~nsContextMenuInfo()
  43 {
  44 }
  45
  46 /* readonly attribute nsIDOMEvent mouseEvent; */
  47 NS_IMETHODIMP
  48 nsContextMenuInfo::GetMouseEvent(nsIDOMEvent **aEvent)
  49 {
  50   NS_ENSURE_ARG_POINTER(aEvent);
  51   NS_IF_ADDREF(*aEvent = mMouseEvent);
  52   return NS_OK;
  53 }
  54
  55 /* readonly attribute nsIDOMNode targetNode; */
  56 NS_IMETHODIMP
  57 nsContextMenuInfo::GetTargetNode(nsIDOMNode **aNode)
  58 {
  59   NS_ENSURE_ARG_POINTER(aNode);
  60   NS_IF_ADDREF(*aNode = mDOMNode);
  61   return NS_OK;
  62 }
  63
  64 /* readonly attribute AString associatedLink; */
  65 NS_IMETHODIMP
  66 nsContextMenuInfo::GetAssociatedLink(nsAString& aHRef)
  67 {
  68   NS_ENSURE_STATE(mAssociatedLink);
  69   aHRef.Truncate(0);
  70
  71   nsCOMPtr<nsIDOMElement> content(do_QueryInterface(mAssociatedLink));
  72   nsAutoString localName;
  73   if (content)
  74     content->GetLocalName(localName);
  75
  76   nsCOMPtr<nsIDOMElement> linkContent;
  77   ToLowerCase(localName);
  78   if (localName.EqualsLiteral("a") ||
  79       localName.EqualsLiteral("area") ||
  80       localName.EqualsLiteral("link")) {
  81     bool hasAttr;
  82     content->HasAttribute(NS_LITERAL_STRING("href"), &hasAttr);
  83     if (hasAttr) {
  84       linkContent = content;
  85       nsCOMPtr<nsIDOMHTMLAnchorElement> anchor(do_QueryInterface(linkContent));
  86       if (anchor)
  87         anchor->GetHref(aHRef);
  88       else {
  89         nsCOMPtr<nsIDOMHTMLAreaElement> area(do_QueryInterface(linkContent));
  90         if (area)
  91           area->GetHref(aHRef);
  92         else {
  93           nsCOMPtr<nsIDOMHTMLLinkElement> link(do_QueryInterface(linkContent));
  94           if (link)
  95             link->GetHref(aHRef);
  96         }
  97       }
  98     }
  99   }
 100   else {
 101     nsCOMPtr<nsIDOMNode> curr;
 102     mAssociatedLink->GetParentNode(getter_AddRefs(curr));
 103     while (curr) {
 104       content = do_QueryInterface(curr);
 105       if (!content)
 106         break;
 107       content->GetLocalName(localName);
 108       ToLowerCase(localName);
 109       if (localName.EqualsLiteral("a")) {
 110         bool hasAttr;
 111         content->HasAttribute(NS_LITERAL_STRING("href"), &hasAttr);
 112         if (hasAttr) {
 113           linkContent = content;
 114           nsCOMPtr<nsIDOMHTMLAnchorElement> anchor(do_QueryInterface(linkContent));
 115           if (anchor)
 116             anchor->GetHref(aHRef);
 117         }
 118         else
 119           linkContent = nullptr; // Links can't be nested.
 120         break;
 121       }
 122
 123       nsCOMPtr<nsIDOMNode> temp = curr;
 124       temp->GetParentNode(getter_AddRefs(curr));
 125     }
 126   }
 127
 128   return NS_OK;
 129 }
 130
 131 /* readonly attribute imgIContainer imageContainer; */
 132 NS_IMETHODIMP
 133 nsContextMenuInfo::GetImageContainer(imgIContainer **aImageContainer)
 134 {
 135   NS_ENSURE_ARG_POINTER(aImageContainer);
 136   NS_ENSURE_STATE(mDOMNode);
 137
 138   nsCOMPtr<imgIRequest> request;
 139   GetImageRequest(mDOMNode, getter_AddRefs(request));
 140   if (request)
 141     return request->GetImage(aImageContainer);
 142
 143   return NS_ERROR_FAILURE;
 144 }
 145
 146 /* readonly attribute nsIURI imageSrc; */
 147 NS_IMETHODIMP
 148 nsContextMenuInfo::GetImageSrc(nsIURI **aURI)
 149 {
 150   NS_ENSURE_ARG_POINTER(aURI);
 151   NS_ENSURE_STATE(mDOMNode);
 152
 153   nsCOMPtr<nsIImageLoadingContent> content(do_QueryInterface(mDOMNode));
 154   NS_ENSURE_TRUE(content, NS_ERROR_FAILURE);
 155   return content->GetCurrentURI(aURI);
 156 }
 157
 158 /* readonly attribute imgIContainer backgroundImageContainer; */
 159 NS_IMETHODIMP
 160 nsContextMenuInfo::GetBackgroundImageContainer(imgIContainer **aImageContainer)
 161 {
 162   NS_ENSURE_ARG_POINTER(aImageContainer);
 163   NS_ENSURE_STATE(mDOMNode);
 164
 165   nsRefPtr<imgRequestProxy> request;
 166   GetBackgroundImageRequest(mDOMNode, getter_AddRefs(request));
 167   if (request)
 168     return request->GetImage(aImageContainer);
 169
 170   return NS_ERROR_FAILURE;
 171 }
 172
 173 /* readonly attribute nsIURI backgroundImageSrc; */
 174 NS_IMETHODIMP
 175 nsContextMenuInfo::GetBackgroundImageSrc(nsIURI **aURI)
 176 {
 177   NS_ENSURE_ARG_POINTER(aURI);
 178   NS_ENSURE_STATE(mDOMNode);
 179
 180   nsRefPtr<imgRequestProxy> request;
 181   GetBackgroundImageRequest(mDOMNode, getter_AddRefs(request));
 182   if (request)
 183     return request->GetURI(aURI);
 184
 185   return NS_ERROR_FAILURE;
 186 }
 187
 188 //*****************************************************************************
 189
 190 nsresult
 191 nsContextMenuInfo::GetImageRequest(nsIDOMNode *aDOMNode, imgIRequest **aRequest)
 192 {
 193   NS_ENSURE_ARG(aDOMNode);
 194   NS_ENSURE_ARG_POINTER(aRequest);
 195
 196   // Get content
 197   nsCOMPtr<nsIImageLoadingContent> content(do_QueryInterface(aDOMNode));
 198   NS_ENSURE_TRUE(content, NS_ERROR_FAILURE);
 199
 200   return content->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
 201                              aRequest);
 202 }
 203
 204 bool
 205 nsContextMenuInfo::HasBackgroundImage(nsIDOMNode * aDOMNode)
 206 {
 207   NS_ENSURE_TRUE(aDOMNode, false);
 208
 209   nsRefPtr<imgRequestProxy> request;
 210   GetBackgroundImageRequest(aDOMNode, getter_AddRefs(request));
 211
 212   return (request != nullptr);
 213 }
 214
 215 nsresult
 216 nsContextMenuInfo::GetBackgroundImageRequest(nsIDOMNode *aDOMNode, imgRequestProxy **aRequest)
 217 {
 218
 219   NS_ENSURE_ARG(aDOMNode);
 220   NS_ENSURE_ARG_POINTER(aRequest);
 221
 222   nsCOMPtr<nsIDOMNode> domNode = aDOMNode;
 223
 224   // special case for the <html> element: if it has no background-image
 225   // we'll defer to <body>
 226   nsCOMPtr<nsIDOMHTMLHtmlElement> htmlElement = do_QueryInterface(domNode);
 227   if (htmlElement) {
 228     nsCOMPtr<nsIDOMHTMLElement> element = do_QueryInterface(domNode);
 229     nsAutoString nameSpace;
 230     element->GetNamespaceURI(nameSpace);
 231     if (nameSpace.IsEmpty()) {
 232       nsresult rv = GetBackgroundImageRequestInternal(domNode, aRequest);
 233       if (NS_SUCCEEDED(rv) && *aRequest)
 234         return NS_OK;
 235
 236       // no background-image found
 237       nsCOMPtr<nsIDOMDocument> document;
 238       domNode->GetOwnerDocument(getter_AddRefs(document));
 239       nsCOMPtr<nsIDOMHTMLDocument> htmlDocument(do_QueryInterface(document));
 240       NS_ENSURE_TRUE(htmlDocument, NS_ERROR_FAILURE);
 241
 242       nsCOMPtr<nsIDOMHTMLElement> body;
 243       htmlDocument->GetBody(getter_AddRefs(body));
 244       domNode = do_QueryInterface(body);
 245       NS_ENSURE_TRUE(domNode, NS_ERROR_FAILURE);
 246     }
 247   }
 248   return GetBackgroundImageRequestInternal(domNode, aRequest);
 249 }
 250
 251 nsresult
 252 nsContextMenuInfo::GetBackgroundImageRequestInternal(nsIDOMNode *aDOMNode, imgRequestProxy **aRequest)
 253 {
 254   NS_ENSURE_ARG_POINTER(aDOMNode);
 255
 256   nsCOMPtr<nsIDOMNode> domNode = aDOMNode;
 257   nsCOMPtr<nsIDOMNode> parentNode;
 258
 259   nsCOMPtr<nsIDOMDocument> document;
 260   domNode->GetOwnerDocument(getter_AddRefs(document));
 261   NS_ENSURE_TRUE(document, NS_ERROR_FAILURE);
 262
 263   nsCOMPtr<nsIDOMWindow> window;
 264   document->GetDefaultView(getter_AddRefs(window));
 265   NS_ENSURE_TRUE(window, NS_ERROR_FAILURE);
 266
 267   nsCOMPtr<nsIDOMCSSPrimitiveValue> primitiveValue;
 268   nsAutoString bgStringValue;
 269
 270   nsCOMPtr<nsIDocument> doc(do_QueryInterface(document));
 271   nsCOMPtr<nsIPrincipal> principal = doc ? doc->NodePrincipal() : nullptr;
 272
 273   while (true) {
 274     nsCOMPtr<nsIDOMElement> domElement(do_QueryInterface(domNode));
 275     // bail for the parent node of the root element or null argument
 276     if (!domElement)
 277       break;
 278
 279     nsCOMPtr<nsIDOMCSSStyleDeclaration> computedStyle;
 280     window->GetComputedStyle(domElement, EmptyString(),
 281                              getter_AddRefs(computedStyle));
 282     if (computedStyle) {
 283       nsCOMPtr<nsIDOMCSSValue> cssValue;
 284       computedStyle->GetPropertyCSSValue(NS_LITERAL_STRING("background-image"),
 285                                          getter_AddRefs(cssValue));
 286       primitiveValue = do_QueryInterface(cssValue);
 287       if (primitiveValue) {
 288         primitiveValue->GetStringValue(bgStringValue);
 289         if (!bgStringValue.EqualsLiteral("none")) {
 290           nsCOMPtr<nsIURI> bgUri;
 291           NS_NewURI(getter_AddRefs(bgUri), bgStringValue);
 292           NS_ENSURE_TRUE(bgUri, NS_ERROR_FAILURE);
 293
 294           nsRefPtr<imgLoader> il = imgLoader::GetInstance();
 295           NS_ENSURE_TRUE(il, NS_ERROR_FAILURE);
 296
 297           return il->LoadImage(bgUri, nullptr, nullptr,
 298                                doc->GetReferrerPolicy(), principal, nullptr,
 299                                nullptr, nullptr, nsIRequest::LOAD_NORMAL,
 300                                nullptr, nsIContentPolicy::TYPE_IMAGE,
 301                                EmptyString(), aRequest);
 302         }
 303       }
 304
 305       // bail if we encounter non-transparent background-color
 306       computedStyle->GetPropertyCSSValue(NS_LITERAL_STRING("background-color"),
 307                                          getter_AddRefs(cssValue));
 308       primitiveValue = do_QueryInterface(cssValue);
 309       if (primitiveValue) {
 310         primitiveValue->GetStringValue(bgStringValue);
 311         if (!bgStringValue.EqualsLiteral("transparent"))
 312           return NS_ERROR_FAILURE;
 313       }
 314     }
 315
 316     domNode->GetParentNode(getter_AddRefs(parentNode));
 317     domNode = parentNode;
 318   }
 319
 320   return NS_ERROR_FAILURE;
 321 }