dom/html/nsGenericHTMLFrameElement.cpp

   1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
   3 /* This Source Code Form is subject to the terms of the Mozilla Public
   4  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   5  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   6
   7 #include "nsGenericHTMLFrameElement.h"
   8
   9 #include "mozilla/dom/Document.h"
  10 #include "mozilla/dom/HTMLIFrameElement.h"
  11 #include "mozilla/dom/XULFrameElement.h"
  12 #include "mozilla/dom/BrowserBridgeChild.h"
  13 #include "mozilla/dom/WindowProxyHolder.h"
  14 #include "mozilla/Preferences.h"
  15 #include "mozilla/PresShell.h"
  16 #include "mozilla/ProfilerLabels.h"
  17 #include "mozilla/StaticPrefs_dom.h"
  18 #include "mozilla/ErrorResult.h"
  19 #include "nsAttrValueInlines.h"
  20 #include "nsContentUtils.h"
  21 #include "nsIDocShell.h"
  22 #include "nsIFrame.h"
  23 #include "nsIInterfaceRequestorUtils.h"
  24 #include "nsIPermissionManager.h"
  25 #include "nsPresContext.h"
  26 #include "nsServiceManagerUtils.h"
  27 #include "nsSubDocumentFrame.h"
  28 #include "nsAttrValueOrString.h"
  29
  30 using namespace mozilla;
  31 using namespace mozilla::dom;
  32
  33 NS_IMPL_CYCLE_COLLECTION_CLASS(nsGenericHTMLFrameElement)
  34
  35 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN_INHERITED(nsGenericHTMLFrameElement,
  36                                                   nsGenericHTMLElement)
  37   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mFrameLoader)
  38 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
  39
  40 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN_INHERITED(nsGenericHTMLFrameElement,
  41                                                 nsGenericHTMLElement)
  42   if (tmp->mFrameLoader) {
  43     tmp->mFrameLoader->Destroy();
  44   }
  45
  46   NS_IMPL_CYCLE_COLLECTION_UNLINK(mFrameLoader)
  47 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
  48
  49 NS_IMPL_ISUPPORTS_CYCLE_COLLECTION_INHERITED(nsGenericHTMLFrameElement,
  50                                              nsGenericHTMLElement,
  51                                              nsFrameLoaderOwner,
  52                                              nsGenericHTMLFrameElement)
  53
  54 int32_t nsGenericHTMLFrameElement::TabIndexDefault() { return 0; }
  55
  56 nsGenericHTMLFrameElement::~nsGenericHTMLFrameElement() {
  57   if (mFrameLoader) {
  58     mFrameLoader->Destroy();
  59   }
  60 }
  61
  62 Document* nsGenericHTMLFrameElement::GetContentDocument(
  63     nsIPrincipal& aSubjectPrincipal) {
  64   RefPtr<BrowsingContext> bc = GetContentWindowInternal();
  65   if (!bc) {
  66     return nullptr;
  67   }
  68
  69   nsPIDOMWindowOuter* window = bc->GetDOMWindow();
  70   if (!window) {
  71     // Either our browsing context contents are out-of-process (in which case
  72     // clearly this is a cross-origin call and we should return null), or our
  73     // browsing context is torn-down enough to no longer have a window or a
  74     // document, and we should still return null.
  75     return nullptr;
  76   }
  77   Document* doc = window->GetDoc();
  78   if (!doc) {
  79     return nullptr;
  80   }
  81
  82   // Return null for cross-origin contentDocument.
  83   if (!aSubjectPrincipal.SubsumesConsideringDomain(doc->NodePrincipal())) {
  84     return nullptr;
  85   }
  86   return doc;
  87 }
  88
  89 BrowsingContext* nsGenericHTMLFrameElement::GetContentWindowInternal() {
  90   EnsureFrameLoader();
  91
  92   if (!mFrameLoader) {
  93     return nullptr;
  94   }
  95
  96   if (mFrameLoader->DepthTooGreat()) {
  97     // Claim to have no contentWindow
  98     return nullptr;
  99   }
 100
 101   RefPtr<BrowsingContext> bc = mFrameLoader->GetBrowsingContext();
 102   return bc;
 103 }
 104
 105 Nullable<WindowProxyHolder> nsGenericHTMLFrameElement::GetContentWindow() {
 106   RefPtr<BrowsingContext> bc = GetContentWindowInternal();
 107   if (!bc) {
 108     return nullptr;
 109   }
 110   return WindowProxyHolder(bc);
 111 }
 112
 113 void nsGenericHTMLFrameElement::EnsureFrameLoader() {
 114   if (!IsInComposedDoc() || mFrameLoader || OwnerDoc()->IsStaticDocument()) {
 115     // If frame loader is there, we just keep it around, cached
 116     return;
 117   }
 118
 119   // Strangely enough, this method doesn't actually ensure that the
 120   // frameloader exists.  It's more of a best-effort kind of thing.
 121   mFrameLoader = nsFrameLoader::Create(this, mNetworkCreated);
 122 }
 123
 124 void nsGenericHTMLFrameElement::SwapFrameLoaders(
 125     HTMLIFrameElement& aOtherLoaderOwner, ErrorResult& rv) {
 126   if (&aOtherLoaderOwner == this) {
 127     // nothing to do
 128     return;
 129   }
 130
 131   aOtherLoaderOwner.SwapFrameLoaders(this, rv);
 132 }
 133
 134 void nsGenericHTMLFrameElement::SwapFrameLoaders(
 135     XULFrameElement& aOtherLoaderOwner, ErrorResult& rv) {
 136   aOtherLoaderOwner.SwapFrameLoaders(this, rv);
 137 }
 138
 139 void nsGenericHTMLFrameElement::SwapFrameLoaders(
 140     nsFrameLoaderOwner* aOtherLoaderOwner, mozilla::ErrorResult& rv) {
 141   if (RefPtr<Document> doc = GetComposedDoc()) {
 142     // SwapWithOtherLoader relies on frames being up-to-date.
 143     doc->FlushPendingNotifications(FlushType::Frames);
 144   }
 145
 146   RefPtr<nsFrameLoader> loader = GetFrameLoader();
 147   RefPtr<nsFrameLoader> otherLoader = aOtherLoaderOwner->GetFrameLoader();
 148   if (!loader || !otherLoader) {
 149     rv.Throw(NS_ERROR_NOT_IMPLEMENTED);
 150     return;
 151   }
 152
 153   rv = loader->SwapWithOtherLoader(otherLoader, this, aOtherLoaderOwner);
 154 }
 155
 156 void nsGenericHTMLFrameElement::LoadSrc() {
 157   // Waiting for lazy load, do nothing.
 158   if (mLazyLoading) {
 159     return;
 160   }
 161
 162   EnsureFrameLoader();
 163
 164   if (!mFrameLoader) {
 165     return;
 166   }
 167
 168   bool origSrc = !mSrcLoadHappened;
 169   mSrcLoadHappened = true;
 170   mFrameLoader->LoadFrame(origSrc);
 171 }
 172
 173 nsresult nsGenericHTMLFrameElement::BindToTree(BindContext& aContext,
 174                                                nsINode& aParent) {
 175   nsresult rv = nsGenericHTMLElement::BindToTree(aContext, aParent);
 176   NS_ENSURE_SUCCESS(rv, rv);
 177
 178   if (IsInComposedDoc()) {
 179     NS_ASSERTION(!nsContentUtils::IsSafeToRunScript(),
 180                  "Missing a script blocker!");
 181
 182     AUTO_PROFILER_LABEL("nsGenericHTMLFrameElement::BindToTree", OTHER);
 183
 184     // We're in a document now.  Kick off the frame load.
 185     LoadSrc();
 186   }
 187
 188   // We're now in document and scripts may move us, so clear
 189   // the mNetworkCreated flag.
 190   mNetworkCreated = false;
 191   return rv;
 192 }
 193
 194 void nsGenericHTMLFrameElement::UnbindFromTree(UnbindContext& aContext) {
 195   if (mFrameLoader) {
 196     // This iframe is being taken out of the document, destroy the
 197     // iframe's frame loader (doing that will tear down the window in
 198     // this iframe).
 199     // XXXbz we really want to only partially destroy the frame
 200     // loader... we don't want to tear down the docshell.  Food for
 201     // later bug.
 202     mFrameLoader->Destroy();
 203     mFrameLoader = nullptr;
 204   }
 205
 206   nsGenericHTMLElement::UnbindFromTree(aContext);
 207 }
 208
 209 /* static */
 210 ScrollbarPreference nsGenericHTMLFrameElement::MapScrollingAttribute(
 211     const nsAttrValue* aValue) {
 212   if (aValue && aValue->Type() == nsAttrValue::eEnum) {
 213     auto scrolling = static_cast<ScrollingAttribute>(aValue->GetEnumValue());
 214     if (scrolling == ScrollingAttribute::Off ||
 215         scrolling == ScrollingAttribute::Noscroll ||
 216         scrolling == ScrollingAttribute::No) {
 217       return ScrollbarPreference::Never;
 218     }
 219   }
 220   return ScrollbarPreference::Auto;
 221 }
 222
 223 /* virtual */
 224 void nsGenericHTMLFrameElement::AfterSetAttr(
 225     int32_t aNameSpaceID, nsAtom* aName, const nsAttrValue* aValue,
 226     const nsAttrValue* aOldValue, nsIPrincipal* aMaybeScriptedPrincipal,
 227     bool aNotify) {
 228   if (aValue) {
 229     nsAttrValueOrString value(aValue);
 230     AfterMaybeChangeAttr(aNameSpaceID, aName, &value, aMaybeScriptedPrincipal,
 231                          aNotify);
 232   } else {
 233     AfterMaybeChangeAttr(aNameSpaceID, aName, nullptr, aMaybeScriptedPrincipal,
 234                          aNotify);
 235   }
 236
 237   if (aNameSpaceID == kNameSpaceID_None) {
 238     if (aName == nsGkAtoms::scrolling) {
 239       if (mFrameLoader) {
 240         ScrollbarPreference pref = MapScrollingAttribute(aValue);
 241         if (nsDocShell* docshell = mFrameLoader->GetExistingDocShell()) {
 242           docshell->SetScrollbarPreference(pref);
 243         } else if (auto* child = mFrameLoader->GetBrowserBridgeChild()) {
 244           // NOTE(emilio): We intentionally don't deal with the
 245           // GetBrowserParent() case, and only deal with the fission iframe
 246           // case. We could make it work, but it's a bit of boilerplate for
 247           // something that we don't use, and we'd need to think how it
 248           // interacts with the scrollbar window flags...
 249           child->SendScrollbarPreferenceChanged(pref);
 250         }
 251       }
 252     }
 253   }
 254
 255   return nsGenericHTMLElement::AfterSetAttr(
 256       aNameSpaceID, aName, aValue, aOldValue, aMaybeScriptedPrincipal, aNotify);
 257 }
 258
 259 void nsGenericHTMLFrameElement::OnAttrSetButNotChanged(
 260     int32_t aNamespaceID, nsAtom* aName, const nsAttrValueOrString& aValue,
 261     bool aNotify) {
 262   AfterMaybeChangeAttr(aNamespaceID, aName, &aValue, nullptr, aNotify);
 263
 264   return nsGenericHTMLElement::OnAttrSetButNotChanged(aNamespaceID, aName,
 265                                                       aValue, aNotify);
 266 }
 267
 268 void nsGenericHTMLFrameElement::AfterMaybeChangeAttr(
 269     int32_t aNamespaceID, nsAtom* aName, const nsAttrValueOrString* aValue,
 270     nsIPrincipal* aMaybeScriptedPrincipal, bool aNotify) {
 271   if (aNamespaceID == kNameSpaceID_None) {
 272     if (aName == nsGkAtoms::src) {
 273       mSrcTriggeringPrincipal = nsContentUtils::GetAttrTriggeringPrincipal(
 274           this, aValue ? aValue->String() : u""_ns, aMaybeScriptedPrincipal);
 275       if (!IsHTMLElement(nsGkAtoms::iframe) || !HasAttr(nsGkAtoms::srcdoc)) {
 276         // Don't propagate error here. The attribute was successfully
 277         // set or removed; that's what we should reflect.
 278         LoadSrc();
 279       }
 280     } else if (aName == nsGkAtoms::name) {
 281       // Propagate "name" to the browsing context per HTML5.
 282       RefPtr<BrowsingContext> bc =
 283           mFrameLoader ? mFrameLoader->GetExtantBrowsingContext() : nullptr;
 284       if (bc) {
 285         MOZ_ALWAYS_SUCCEEDS(bc->SetName(aValue ? aValue->String() : u""_ns));
 286       }
 287     }
 288   }
 289 }
 290
 291 void nsGenericHTMLFrameElement::DestroyContent() {
 292   if (mFrameLoader) {
 293     mFrameLoader->Destroy();
 294     mFrameLoader = nullptr;
 295   }
 296
 297   nsGenericHTMLElement::DestroyContent();
 298 }
 299
 300 nsresult nsGenericHTMLFrameElement::CopyInnerTo(Element* aDest) {
 301   nsresult rv = nsGenericHTMLElement::CopyInnerTo(aDest);
 302   NS_ENSURE_SUCCESS(rv, rv);
 303
 304   Document* doc = aDest->OwnerDoc();
 305   if (doc->IsStaticDocument() && mFrameLoader) {
 306     nsGenericHTMLFrameElement* dest =
 307         static_cast<nsGenericHTMLFrameElement*>(aDest);
 308     doc->AddPendingFrameStaticClone(dest, mFrameLoader);
 309   }
 310
 311   return rv;
 312 }
 313
 314 bool nsGenericHTMLFrameElement::IsHTMLFocusable(bool aWithMouse,
 315                                                 bool* aIsFocusable,
 316                                                 int32_t* aTabIndex) {
 317   if (nsGenericHTMLElement::IsHTMLFocusable(aWithMouse, aIsFocusable,
 318                                             aTabIndex)) {
 319     return true;
 320   }
 321
 322   *aIsFocusable = true;
 323   return false;
 324 }