Bug 1363057 - Make nsIDOMLocation an empty interface, r=mystor

dom/base/Location.cpp

@@ -283,23 +283,33 @@ Location::SetURI(nsIURI* aURI, bool aReplace)
   return NS_OK;
 }
 
-NS_IMETHODIMP
-Location::GetHash(nsAString& aHash)
+void
+Location::GetHash(nsAString& aHash,
+                  nsIPrincipal& aSubjectPrincipal,
+                  ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   aHash.SetLength(0);
 
   nsCOMPtr<nsIURI> uri;
-  nsresult rv = GetURI(getter_AddRefs(uri));
-  if (NS_FAILED(rv) || !uri) {
-    return rv;
+  aRv = GetURI(getter_AddRefs(uri));
+  if (NS_WARN_IF(aRv.Failed()) || !uri) {
+    return;
   }
 
   nsAutoCString ref;
   nsAutoString unicodeRef;
 
-  rv = uri->GetRef(ref);
+  aRv = uri->GetRef(ref);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
 
-  if (NS_SUCCEEDED(rv) && !ref.IsEmpty()) {
+  if (!ref.IsEmpty()) {
     aHash.Assign(char16_t('#'));
     AppendUTF8toUTF16(ref, aHash);
   }
@@ -312,29 +322,42 @@ Location::GetHash(nsAString& aHash)
   } else {
     mCachedHash = aHash;
   }
-
-  return rv;
 }
 
-NS_IMETHODIMP
-Location::SetHash(const nsAString& aHash)
+void
+Location::SetHash(const nsAString& aHash,
+                  nsIPrincipal& aSubjectPrincipal,
+                  ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   NS_ConvertUTF16toUTF8 hash(aHash);
   if (hash.IsEmpty() || hash.First() != char16_t('#')) {
     hash.Insert(char16_t('#'), 0);
   }
+
   nsCOMPtr<nsIURI> uri;
-  nsresult rv = GetWritableURI(getter_AddRefs(uri), &hash);
-  if (NS_FAILED(rv) || !uri) {
-    return rv;
+  aRv = GetWritableURI(getter_AddRefs(uri), &hash);
+  if (NS_WARN_IF(aRv.Failed()) || !uri) {
+    return;
   }
 
-  return SetURI(uri);
+  aRv = SetURI(uri);
 }
 
-NS_IMETHODIMP
-Location::GetHost(nsAString& aHost)
+void
+Location::GetHost(nsAString& aHost,
+                  nsIPrincipal& aSubjectPrincipal,
+                  ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   aHost.Truncate();
 
   nsCOMPtr<nsIURI> uri;
@@ -351,30 +374,42 @@ Location::GetHost(nsAString& aHost)
       AppendUTF8toUTF16(hostport, aHost);
     }
   }
-
-  return NS_OK;
 }
 
-NS_IMETHODIMP
-Location::SetHost(const nsAString& aHost)
+void
+Location::SetHost(const nsAString& aHost,
+                  nsIPrincipal& aSubjectPrincipal,
+                  ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   nsCOMPtr<nsIURI> uri;
-  nsresult rv = GetWritableURI(getter_AddRefs(uri));
-  if (NS_WARN_IF(NS_FAILED(rv) || !uri)) {
-    return rv;
+  aRv = GetWritableURI(getter_AddRefs(uri));
+  if (NS_WARN_IF(aRv.Failed()) || !uri) {
+    return;
   }
 
-  rv = uri->SetHostPort(NS_ConvertUTF16toUTF8(aHost));
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
+  aRv = uri->SetHostPort(NS_ConvertUTF16toUTF8(aHost));
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
   }
 
-  return SetURI(uri);
+  aRv = SetURI(uri);
 }
 
