The Tor Browser: netwerk/base/src/nsSimpleURI.cpp@b8a032363ba2 (annotated)

netwerk/base/src/nsSimpleURI.cpp@b8a032363ba2 (annotated)

netwerk/base/src/nsSimpleURI.cpp

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
 /* 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 "mozilla/DebugOnly.h"
 #undef LOG
 #include "IPCMessageUtils.h"
 #include "nsSimpleURI.h"
 #include "nscore.h"
 #include "nsString.h"
 #include "plstr.h"
 #include "nsURLHelper.h"
 #include "nsNetCID.h"
 #include "nsIObjectInputStream.h"
 #include "nsIObjectOutputStream.h"
 #include "nsEscape.h"
 #include "nsError.h"
 #include "nsIProgrammingLanguage.h"
 #include "nsIIPCSerializableURI.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/ipc/URIUtils.h"
 using namespace mozilla::ipc;
 static NS_DEFINE_CID(kThisSimpleURIImplementationCID,
                      NS_THIS_SIMPLEURI_IMPLEMENTATION_CID);
 static NS_DEFINE_CID(kSimpleURICID, NS_SIMPLEURI_CID);
 ////////////////////////////////////////////////////////////////////////////////
 // nsSimpleURI methods:
 nsSimpleURI::nsSimpleURI()
     : mMutable(true),
       mIsRefValid(false)
 {
 }
 nsSimpleURI::~nsSimpleURI()
 {
 }
 NS_IMPL_ADDREF(nsSimpleURI)
 NS_IMPL_RELEASE(nsSimpleURI)
 NS_INTERFACE_TABLE_HEAD(nsSimpleURI)
 NS_INTERFACE_TABLE(nsSimpleURI, nsIURI, nsISerializable, nsIClassInfo,
                     nsIMutable, nsIIPCSerializableURI)
 NS_INTERFACE_TABLE_TO_MAP_SEGUE
   if (aIID.Equals(kThisSimpleURIImplementationCID))
     foundInterface = static_cast<nsIURI*>(this);
   else
   NS_INTERFACE_MAP_ENTRY(nsISizeOf)
 NS_INTERFACE_MAP_END
 ////////////////////////////////////////////////////////////////////////////////
 // nsISerializable methods:
 NS_IMETHODIMP
 nsSimpleURI::Read(nsIObjectInputStream* aStream)
 {
     nsresult rv;
     bool isMutable;
     rv = aStream->ReadBoolean(&isMutable);
     if (NS_FAILED(rv)) return rv;
     mMutable = isMutable;
     rv = aStream->ReadCString(mScheme);
     if (NS_FAILED(rv)) return rv;
     rv = aStream->ReadCString(mPath);
     if (NS_FAILED(rv)) return rv;
     bool isRefValid;
     rv = aStream->ReadBoolean(&isRefValid);
     if (NS_FAILED(rv)) return rv;
     mIsRefValid = isRefValid;
     if (isRefValid) {
         rv = aStream->ReadCString(mRef);
         if (NS_FAILED(rv)) return rv;
     } else {
         mRef.Truncate(); // invariant: mRef should be empty when it's not valid
     }
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::Write(nsIObjectOutputStream* aStream)
 {
     nsresult rv;
     rv = aStream->WriteBoolean(mMutable);
     if (NS_FAILED(rv)) return rv;
     rv = aStream->WriteStringZ(mScheme.get());
     if (NS_FAILED(rv)) return rv;
     rv = aStream->WriteStringZ(mPath.get());
     if (NS_FAILED(rv)) return rv;
     rv = aStream->WriteBoolean(mIsRefValid);
     if (NS_FAILED(rv)) return rv;
     if (mIsRefValid) {
         rv = aStream->WriteStringZ(mRef.get());
         if (NS_FAILED(rv)) return rv;
     }
     return NS_OK;
 }
 ////////////////////////////////////////////////////////////////////////////////
 // nsIIPCSerializableURI methods:
 void
 nsSimpleURI::Serialize(URIParams& aParams)
 {
     SimpleURIParams params;
     params.scheme() = mScheme;
     params.path() = mPath;
     if (mIsRefValid) {
       params.ref() = mRef;
     }
     else {
       params.ref().SetIsVoid(true);
     }
     params.isMutable() = mMutable;
     aParams = params;
 }
 bool
 nsSimpleURI::Deserialize(const URIParams& aParams)
 {
     if (aParams.type() != URIParams::TSimpleURIParams) {
         NS_ERROR("Received unknown parameters from the other process!");
         return false;
     }
     const SimpleURIParams& params = aParams.get_SimpleURIParams();
     mScheme = params.scheme();
     mPath = params.path();
     if (params.ref().IsVoid()) {
         mRef.Truncate();
         mIsRefValid = false;
     }
     else {
         mRef = params.ref();
         mIsRefValid = true;
     }
     mMutable = params.isMutable();
     return true;
 }
 ////////////////////////////////////////////////////////////////////////////////
 // nsIURI methods:
 NS_IMETHODIMP
 nsSimpleURI::GetSpec(nsACString &result)
 {
     result = mScheme + NS_LITERAL_CSTRING(":") + mPath;
     if (mIsRefValid) {
         result += NS_LITERAL_CSTRING("#") + mRef;
     } else {
         NS_ABORT_IF_FALSE(mRef.IsEmpty(), "mIsRefValid/mRef invariant broken");
     }
     return NS_OK;
 }
 // result may contain unescaped UTF-8 characters
 NS_IMETHODIMP
 nsSimpleURI::GetSpecIgnoringRef(nsACString &result)
 {
     result = mScheme + NS_LITERAL_CSTRING(":") + mPath;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetHasRef(bool *result)
 {
     *result = mIsRefValid;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::SetSpec(const nsACString &aSpec)
 {
     NS_ENSURE_STATE(mMutable);
     const nsAFlatCString& flat = PromiseFlatCString(aSpec);
     const char* specPtr = flat.get();
     // filter out unexpected chars "\r\n\t" if necessary
     nsAutoCString filteredSpec;
     int32_t specLen;
     if (net_FilterURIString(specPtr, filteredSpec)) {
         specPtr = filteredSpec.get();
         specLen = filteredSpec.Length();
     } else
         specLen = flat.Length();
     // nsSimpleURI currently restricts the charset to US-ASCII
     nsAutoCString spec;
     NS_EscapeURL(specPtr, specLen, esc_OnlyNonASCII|esc_AlwaysCopy, spec);
     int32_t colonPos = spec.FindChar(':');
     if (colonPos < 0 || !net_IsValidScheme(spec.get(), colonPos))
         return NS_ERROR_MALFORMED_URI;
     mScheme.Truncate();
     mozilla::DebugOnly<int32_t> n = spec.Left(mScheme, colonPos);
     NS_ASSERTION(n == colonPos, "Left failed");
     ToLowerCase(mScheme);
     // This sets both mPath and mRef.
     return SetPath(Substring(spec, colonPos + 1));
 }
 NS_IMETHODIMP
 nsSimpleURI::GetScheme(nsACString &result)
 {
     result = mScheme;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::SetScheme(const nsACString &scheme)
 {
     NS_ENSURE_STATE(mMutable);
     const nsPromiseFlatCString &flat = PromiseFlatCString(scheme);
     if (!net_IsValidScheme(flat)) {
         NS_ERROR("the given url scheme contains invalid characters");
         return NS_ERROR_MALFORMED_URI;
     }
     mScheme = scheme;
     ToLowerCase(mScheme);
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetPrePath(nsACString &result)
 {
     result = mScheme + NS_LITERAL_CSTRING(":");
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetUserPass(nsACString &result)
 {
     return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsSimpleURI::SetUserPass(const nsACString &userPass)
 {
     NS_ENSURE_STATE(mMutable);
     return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetUsername(nsACString &result)
 {
     return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsSimpleURI::SetUsername(const nsACString &userName)
 {
     NS_ENSURE_STATE(mMutable);
     return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetPassword(nsACString &result)
 {
     return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsSimpleURI::SetPassword(const nsACString &password)
 {
     NS_ENSURE_STATE(mMutable);
     return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetHostPort(nsACString &result)
 {
     // Note: Audit all callers before changing this to return an empty
     // string -- CAPS and UI code may depend on this throwing.
     return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsSimpleURI::SetHostPort(const nsACString &result)
 {
     NS_ENSURE_STATE(mMutable);
     return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetHost(nsACString &result)
 {
     // Note: Audit all callers before changing this to return an empty
     // string -- CAPS and UI code depend on this throwing.
     return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsSimpleURI::SetHost(const nsACString &host)
 {
     NS_ENSURE_STATE(mMutable);
     return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetPort(int32_t *result)
 {
     // Note: Audit all callers before changing this to return an empty
     // string -- CAPS and UI code may depend on this throwing.
     return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsSimpleURI::SetPort(int32_t port)
 {
     NS_ENSURE_STATE(mMutable);
     return NS_ERROR_FAILURE;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetPath(nsACString &result)
 {
     result = mPath;
     if (mIsRefValid) {
         result += NS_LITERAL_CSTRING("#") + mRef;
     }
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::SetPath(const nsACString &path)
 {
     NS_ENSURE_STATE(mMutable);
     int32_t hashPos = path.FindChar('#');
     if (hashPos < 0) {
         mIsRefValid = false;
         mRef.Truncate(); // invariant: mRef should be empty when it's not valid
         mPath = path;
         return NS_OK;
     }
     mPath = StringHead(path, hashPos);
     return SetRef(Substring(path, uint32_t(hashPos)));
 }
 NS_IMETHODIMP
 nsSimpleURI::GetRef(nsACString &result)
 {
     if (!mIsRefValid) {
       NS_ABORT_IF_FALSE(mRef.IsEmpty(), "mIsRefValid/mRef invariant broken");
       result.Truncate();
     } else {
       result = mRef;
     }
     return NS_OK;
 }
 // NOTE: SetRef("") removes our ref, whereas SetRef("#") sets it to the empty
 // string (and will result in .spec and .path having a terminal #).
 NS_IMETHODIMP
 nsSimpleURI::SetRef(const nsACString &aRef)
 {
     NS_ENSURE_STATE(mMutable);
     if (aRef.IsEmpty()) {
       // Empty string means to remove ref completely.
       mIsRefValid = false;
       mRef.Truncate(); // invariant: mRef should be empty when it's not valid
       return NS_OK;
     }
     mIsRefValid = true;
     // Gracefully skip initial hash
     if (aRef[0] == '#') {
         mRef = Substring(aRef, 1);
     } else {
         mRef = aRef;
     }
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::Equals(nsIURI* other, bool *result)
 {
     return EqualsInternal(other, eHonorRef, result);
 }
 NS_IMETHODIMP
 nsSimpleURI::EqualsExceptRef(nsIURI* other, bool *result)
 {
     return EqualsInternal(other, eIgnoreRef, result);
 }
 /* virtual */ nsresult
 nsSimpleURI::EqualsInternal(nsIURI* other,
                             nsSimpleURI::RefHandlingEnum refHandlingMode,
                             bool* result)
 {
     NS_ENSURE_ARG_POINTER(other);
     NS_PRECONDITION(result, "null pointer");
     nsRefPtr<nsSimpleURI> otherUri;
     nsresult rv = other->QueryInterface(kThisSimpleURIImplementationCID,
                                         getter_AddRefs(otherUri));
     if (NS_FAILED(rv)) {
         *result = false;
         return NS_OK;
     }
     *result = EqualsInternal(otherUri, refHandlingMode);
     return NS_OK;
 }
 bool
 nsSimpleURI::EqualsInternal(nsSimpleURI* otherUri, RefHandlingEnum refHandlingMode)
 {
     bool result = (mScheme == otherUri->mScheme &&
                    mPath   == otherUri->mPath);
     if (result && refHandlingMode == eHonorRef) {
         result = (mIsRefValid == otherUri->mIsRefValid &&
                   (!mIsRefValid || mRef == otherUri->mRef));
     }
     return result;
 }
 NS_IMETHODIMP
 nsSimpleURI::SchemeIs(const char *i_Scheme, bool *o_Equals)
 {
     NS_ENSURE_ARG_POINTER(o_Equals);
     if (!i_Scheme) return NS_ERROR_NULL_POINTER;
     const char *this_scheme = mScheme.get();
     // mScheme is guaranteed to be lower case.
     if (*i_Scheme == *this_scheme || *i_Scheme == (*this_scheme - ('a' - 'A')) ) {
         *o_Equals = PL_strcasecmp(this_scheme, i_Scheme) ? false : true;
     } else {
         *o_Equals = false;
     }
     return NS_OK;
 }
 /* virtual */ nsSimpleURI*
 nsSimpleURI::StartClone(nsSimpleURI::RefHandlingEnum /* ignored */)
 {
     return new nsSimpleURI();
 }
 NS_IMETHODIMP
 nsSimpleURI::Clone(nsIURI** result)
 {
     return CloneInternal(eHonorRef, result);
 }
 NS_IMETHODIMP
 nsSimpleURI::CloneIgnoringRef(nsIURI** result)
 {
     return CloneInternal(eIgnoreRef, result);
 }
 nsresult
 nsSimpleURI::CloneInternal(nsSimpleURI::RefHandlingEnum refHandlingMode,
                            nsIURI** result)
 {
     nsRefPtr<nsSimpleURI> url = StartClone(refHandlingMode);
     if (!url)
         return NS_ERROR_OUT_OF_MEMORY;
     // Note: |url| may well have mMutable false at this point, so
     // don't call any setter methods.
     url->mScheme = mScheme;
     url->mPath = mPath;
     if (refHandlingMode == eHonorRef) {
         url->mRef = mRef;
         url->mIsRefValid = mIsRefValid;
     }
     url.forget(result);
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::Resolve(const nsACString &relativePath, nsACString &result)
 {
     result = relativePath;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetAsciiSpec(nsACString &result)
 {
     nsAutoCString buf;
     nsresult rv = GetSpec(buf);
     if (NS_FAILED(rv)) return rv;
     NS_EscapeURL(buf, esc_OnlyNonASCII|esc_AlwaysCopy, result);
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetAsciiHost(nsACString &result)
 {
     result.Truncate();
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetOriginCharset(nsACString &result)
 {
     result.Truncate();
     return NS_OK;
 }
 //----------------------------------------------------------------------------
 // nsSimpleURI::nsIClassInfo
 //----------------------------------------------------------------------------
 NS_IMETHODIMP
 nsSimpleURI::GetInterfaces(uint32_t *count, nsIID * **array)
 {
     *count = 0;
     *array = nullptr;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetHelperForLanguage(uint32_t language, nsISupports **_retval)
 {
     *_retval = nullptr;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetContractID(char * *aContractID)
 {
     // Make sure to modify any subclasses as needed if this ever
     // changes.
     *aContractID = nullptr;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetClassDescription(char * *aClassDescription)
 {
     *aClassDescription = nullptr;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetClassID(nsCID * *aClassID)
 {
     // Make sure to modify any subclasses as needed if this ever
     // changes to not call the virtual GetClassIDNoAlloc.
     *aClassID = (nsCID*) nsMemory::Alloc(sizeof(nsCID));
     if (!*aClassID)
         return NS_ERROR_OUT_OF_MEMORY;
     return GetClassIDNoAlloc(*aClassID);
 }
 NS_IMETHODIMP
 nsSimpleURI::GetImplementationLanguage(uint32_t *aImplementationLanguage)
 {
     *aImplementationLanguage = nsIProgrammingLanguage::CPLUSPLUS;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetFlags(uint32_t *aFlags)
 {
     *aFlags = nsIClassInfo::MAIN_THREAD_ONLY;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::GetClassIDNoAlloc(nsCID *aClassIDNoAlloc)
 {
     *aClassIDNoAlloc = kSimpleURICID;
     return NS_OK;
 }
 //----------------------------------------------------------------------------
 // nsSimpleURI::nsISimpleURI
 //----------------------------------------------------------------------------
 NS_IMETHODIMP
 nsSimpleURI::GetMutable(bool *value)
 {
     *value = mMutable;
     return NS_OK;
 }
 NS_IMETHODIMP
 nsSimpleURI::SetMutable(bool value)
 {
     NS_ENSURE_ARG(mMutable || !value);
     mMutable = value;
     return NS_OK;
 }
 //----------------------------------------------------------------------------
 // nsSimpleURI::nsISizeOf
 //----------------------------------------------------------------------------
 size_t
 nsSimpleURI::SizeOfExcludingThis(mozilla::MallocSizeOf aMallocSizeOf) const
 {
   return mScheme.SizeOfExcludingThisIfUnshared(aMallocSizeOf) +
          mPath.SizeOfExcludingThisIfUnshared(aMallocSizeOf) +
          mRef.SizeOfExcludingThisIfUnshared(aMallocSizeOf);
 }
 size_t
 nsSimpleURI::SizeOfIncludingThis(mozilla::MallocSizeOf aMallocSizeOf) const {
   return aMallocSizeOf(this) + SizeOfExcludingThis(aMallocSizeOf);
 }

The Tor Browser / annotate

netwerk/base/src/nsSimpleURI.cpp@b8a032363ba2 (annotated)

netwerk/base/src/nsSimpleURI.cpp