178 lines
4.6 KiB
C++
178 lines
4.6 KiB
C++
/* -*- Mode: C++; tab-width: 4; 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 "base/basictypes.h"
|
|
|
|
#include "nsNetCID.h"
|
|
#include "nsNetUtil.h"
|
|
#include "nsSimpleNestedURI.h"
|
|
#include "nsIObjectInputStream.h"
|
|
#include "nsIObjectOutputStream.h"
|
|
|
|
#include "mozilla/ipc/URIUtils.h"
|
|
|
|
NS_IMPL_ISUPPORTS_INHERITED(nsSimpleNestedURI, nsSimpleURI, nsINestedURI)
|
|
|
|
nsSimpleNestedURI::nsSimpleNestedURI(nsIURI* innerURI)
|
|
: mInnerURI(innerURI)
|
|
{
|
|
NS_ASSERTION(innerURI, "Must have inner URI");
|
|
NS_TryToSetImmutable(innerURI);
|
|
}
|
|
|
|
// nsISerializable
|
|
|
|
NS_IMETHODIMP
|
|
nsSimpleNestedURI::Read(nsIObjectInputStream* aStream)
|
|
{
|
|
nsresult rv = nsSimpleURI::Read(aStream);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
NS_ASSERTION(!mMutable, "How did that happen?");
|
|
|
|
nsCOMPtr<nsISupports> supports;
|
|
rv = aStream->ReadObject(true, getter_AddRefs(supports));
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
mInnerURI = do_QueryInterface(supports, &rv);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
NS_TryToSetImmutable(mInnerURI);
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSimpleNestedURI::Write(nsIObjectOutputStream* aStream)
|
|
{
|
|
nsCOMPtr<nsISerializable> serializable = do_QueryInterface(mInnerURI);
|
|
if (!serializable) {
|
|
// We can't serialize ourselves
|
|
return NS_ERROR_NOT_AVAILABLE;
|
|
}
|
|
|
|
nsresult rv = nsSimpleURI::Write(aStream);
|
|
if (NS_FAILED(rv)) return rv;
|
|
|
|
rv = aStream->WriteCompoundObject(mInnerURI, NS_GET_IID(nsIURI),
|
|
true);
|
|
return rv;
|
|
}
|
|
|
|
// nsIIPCSerializableURI
|
|
void
|
|
nsSimpleNestedURI::Serialize(mozilla::ipc::URIParams& aParams)
|
|
{
|
|
using namespace mozilla::ipc;
|
|
|
|
SimpleNestedURIParams params;
|
|
URIParams simpleParams;
|
|
|
|
nsSimpleURI::Serialize(simpleParams);
|
|
params.simpleParams() = simpleParams;
|
|
|
|
SerializeURI(mInnerURI, params.innerURI());
|
|
|
|
aParams = params;
|
|
}
|
|
|
|
bool
|
|
nsSimpleNestedURI::Deserialize(const mozilla::ipc::URIParams& aParams)
|
|
{
|
|
using namespace mozilla::ipc;
|
|
|
|
if (aParams.type() != URIParams::TSimpleNestedURIParams) {
|
|
NS_ERROR("Received unknown parameters from the other process!");
|
|
return false;
|
|
}
|
|
|
|
const SimpleNestedURIParams& params = aParams.get_SimpleNestedURIParams();
|
|
if (!nsSimpleURI::Deserialize(params.simpleParams()))
|
|
return false;
|
|
|
|
mInnerURI = DeserializeURI(params.innerURI());
|
|
|
|
NS_TryToSetImmutable(mInnerURI);
|
|
return true;
|
|
}
|
|
|
|
// nsINestedURI
|
|
|
|
NS_IMETHODIMP
|
|
nsSimpleNestedURI::GetInnerURI(nsIURI** uri)
|
|
{
|
|
NS_ENSURE_TRUE(mInnerURI, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
return NS_EnsureSafeToReturn(mInnerURI, uri);
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsSimpleNestedURI::GetInnermostURI(nsIURI** uri)
|
|
{
|
|
return NS_ImplGetInnermostURI(this, uri);
|
|
}
|
|
|
|
// nsSimpleURI overrides
|
|
/* virtual */ nsresult
|
|
nsSimpleNestedURI::EqualsInternal(nsIURI* other,
|
|
nsSimpleURI::RefHandlingEnum refHandlingMode,
|
|
bool* result)
|
|
{
|
|
*result = false;
|
|
NS_ENSURE_TRUE(mInnerURI, NS_ERROR_NOT_INITIALIZED);
|
|
|
|
if (other) {
|
|
bool correctScheme;
|
|
nsresult rv = other->SchemeIs(mScheme.get(), &correctScheme);
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
if (correctScheme) {
|
|
nsCOMPtr<nsINestedURI> nest = do_QueryInterface(other);
|
|
if (nest) {
|
|
nsCOMPtr<nsIURI> otherInner;
|
|
rv = nest->GetInnerURI(getter_AddRefs(otherInner));
|
|
NS_ENSURE_SUCCESS(rv, rv);
|
|
|
|
return (refHandlingMode == eHonorRef) ?
|
|
otherInner->Equals(mInnerURI, result) :
|
|
otherInner->EqualsExceptRef(mInnerURI, result);
|
|
}
|
|
}
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* virtual */ nsSimpleURI*
|
|
nsSimpleNestedURI::StartClone(nsSimpleURI::RefHandlingEnum refHandlingMode)
|
|
{
|
|
NS_ENSURE_TRUE(mInnerURI, nullptr);
|
|
|
|
nsCOMPtr<nsIURI> innerClone;
|
|
nsresult rv = refHandlingMode == eHonorRef ?
|
|
mInnerURI->Clone(getter_AddRefs(innerClone)) :
|
|
mInnerURI->CloneIgnoringRef(getter_AddRefs(innerClone));
|
|
|
|
if (NS_FAILED(rv)) {
|
|
return nullptr;
|
|
}
|
|
|
|
nsSimpleNestedURI* url = new nsSimpleNestedURI(innerClone);
|
|
url->SetMutable(false);
|
|
|
|
return url;
|
|
}
|
|
|
|
// nsIClassInfo overrides
|
|
|
|
NS_IMETHODIMP
|
|
nsSimpleNestedURI::GetClassIDNoAlloc(nsCID *aClassIDNoAlloc)
|
|
{
|
|
static NS_DEFINE_CID(kSimpleNestedURICID, NS_SIMPLENESTEDURI_CID);
|
|
|
|
*aClassIDNoAlloc = kSimpleNestedURICID;
|
|
return NS_OK;
|
|
}
|