-NS_IMETHODIMP
-Location::GetHostname(nsAString& aHostname)
+void
+Location::GetHostname(nsAString& aHostname,
+                      nsIPrincipal& aSubjectPrincipal,
+                      ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   aHostname.Truncate();
 
   nsCOMPtr<nsIURI> uri;
@@ -382,79 +417,85 @@ Location::GetHostname(nsAString& aHostname)
   if (uri) {
     nsContentUtils::GetHostOrIPv6WithBrackets(uri, aHostname);
   }
-
-  return NS_OK;
 }
 
-NS_IMETHODIMP
-Location::SetHostname(const nsAString& aHostname)
+void
+Location::SetHostname(const nsAString& aHostname,
+                      nsIPrincipal& aSubjectPrincipal,
+                      ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   nsCOMPtr<nsIURI> uri;
-  nsresult rv = GetWritableURI(getter_AddRefs(uri));
-  if (NS_WARN_IF(NS_FAILED(rv) || !uri)) {
-    return rv;
+  aRv = GetWritableURI(getter_AddRefs(uri));
+  if (NS_WARN_IF(aRv.Failed()) || !uri) {
+    return;
   }
 
-  rv = uri->SetHost(NS_ConvertUTF16toUTF8(aHostname));
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
+  aRv = uri->SetHost(NS_ConvertUTF16toUTF8(aHostname));
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
   }
 
-  return SetURI(uri);
+  aRv = SetURI(uri);
 }
 
