The Tor Browser: content/base/src/Link.cpp@6474c204b198 (annotated)

content/base/src/Link.cpp@6474c204b198 (annotated)

content/base/src/Link.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  * vim: sw=2 ts=2 et :
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 #include "Link.h"
 #include "mozilla/EventStates.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/dom/Element.h"
 #include "nsIURL.h"
 #include "nsISizeOf.h"
 #include "nsEscape.h"
 #include "nsGkAtoms.h"
 #include "nsString.h"
 #include "mozAutoDocUpdate.h"
 #include "mozilla/Services.h"
 namespace mozilla {
 namespace dom {
 Link::Link(Element *aElement)
   : mElement(aElement)
   , mHistory(services::GetHistoryService())
   , mLinkState(eLinkState_NotLink)
   , mNeedsRegistration(false)
   , mRegistered(false)
 {
   NS_ABORT_IF_FALSE(mElement, "Must have an element");
 }
 Link::~Link()
 {
   UnregisterFromHistory();
 }
 bool
 Link::ElementHasHref() const
 {
   return ((!mElement->IsSVG() && mElement->HasAttr(kNameSpaceID_None, nsGkAtoms::href))
         || (!mElement->IsHTML() && mElement->HasAttr(kNameSpaceID_XLink, nsGkAtoms::href)));
 }
 void
 Link::SetLinkState(nsLinkState aState)
 {
   NS_ASSERTION(mRegistered,
                "Setting the link state of an unregistered Link!");
   NS_ASSERTION(mLinkState != aState,
                "Setting state to the currently set state!");
   // Set our current state as appropriate.
   mLinkState = aState;
   // Per IHistory interface documentation, we are no longer registered.
   mRegistered = false;
   NS_ABORT_IF_FALSE(LinkState() == NS_EVENT_STATE_VISITED ||
                     LinkState() == NS_EVENT_STATE_UNVISITED,
                     "Unexpected state obtained from LinkState()!");
   // Tell the element to update its visited state
   mElement->UpdateState(true);
 }
 EventStates
 Link::LinkState() const
 {
   // We are a constant method, but we are just lazily doing things and have to
   // track that state.  Cast away that constness!
   Link *self = const_cast<Link *>(this);
   Element *element = self->mElement;
   // If we have not yet registered for notifications and need to,
   // due to our href changing, register now!
   if (!mRegistered && mNeedsRegistration && element->IsInDoc()) {
     // Only try and register once.
     self->mNeedsRegistration = false;
     nsCOMPtr<nsIURI> hrefURI(GetURI());
     // Assume that we are not visited until we are told otherwise.
     self->mLinkState = eLinkState_Unvisited;
     // Make sure the href attribute has a valid link (bug 23209).
     // If we have a good href, register with History if available.
     if (mHistory && hrefURI) {
       nsresult rv = mHistory->RegisterVisitedCallback(hrefURI, self);
       if (NS_SUCCEEDED(rv)) {
         self->mRegistered = true;
         // And make sure we are in the document's link map.
         element->GetCurrentDoc()->AddStyleRelevantLink(self);
       }
     }
   }
   // Otherwise, return our known state.
   if (mLinkState == eLinkState_Visited) {
     return NS_EVENT_STATE_VISITED;
   }
   if (mLinkState == eLinkState_Unvisited) {
     return NS_EVENT_STATE_UNVISITED;
   }
   return EventStates();
 }
 nsIURI*
 Link::GetURI() const
 {
   // If we have this URI cached, use it.
   if (mCachedURI) {
     return mCachedURI;
   }
   // Otherwise obtain it.
   Link *self = const_cast<Link *>(this);
   Element *element = self->mElement;
   mCachedURI = element->GetHrefURI();
   return mCachedURI;
 }
 void
 Link::SetProtocol(const nsAString &aProtocol)
 {
   nsCOMPtr<nsIURI> uri(GetURIToMutate());
   if (!uri) {
     // Ignore failures to be compatible with NS4.
     return;
   }
   nsAString::const_iterator start, end;
   aProtocol.BeginReading(start);
   aProtocol.EndReading(end);
   nsAString::const_iterator iter(start);
   (void)FindCharInReadable(':', iter, end);
   (void)uri->SetScheme(NS_ConvertUTF16toUTF8(Substring(start, iter)));
   SetHrefAttribute(uri);
 }
 void
 Link::SetPassword(const nsAString &aPassword)
 {
   nsCOMPtr<nsIURI> uri(GetURIToMutate());
   if (!uri) {
     // Ignore failures to be compatible with NS4.
     return;
   }
   uri->SetPassword(NS_ConvertUTF16toUTF8(aPassword));
   SetHrefAttribute(uri);
 }
 void
 Link::SetUsername(const nsAString &aUsername)
 {
   nsCOMPtr<nsIURI> uri(GetURIToMutate());
   if (!uri) {
     // Ignore failures to be compatible with NS4.
     return;
   }
   uri->SetUsername(NS_ConvertUTF16toUTF8(aUsername));
   SetHrefAttribute(uri);
 }
 void
 Link::SetHost(const nsAString &aHost)
 {
   nsCOMPtr<nsIURI> uri(GetURIToMutate());
   if (!uri) {
     // Ignore failures to be compatible with NS4.
     return;
   }
   (void)uri->SetHostPort(NS_ConvertUTF16toUTF8(aHost));
   SetHrefAttribute(uri);
 }
 void
 Link::SetHostname(const nsAString &aHostname)
 {
   nsCOMPtr<nsIURI> uri(GetURIToMutate());
   if (!uri) {
     // Ignore failures to be compatible with NS4.
     return;
   }
   (void)uri->SetHost(NS_ConvertUTF16toUTF8(aHostname));
   SetHrefAttribute(uri);
 }
 void
 Link::SetPathname(const nsAString &aPathname)
 {
   nsCOMPtr<nsIURI> uri(GetURIToMutate());
   nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
   if (!url) {
     // Ignore failures to be compatible with NS4.
     return;
   }
   (void)url->SetFilePath(NS_ConvertUTF16toUTF8(aPathname));
   SetHrefAttribute(uri);
 }
 void
 Link::SetSearch(const nsAString& aSearch)
 {
   SetSearchInternal(aSearch);
   UpdateURLSearchParams();
 }
 void
 Link::SetSearchInternal(const nsAString& aSearch)
 {
   nsCOMPtr<nsIURI> uri(GetURIToMutate());
   nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
   if (!url) {
     // Ignore failures to be compatible with NS4.
     return;
   }
   (void)url->SetQuery(NS_ConvertUTF16toUTF8(aSearch));
   SetHrefAttribute(uri);
 }
 void
 Link::SetPort(const nsAString &aPort)
 {
   nsCOMPtr<nsIURI> uri(GetURIToMutate());
   if (!uri) {
     // Ignore failures to be compatible with NS4.
     return;
   }
   nsresult rv;
   nsAutoString portStr(aPort);
   // nsIURI uses -1 as default value.
   int32_t port = -1;
   if (!aPort.IsEmpty()) {
     port = portStr.ToInteger(&rv);
     if (NS_FAILED(rv)) {
       return;
     }
   }
   (void)uri->SetPort(port);
   SetHrefAttribute(uri);
 }
 void
 Link::SetHash(const nsAString &aHash)
 {
   nsCOMPtr<nsIURI> uri(GetURIToMutate());
   if (!uri) {
     // Ignore failures to be compatible with NS4.
     return;
   }
   (void)uri->SetRef(NS_ConvertUTF16toUTF8(aHash));
   SetHrefAttribute(uri);
 }
 void
 Link::GetOrigin(nsAString &aOrigin)
 {
   aOrigin.Truncate();
   nsCOMPtr<nsIURI> uri(GetURI());
   if (!uri) {
     return;
   }
   nsString origin;
   nsContentUtils::GetUTFNonNullOrigin(uri, origin);
   aOrigin.Assign(origin);
 }
 void
 Link::GetProtocol(nsAString &_protocol)
 {
   nsCOMPtr<nsIURI> uri(GetURI());
   if (!uri) {
     _protocol.AssignLiteral("http");
   }
   else {
     nsAutoCString scheme;
     (void)uri->GetScheme(scheme);
     CopyASCIItoUTF16(scheme, _protocol);
   }
   _protocol.Append(char16_t(':'));
   return;
 }
 void
 Link::GetUsername(nsAString& aUsername)
 {
   aUsername.Truncate();
   nsCOMPtr<nsIURI> uri(GetURI());
   if (!uri) {
     return;
   }
   nsAutoCString username;
   uri->GetUsername(username);
   CopyASCIItoUTF16(username, aUsername);
 }
 void
 Link::GetPassword(nsAString &aPassword)
 {
   aPassword.Truncate();
   nsCOMPtr<nsIURI> uri(GetURI());
   if (!uri) {
     return;
   }
   nsAutoCString password;
   uri->GetPassword(password);
   CopyASCIItoUTF16(password, aPassword);
 }
 void
 Link::GetHost(nsAString &_host)
 {
   _host.Truncate();
   nsCOMPtr<nsIURI> uri(GetURI());
   if (!uri) {
     // Do not throw!  Not having a valid URI should result in an empty string.
     return;
   }
   nsAutoCString hostport;
   nsresult rv = uri->GetHostPort(hostport);
   if (NS_SUCCEEDED(rv)) {
     CopyUTF8toUTF16(hostport, _host);
   }
 }
 void
 Link::GetHostname(nsAString &_hostname)
 {
   _hostname.Truncate();
   nsCOMPtr<nsIURI> uri(GetURI());
   if (!uri) {
     // Do not throw!  Not having a valid URI should result in an empty string.
     return;
   }
   nsAutoCString host;
   nsresult rv = uri->GetHost(host);
   // Note that failure to get the host from the URI is not necessarily a bad
   // thing.  Some URIs do not have a host.
   if (NS_SUCCEEDED(rv)) {
     CopyUTF8toUTF16(host, _hostname);
   }
 }
 void
 Link::GetPathname(nsAString &_pathname)
 {
   _pathname.Truncate();
   nsCOMPtr<nsIURI> uri(GetURI());
   nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
   if (!url) {
     // Do not throw!  Not having a valid URI or URL should result in an empty
     // string.
     return;
   }
   nsAutoCString file;
   nsresult rv = url->GetFilePath(file);
   if (NS_SUCCEEDED(rv)) {
     CopyUTF8toUTF16(file, _pathname);
   }
 }
 void
 Link::GetSearch(nsAString &_search)
 {
   _search.Truncate();
   nsCOMPtr<nsIURI> uri(GetURI());
   nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
   if (!url) {
     // Do not throw!  Not having a valid URI or URL should result in an empty
     // string.
     return;
   }
   nsAutoCString search;
   nsresult rv = url->GetQuery(search);
   if (NS_SUCCEEDED(rv) && !search.IsEmpty()) {
     CopyUTF8toUTF16(NS_LITERAL_CSTRING("?") + search, _search);
   }
 }
 void
 Link::GetPort(nsAString &_port)
 {
   _port.Truncate();
   nsCOMPtr<nsIURI> uri(GetURI());
   if (!uri) {
     // Do not throw!  Not having a valid URI should result in an empty string.
     return;
   }
   int32_t port;
   nsresult rv = uri->GetPort(&port);
   // Note that failure to get the port from the URI is not necessarily a bad
   // thing.  Some URIs do not have a port.
   if (NS_SUCCEEDED(rv) && port != -1) {
     nsAutoString portStr;
     portStr.AppendInt(port, 10);
     _port.Assign(portStr);
   }
 }
 void
 Link::GetHash(nsAString &_hash)
 {
   _hash.Truncate();
   nsCOMPtr<nsIURI> uri(GetURI());
   if (!uri) {
     // Do not throw!  Not having a valid URI should result in an empty
     // string.
     return;
   }
   nsAutoCString ref;
   nsresult rv = uri->GetRef(ref);
   if (NS_SUCCEEDED(rv) && !ref.IsEmpty()) {
     NS_UnescapeURL(ref); // XXX may result in random non-ASCII bytes!
     _hash.Assign(char16_t('#'));
     AppendUTF8toUTF16(ref, _hash);
   }
 }
 void
 Link::ResetLinkState(bool aNotify, bool aHasHref)
 {
   nsLinkState defaultState;
   // The default state for links with an href is unvisited.
   if (aHasHref) {
     defaultState = eLinkState_Unvisited;
   } else {
     defaultState = eLinkState_NotLink;
   }
   // If !mNeedsRegstration, then either we've never registered, or we're
   // currently registered; in either case, we should remove ourself
   // from the doc and the history.
   if (!mNeedsRegistration && mLinkState != eLinkState_NotLink) {
     nsIDocument *doc = mElement->GetCurrentDoc();
     if (doc && (mRegistered || mLinkState == eLinkState_Visited)) {
       // Tell the document to forget about this link if we've registered
       // with it before.
       doc->ForgetLink(this);
     }
     UnregisterFromHistory();
   }
   // If we have an href, we should register with the history.
   mNeedsRegistration = aHasHref;
   // If we've cached the URI, reset always invalidates it.
   mCachedURI = nullptr;
   UpdateURLSearchParams();
   // Update our state back to the default.
   mLinkState = defaultState;
   // We have to be very careful here: if aNotify is false we do NOT
   // want to call UpdateState, because that will call into LinkState()
   // and try to start off loads, etc.  But ResetLinkState is called
   // with aNotify false when things are in inconsistent states, so
   // we'll get confused in that situation.  Instead, just silently
   // update the link state on mElement. Since we might have set the
   // link state to unvisited, make sure to update with that state if
   // required.
   if (aNotify) {
     mElement->UpdateState(aNotify);
   } else {
     if (mLinkState == eLinkState_Unvisited) {
       mElement->UpdateLinkState(NS_EVENT_STATE_UNVISITED);
     } else {
       mElement->UpdateLinkState(EventStates());
     }
   }
 }
 void
 Link::UnregisterFromHistory()
 {
   // If we are not registered, we have nothing to do.
   if (!mRegistered) {
     return;
   }
   NS_ASSERTION(mCachedURI, "mRegistered is true, but we have no cached URI?!");
   // And tell History to stop tracking us.
   if (mHistory) {
     nsresult rv = mHistory->UnregisterVisitedCallback(mCachedURI, this);
     NS_ASSERTION(NS_SUCCEEDED(rv), "This should only fail if we misuse the API!");
     if (NS_SUCCEEDED(rv)) {
       mRegistered = false;
     }
   }
 }
 already_AddRefed<nsIURI>
 Link::GetURIToMutate()
 {
   nsCOMPtr<nsIURI> uri(GetURI());
   if (!uri) {
     return nullptr;
   }
   nsCOMPtr<nsIURI> clone;
   (void)uri->Clone(getter_AddRefs(clone));
   return clone.forget();
 }
 void
 Link::SetHrefAttribute(nsIURI *aURI)
 {
   NS_ASSERTION(aURI, "Null URI is illegal!");
   nsAutoCString href;
   (void)aURI->GetSpec(href);
   (void)mElement->SetAttr(kNameSpaceID_None, nsGkAtoms::href,
                           NS_ConvertUTF8toUTF16(href), true);
 }
 size_t
 Link::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
 {
   size_t n = 0;
   if (mCachedURI) {
     nsCOMPtr<nsISizeOf> iface = do_QueryInterface(mCachedURI);
     if (iface) {
       n += iface->SizeOfIncludingThis(aMallocSizeOf);
     }
   }
   // The following members don't need to be measured:
   // - mElement, because it is a pointer-to-self used to avoid QIs
   // - mHistory, because it is non-owning
   return n;
 }
 URLSearchParams*
 Link::SearchParams()
 {
   CreateSearchParamsIfNeeded();
   return mSearchParams;
 }
 void
 Link::SetSearchParams(URLSearchParams& aSearchParams)
 {
   if (mSearchParams) {
     mSearchParams->RemoveObserver(this);
   }
   mSearchParams = &aSearchParams;
   mSearchParams->AddObserver(this);
   nsAutoString search;
   mSearchParams->Serialize(search);
   SetSearchInternal(search);
 }
 void
 Link::URLSearchParamsUpdated()
 {
   MOZ_ASSERT(mSearchParams);
   nsString search;
   mSearchParams->Serialize(search);
   SetSearchInternal(search);
 }
 void
 Link::UpdateURLSearchParams()
 {
   if (!mSearchParams) {
     return;
   }
   nsAutoCString search;
   nsCOMPtr<nsIURI> uri(GetURI());
   nsCOMPtr<nsIURL> url(do_QueryInterface(uri));
   if (url) {
     nsresult rv = url->GetQuery(search);
     if (NS_FAILED(rv)) {
       NS_WARNING("Failed to get the query from a nsIURL.");
     }
   }
   mSearchParams->ParseInput(search, this);
 }
 void
 Link::CreateSearchParamsIfNeeded()
 {
   if (!mSearchParams) {
     mSearchParams = new URLSearchParams();
     mSearchParams->AddObserver(this);
     UpdateURLSearchParams();
   }
 }
 void
 Link::Unlink()
 {
   if (mSearchParams) {
     mSearchParams->RemoveObserver(this);
     mSearchParams = nullptr;
   }
 }
 void
 Link::Traverse(nsCycleCollectionTraversalCallback &cb)
 {
   Link* tmp = this;
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE(mSearchParams);
 }
 } // namespace dom
 } // namespace mozilla

The Tor Browser / annotate

content/base/src/Link.cpp@6474c204b198 (annotated)

content/base/src/Link.cpp