-NS_IMETHODIMP
+nsresult
 Location::GetHref(nsAString& aHref)
 {
   aHref.Truncate();
 
   nsCOMPtr<nsIURI> uri;
-  nsresult result;
-
-  result = GetURI(getter_AddRefs(uri));
-
-  if (uri) {
-    nsAutoCString uriString;
-
-    result = uri->GetSpec(uriString);
-
-    if (NS_SUCCEEDED(result)) {
-      AppendUTF8toUTF16(uriString, aHref);
-    }
+  nsresult rv = GetURI(getter_AddRefs(uri));
+  if (NS_WARN_IF(NS_FAILED(rv)) || !uri) {
+    return rv;
   }
 
-  return result;
+  nsAutoCString uriString;
+  rv = uri->GetSpec(uriString);
+  if (NS_WARN_IF(NS_FAILED(rv))) {
+    return rv;
+  }
+
+  AppendUTF8toUTF16(uriString, aHref);
+  return NS_OK;
 }
 
-NS_IMETHODIMP
-Location::SetHref(const nsAString& aHref)
+void
+Location::SetHref(const nsAString& aHref,
+                  nsIPrincipal& aSubjectPrincipal,
+                  ErrorResult& aRv)
 {
-  nsAutoString oldHref;
-  nsresult rv = NS_OK;
-
   JSContext *cx = nsContentUtils::GetCurrentJSContext();
   if (cx) {
-    rv = SetHrefWithContext(cx, aHref, false);
-  } else {
-    rv = GetHref(oldHref);
-
-    if (NS_SUCCEEDED(rv)) {
-      nsCOMPtr<nsIURI> oldUri;
-
-      rv = NS_NewURI(getter_AddRefs(oldUri), oldHref);
-
-      if (oldUri) {
-        rv = SetHrefWithBase(aHref, oldUri, false);
-      }
-    }
+    aRv = SetHrefWithContext(cx, aHref, false);
+    return;
   }
 
-  return rv;
+  nsAutoString oldHref;
+  aRv = GetHref(oldHref);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  nsCOMPtr<nsIURI> oldUri;
+  aRv = NS_NewURI(getter_AddRefs(oldUri), oldHref);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  aRv = SetHrefWithBase(aHref, oldUri, false);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
 }
 
 nsresult
 Location::SetHrefWithContext(JSContext* cx, const nsAString& aHref,
-                               bool aReplace)
+                             bool aReplace)
 {
   nsCOMPtr<nsIURI> base;
 
@@ -470,7 +511,7 @@ Location::SetHrefWithContext(JSContext* cx, const nsAString& aHref,
 
 nsresult
 Location::SetHrefWithBase(const nsAString& aHref, nsIURI* aBase,
-                            bool aReplace)
+                          bool aReplace)
 {
   nsresult result;
   nsCOMPtr<nsIURI> newUri;
@@ -486,13 +527,12 @@ Location::SetHrefWithBase(const nsAString& aHref, nsIURI* aBase,
   if (newUri) {
     /* Check with the scriptContext if it is currently processing a script tag.
      * If so, this must be a <script> tag with a location.href in it.
-     * we want to do a replace load, in such a situation. 
+     * we want to do a replace load, in such a situation.
      * In other cases, for example if a event handler or a JS timer
      * had a location.href in it, we want to do a normal load,
      * so that the new url will be appended to Session History.
      * This solution is tricky. Hopefully it isn't going to bite
      * anywhere else. This is part of solution for bug # 39938, 72197
-     * 
      */
     bool inScriptTag = false;
     nsIScriptContext* scriptContext = nullptr;
@@ -518,96 +558,125 @@ Location::SetHrefWithBase(const nsAString& aHref, nsIURI* aBase,
   return result;
 }
 
-NS_IMETHODIMP
-Location::GetOrigin(nsAString& aOrigin)
+void
+Location::GetOrigin(nsAString& aOrigin,
+                    nsIPrincipal& aSubjectPrincipal,
+                    ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   aOrigin.Truncate();
 
   nsCOMPtr<nsIURI> uri;
-  nsresult rv = GetURI(getter_AddRefs(uri), true);
-  NS_ENSURE_SUCCESS(rv, rv);
-  NS_ENSURE_TRUE(uri, NS_OK);
+  aRv = GetURI(getter_AddRefs(uri), true);
+  if (NS_WARN_IF(aRv.Failed()) || !uri) {
+    return;
+  }
 
   nsAutoString origin;
-  rv = nsContentUtils::GetUTFOrigin(uri, origin);
-  NS_ENSURE_SUCCESS(rv, rv);
+  aRv = nsContentUtils::GetUTFOrigin(uri, origin);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
 
   aOrigin = origin;
-  return NS_OK;
 }
 
-NS_IMETHODIMP
-Location::GetPathname(nsAString& aPathname)
+void
+Location::GetPathname(nsAString& aPathname,
+                      nsIPrincipal& aSubjectPrincipal,
+                      ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   aPathname.Truncate();
 
   nsCOMPtr<nsIURI> uri;
-  nsresult result = GetURI(getter_AddRefs(uri));
-  if (NS_FAILED(result) || !uri) {
-    return result;
+  aRv = GetURI(getter_AddRefs(uri));
+  if (NS_WARN_IF(aRv.Failed()) || !uri) {
+    return;
   }
 
   nsAutoCString file;
 
-  result = uri->GetFilePath(file);
-
-  if (NS_SUCCEEDED(result)) {
-    AppendUTF8toUTF16(file, aPathname);
+  aRv = uri->GetFilePath(file);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
   }
 
-  return result;
+  AppendUTF8toUTF16(file, aPathname);
 }
 
-NS_IMETHODIMP
-Location::SetPathname(const nsAString& aPathname)
+void
+Location::SetPathname(const nsAString& aPathname,
+                      nsIPrincipal& aSubjectPrincipal,
+                      ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   nsCOMPtr<nsIURI> uri;
-  nsresult rv = GetWritableURI(getter_AddRefs(uri));
-  if (NS_WARN_IF(NS_FAILED(rv) || !uri)) {
-    return rv;
+  aRv = GetWritableURI(getter_AddRefs(uri));
+  if (NS_WARN_IF(aRv.Failed()) || !uri) {
+    return;
   }
 
   if (NS_SUCCEEDED(uri->SetFilePath(NS_ConvertUTF16toUTF8(aPathname)))) {
-    return SetURI(uri);
+    aRv = SetURI(uri);
   }
-
-  return NS_OK;
 }
 
-NS_IMETHODIMP
-Location::GetPort(nsAString& aPort)
+void
+Location::GetPort(nsAString& aPort,
+                  nsIPrincipal& aSubjectPrincipal,
+                  ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   aPort.SetLength(0);
 
   nsCOMPtr<nsIURI> uri;
-  nsresult result = NS_OK;
-
-  result = GetURI(getter_AddRefs(uri), true);
-
-  if (uri) {
-    int32_t port;
-    result = uri->GetPort(&port);
-
-    if (NS_SUCCEEDED(result) && -1 != port) {
-      nsAutoString portStr;
-      portStr.AppendInt(port);
-      aPort.Append(portStr);
-    }
-
-    // Don't propagate this exception to caller
-    result = NS_OK;
+  aRv = GetURI(getter_AddRefs(uri), true);
+  if (NS_WARN_IF(aRv.Failed()) || !uri) {
+    return;
   }
 
-  return result;
+  int32_t port;
+  nsresult result = uri->GetPort(&port);
+
+  // Don't propagate this exception to caller
+  if (NS_SUCCEEDED(result) && -1 != port) {
+    nsAutoString portStr;
+    portStr.AppendInt(port);
+    aPort.Append(portStr);
+  }
 }
 
-NS_IMETHODIMP
-Location::SetPort(const nsAString& aPort)
+void
+Location::SetPort(const nsAString& aPort,
+                  nsIPrincipal& aSubjectPrincipal,
+                  ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   nsCOMPtr<nsIURI> uri;
-  nsresult rv = GetWritableURI(getter_AddRefs(uri));
-  if (NS_WARN_IF(NS_FAILED(rv) || !uri)) {
-    return rv;
+  aRv = GetWritableURI(getter_AddRefs(uri));
+  if (NS_WARN_IF(aRv.Failed() || !uri)) {
+    return;
   }
 
   // perhaps use nsReadingIterators at some point?
@@ -624,45 +693,57 @@ Location::SetPort(const nsAString& aPort)
     }
   }
 
-  rv = uri->SetPort(port);
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
+  aRv = uri->SetPort(port);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
   }
 
-  return SetURI(uri);
+  aRv = SetURI(uri);
 }
 
-NS_IMETHODIMP
-Location::GetProtocol(nsAString& aProtocol)
+void
+Location::GetProtocol(nsAString& aProtocol,
+                      nsIPrincipal& aSubjectPrincipal,
+                      ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   aProtocol.SetLength(0);
 
   nsCOMPtr<nsIURI> uri;
-  nsresult result = NS_OK;
-
-  result = GetURI(getter_AddRefs(uri));
-
-  if (uri) {
-    nsAutoCString protocol;
-
-    result = uri->GetScheme(protocol);
-
-    if (NS_SUCCEEDED(result)) {
-      CopyASCIItoUTF16(protocol, aProtocol);
-      aProtocol.Append(char16_t(':'));
-    }
+  aRv = GetURI(getter_AddRefs(uri));
+  if (NS_WARN_IF(aRv.Failed()) || !uri) {
+    return;
   }
 
-  return result;
+  nsAutoCString protocol;
+
+  aRv = uri->GetScheme(protocol);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  CopyASCIItoUTF16(protocol, aProtocol);
+  aProtocol.Append(char16_t(':'));
 }
 
-NS_IMETHODIMP
-Location::SetProtocol(const nsAString& aProtocol)
+void
+Location::SetProtocol(const nsAString& aProtocol,
+                      nsIPrincipal& aSubjectPrincipal,
+                      ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   nsCOMPtr<nsIURI> uri;
-  nsresult rv = GetWritableURI(getter_AddRefs(uri));
-  if (NS_WARN_IF(NS_FAILED(rv) || !uri)) {
-    return rv;
+  aRv = GetWritableURI(getter_AddRefs(uri));
+  if (NS_WARN_IF(aRv.Failed()) || !uri) {
+    return;
   }
 
   nsAString::const_iterator start, end;
@@ -671,16 +752,18 @@ Location::SetProtocol(const nsAString& aProtocol)
   nsAString::const_iterator iter(start);
   Unused << FindCharInReadable(':', iter, end);
 
-  rv = uri->SetScheme(NS_ConvertUTF16toUTF8(Substring(start, iter)));
+  nsresult rv = uri->SetScheme(NS_ConvertUTF16toUTF8(Substring(start, iter)));
   if (NS_WARN_IF(NS_FAILED(rv))) {
     // Oh, I wish nsStandardURL returned NS_ERROR_MALFORMED_URI for _all_ the
     // malformed cases, not just some of them!
-    return NS_ERROR_DOM_SYNTAX_ERR;
+    aRv.Throw(NS_ERROR_DOM_SYNTAX_ERR);
+    return;
   }
+
   nsAutoCString newSpec;
-  rv = uri->GetSpec(newSpec);
-  if (NS_FAILED(rv)) {
-    return rv;
+  aRv = uri->GetSpec(newSpec);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
   }
   // We may want a new URI class for the new URI, so recreate it:
   rv = NS_NewURI(getter_AddRefs(uri), newSpec);
@@ -688,32 +771,41 @@ Location::SetProtocol(const nsAString& aProtocol)
     if (rv == NS_ERROR_MALFORMED_URI) {
       rv = NS_ERROR_DOM_SYNTAX_ERR;
     }
-    return rv;
+
+    aRv.Throw(rv);
+    return;
   }
 
   bool isHttp;
-  rv = uri->SchemeIs("http", &isHttp);
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
+  aRv = uri->SchemeIs("http", &isHttp);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
   }
 
   bool isHttps;
-  rv = uri->SchemeIs("https", &isHttps);
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
+  aRv = uri->SchemeIs("https", &isHttps);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
   }
 
   if (!isHttp && !isHttps) {
     // No-op, per spec.
-    return NS_OK;
+    return;
   }
 
-  return SetURI(uri);
+  aRv = SetURI(uri);
 }
 
-NS_IMETHODIMP
-Location::GetSearch(nsAString& aSearch)
+void
+Location::GetSearch(nsAString& aSearch,
+                    nsIPrincipal& aSubjectPrincipal,
+                    ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   aSearch.SetLength(0);
 
   nsCOMPtr<nsIURI> uri;
@@ -733,44 +825,36 @@ Location::GetSearch(nsAString& aSearch)
       AppendUTF8toUTF16(search, aSearch);
     }
   }
-
-  return NS_OK;
 }
 
-NS_IMETHODIMP
-Location::SetSearch(const nsAString& aSearch)
+void
+Location::SetSearch(const nsAString& aSearch,
+                    nsIPrincipal& aSubjectPrincipal,
+                    ErrorResult& aRv)
 {
-  nsresult rv = SetSearchInternal(aSearch);
-  if (NS_FAILED(rv)) {
-    return rv;
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
   }
 
-  return NS_OK;
+  nsCOMPtr<nsIURI> uri;
+  aRv = GetWritableURI(getter_AddRefs(uri));
+  nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
+  if (NS_WARN_IF(aRv.Failed()) || !url) {
+    return;
+  }
+
+  aRv = url->SetQuery(NS_ConvertUTF16toUTF8(aSearch));
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
+
+  aRv = SetURI(uri);
 }
 
 nsresult
-Location::SetSearchInternal(const nsAString& aSearch)
-{
-  nsCOMPtr<nsIURI> uri;
-  nsresult rv = GetWritableURI(getter_AddRefs(uri));
-
-  nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
-  if (NS_WARN_IF(NS_FAILED(rv) || !url)) {
-    return rv;
-  }
-
-  rv = url->SetQuery(NS_ConvertUTF16toUTF8(aSearch));
-  if (NS_WARN_IF(NS_FAILED(rv))) {
-    return rv;
-  }
-
-  return SetURI(uri);
-}
-
-NS_IMETHODIMP
 Location::Reload(bool aForceget)
 {
-  nsresult rv;
   nsCOMPtr<nsIDocShell> docShell(do_QueryReferent(mDocShell));
   nsCOMPtr<nsIWebNavigation> webNav(do_QueryInterface(docShell));
   nsCOMPtr<nsPIDOMWindowOuter> window = docShell ? docShell->GetWindow()
@@ -795,85 +879,89 @@ Location::Reload(bool aForceget)
     return NS_OK;
   }
 
-  if (webNav) {
-    uint32_t reloadFlags = nsIWebNavigation::LOAD_FLAGS_NONE;
+  if (!webNav) {
+    return NS_ERROR_FAILURE;
+  }
 
-    if (aForceget) {
-      reloadFlags = nsIWebNavigation::LOAD_FLAGS_BYPASS_CACHE | 
-                    nsIWebNavigation::LOAD_FLAGS_BYPASS_PROXY;
-    }
-    rv = webNav->Reload(reloadFlags);
-    if (rv == NS_BINDING_ABORTED) {
-      // This happens when we attempt to reload a POST result and the user says
-      // no at the "do you want to reload?" prompt.  Don't propagate this one
-      // back to callers.
-      rv = NS_OK;
-    }
-  } else {
-    rv = NS_ERROR_FAILURE;
+  uint32_t reloadFlags = nsIWebNavigation::LOAD_FLAGS_NONE;
+
+  if (aForceget) {
+    reloadFlags = nsIWebNavigation::LOAD_FLAGS_BYPASS_CACHE |
+                  nsIWebNavigation::LOAD_FLAGS_BYPASS_PROXY;
+  }
+
+  nsresult rv = webNav->Reload(reloadFlags);
+  if (rv == NS_BINDING_ABORTED) {
+    // This happens when we attempt to reload a POST result and the user says
+    // no at the "do you want to reload?" prompt.  Don't propagate this one
+    // back to callers.
+    rv = NS_OK;
   }
 
   return rv;
 }
 
-NS_IMETHODIMP
-Location::Replace(const nsAString& aUrl)
+void
+Location::Replace(const nsAString& aUrl,
+                  nsIPrincipal& aSubjectPrincipal,
+                  ErrorResult& aRv)
 {
-  nsresult rv = NS_OK;
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   if (JSContext *cx = nsContentUtils::GetCurrentJSContext()) {
-    return SetHrefWithContext(cx, aUrl, true);
+    aRv = SetHrefWithContext(cx, aUrl, true);
+    return;
   }
 
   nsAutoString oldHref;
-
-  rv = GetHref(oldHref);
-  NS_ENSURE_SUCCESS(rv, rv);
+  aRv = GetHref(oldHref);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
 
   nsCOMPtr<nsIURI> oldUri;
 
-  rv = NS_NewURI(getter_AddRefs(oldUri), oldHref);
-  NS_ENSURE_SUCCESS(rv, rv);
+  aRv = NS_NewURI(getter_AddRefs(oldUri), oldHref);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
 
-  return SetHrefWithBase(aUrl, oldUri, true);
+  aRv = SetHrefWithBase(aUrl, oldUri, true);
 }
 
-NS_IMETHODIMP
-Location::Assign(const nsAString& aUrl)
+void
+Location::Assign(const nsAString& aUrl,
+                 nsIPrincipal& aSubjectPrincipal,
+                 ErrorResult& aRv)
 {
+  if (!CallerSubsumes(&aSubjectPrincipal)) {
+    aRv.Throw(NS_ERROR_DOM_SECURITY_ERR);
+    return;
+  }
+
   if (JSContext *cx = nsContentUtils::GetCurrentJSContext()) {
-    return SetHrefWithContext(cx, aUrl, false);
+    aRv = SetHrefWithContext(cx, aUrl, false);
+    return;
   }
 
   nsAutoString oldHref;
-  nsresult result = NS_OK;
-
-  result = GetHref(oldHref);
-
-  if (NS_SUCCEEDED(result)) {
-    nsCOMPtr<nsIURI> oldUri;
-
-    result = NS_NewURI(getter_AddRefs(oldUri), oldHref);
-
-    if (oldUri) {
-      result = SetHrefWithBase(aUrl, oldUri, false);
-    }
+  aRv = GetHref(oldHref);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
   }
 
-  return result;
-}
+  nsCOMPtr<nsIURI> oldUri;
+  aRv = NS_NewURI(getter_AddRefs(oldUri), oldHref);
+  if (NS_WARN_IF(aRv.Failed())) {
+    return;
+  }
 
-NS_IMETHODIMP
-Location::ToString(nsAString& aReturn)
-{
-  return GetHref(aReturn);
-}
-
-NS_IMETHODIMP
-Location::ValueOf(nsIDOMLocation** aReturn)
-{
-  nsCOMPtr<nsIDOMLocation> loc(this);
-  loc.forget(aReturn);
-  return NS_OK;
+  if (oldUri) {
+    aRv = SetHrefWithBase(aUrl, oldUri, false);
+  }
 }
 
 nsresult

dom/base/Location.h

@@ -37,37 +37,24 @@ public:
   NS_DECL_CYCLE_COLLECTION_SCRIPT_HOLDER_CLASS_AMBIGUOUS(Location,
                                                          nsIDOMLocation)
 
-  // nsIDOMLocation
-  NS_DECL_NSIDOMLOCATION
-
-  #define THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME() { \
-    if (!CallerSubsumes(&aSubjectPrincipal)) { \
-      aError.Throw(NS_ERROR_DOM_SECURITY_ERR); \
-      return; \
-    } \
-  }
-
   // WebIDL API:
   void Assign(const nsAString& aUrl,
               nsIPrincipal& aSubjectPrincipal,
-              ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = Assign(aUrl);
-  }
+              ErrorResult& aError);
 
   void Replace(const nsAString& aUrl,
                nsIPrincipal& aSubjectPrincipal,
-               ErrorResult& aError)
-  {
-    aError = Replace(aUrl);
-  }
+               ErrorResult& aError);
 
   void Reload(bool aForceget,
               nsIPrincipal& aSubjectPrincipal,
               ErrorResult& aError)
   {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
+    if (!CallerSubsumes(&aSubjectPrincipal)) {
+      aError.Throw(NS_ERROR_DOM_SECURITY_ERR);
+      return;
+    }
+
     aError = Reload(aForceget);
   }
 
@@ -75,136 +62,77 @@ public:
                nsIPrincipal& aSubjectPrincipal,
                ErrorResult& aError)
   {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
+    if (!CallerSubsumes(&aSubjectPrincipal)) {
+      aError.Throw(NS_ERROR_DOM_SECURITY_ERR);
+      return;
+    }
+
     aError = GetHref(aHref);
   }
 
   void SetHref(const nsAString& aHref,
                nsIPrincipal& aSubjectPrincipal,
-               ErrorResult& aError)
-  {
-    aError = SetHref(aHref);
-  }
+               ErrorResult& aError);
 
   void GetOrigin(nsAString& aOrigin,
                  nsIPrincipal& aSubjectPrincipal,
-                 ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = GetOrigin(aOrigin);
-  }
+                 ErrorResult& aError);
 
   void GetProtocol(nsAString& aProtocol,
                    nsIPrincipal& aSubjectPrincipal,
-                   ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = GetProtocol(aProtocol);
-  }
+                   ErrorResult& aError);
 
   void SetProtocol(const nsAString& aProtocol,
                    nsIPrincipal& aSubjectPrincipal,
-                   ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = SetProtocol(aProtocol);
-  }
+                   ErrorResult& aError);
 
   void GetHost(nsAString& aHost,
                nsIPrincipal& aSubjectPrincipal,
-               ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = GetHost(aHost);
-  }
+               ErrorResult& aError);
 
   void SetHost(const nsAString& aHost,
                nsIPrincipal& aSubjectPrincipal,
-               ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = SetHost(aHost);
-  }
+               ErrorResult& aError);
 
   void GetHostname(nsAString& aHostname,
                    nsIPrincipal& aSubjectPrincipal,
-                   ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = GetHostname(aHostname);
-  }
+                   ErrorResult& aError);
 
   void SetHostname(const nsAString& aHostname,
                    nsIPrincipal& aSubjectPrincipal,
-                   ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = SetHostname(aHostname);
-  }
+                   ErrorResult& aError);
 
   void GetPort(nsAString& aPort,
                nsIPrincipal& aSubjectPrincipal,
-               ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = GetPort(aPort);
-  }
+               ErrorResult& aError);
 
   void SetPort(const nsAString& aPort,
                nsIPrincipal& aSubjectPrincipal,
-               ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = SetPort(aPort);
-  }
+               ErrorResult& aError);
 
   void GetPathname(nsAString& aPathname,
                    nsIPrincipal& aSubjectPrincipal,
-                   ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = GetPathname(aPathname);
-  }
+                   ErrorResult& aError);
 
   void SetPathname(const nsAString& aPathname,
                    nsIPrincipal& aSubjectPrincipal,
-                   ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = SetPathname(aPathname);
-  }
+                   ErrorResult& aError);
 
   void GetSearch(nsAString& aSeach,
                  nsIPrincipal& aSubjectPrincipal,
-                 ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = GetSearch(aSeach);
-  }
+                 ErrorResult& aError);
 
   void SetSearch(const nsAString& aSeach,
                  nsIPrincipal& aSubjectPrincipal,
-                 ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = SetSearch(aSeach);
-  }
+                 ErrorResult& aError);
 
   void GetHash(nsAString& aHash,
                nsIPrincipal& aSubjectPrincipal,
-               ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = GetHash(aHash);
-  }
+               ErrorResult& aError);
 
   void SetHash(const nsAString& aHash,
                nsIPrincipal& aSubjectPrincipal,
-               ErrorResult& aError)
-  {
-    THROW_AND_RETURN_IF_CALLER_DOESNT_SUBSUME();
-    aError = SetHash(aHash);
-  }
+               ErrorResult& aError);
 
   void Stringify(nsAString& aRetval,
                  nsIPrincipal& aSubjectPrincipal,
@@ -222,11 +150,20 @@ public:
   virtual JSObject* WrapObject(JSContext* aCx,
                                JS::Handle<JSObject*> aGivenProto) override;
 
+  // Non WebIDL methods:
+
+  nsresult GetHref(nsAString& aHref);
+
+  nsresult ToString(nsAString& aString)
+  {
+    return GetHref(aString);
+  }
+
+  nsresult Reload(bool aForceget);
+
 protected:
   virtual ~Location();
 
-  nsresult SetSearchInternal(const nsAString& aSearch);
-
   // In the case of jar: uris, we sometimes want the place the jar was
   // fetched from as the URI instead of the jar: uri itself.  Pass in
   // true for aGetInnermostURI when that's the case.

dom/interfaces/base/nsIDOMLocation.idl

@@ -8,26 +8,5 @@
 [scriptable, uuid(79de76e5-994e-4f6b-81aa-42d9adb6e67e)]
 interface nsIDOMLocation : nsISupports
 {
-           /**
-            * These properties refer to the current location of the document.
-            * This will correspond to the URI shown in the location bar, which
-            * can be different from the documentURI of the document.
-            */
-           attribute DOMString        hash;
-           attribute DOMString        host;
-           attribute DOMString        hostname;
-           attribute DOMString        href;
-           attribute DOMString        pathname;
-           attribute DOMString        port;
-           attribute DOMString        protocol;
-           attribute DOMString        search;
-
-  readonly attribute DOMString        origin;
-
-  void                      reload([optional] in boolean forceget);
-  void                      replace(in DOMString url);
-  void                      assign(in DOMString url);
-
-  DOMString                 toString();
-  nsIDOMLocation            valueOf();
+  // Empty interface. Location is defined using WebIDL.
 };