bool
nsMozIconURI::Deserialize(const URIParams& aParams)
{
if (aParams.type() != URIParams::TIconURIParams) {
MOZ_ASSERT_UNREACHABLE("Received unknown URI from other process!");
return false;
}
const IconURIParams& params = aParams.get_IconURIParams();
if (params.uri().type() != OptionalURIParams::Tvoid_t) {
nsCOMPtr<nsIURI> uri = DeserializeURI(params.uri().get_URIParams());
mIconURL = do_QueryInterface(uri);
if (!mIconURL) {
MOZ_ASSERT_UNREACHABLE("bad nsIURI passed");
return false;
}
}
mSize = params.size();
mContentType = params.contentType();
mFileName = params.fileName();
mStockIcon = params.stockIcon();
mIconSize = params.iconSize();
mIconState = params.iconState();
return true;
}
void
nsMozIconURI::Serialize(URIParams& aParams)
{
IconURIParams params;
if (mIconURL) {
URIParams iconURLParams;
SerializeURI(mIconURL, iconURLParams);
if (iconURLParams.type() == URIParams::T__None) {
// Serialization failed, bail.
return;
}
params.uri() = iconURLParams;
} else {
params.uri() = void_t();
}
params.size() = mSize;
params.fileName() = mFileName;
params.stockIcon() = mStockIcon;
params.iconSize() = mIconSize;
params.iconState() = mIconState;
aParams = params;
}
already_AddRefed<nsIURI>
DeserializeURI(const URIParams& aParams)
{
MOZ_ASSERT(NS_IsMainThread());
nsCOMPtr<nsIURIMutator> mutator;
switch (aParams.type()) {
case URIParams::TSimpleURIParams:
mutator = do_CreateInstance(kSimpleURIMutatorCID);
break;
case URIParams::TStandardURLParams:
mutator = do_CreateInstance(kStandardURLMutatorCID);
break;
case URIParams::TJARURIParams:
mutator = do_CreateInstance(kJARURIMutatorCID);
break;
case URIParams::TJSURIParams:
mutator = new nsJSURI::Mutator();
break;
case URIParams::TIconURIParams:
mutator = do_CreateInstance(kIconURIMutatorCID);
break;
case URIParams::TNullPrincipalURIParams:
mutator = new NullPrincipalURI::Mutator();
break;
case URIParams::TSimpleNestedURIParams:
mutator = new nsSimpleNestedURI::Mutator();
break;
case URIParams::THostObjectURIParams:
mutator = new nsHostObjectURI::Mutator();
break;
default:
MOZ_CRASH("Unknown params!");
}
MOZ_ASSERT(mutator);
nsresult rv = mutator->Deserialize(aParams);
if (NS_FAILED(rv)) {
MOZ_ASSERT(false, "Deserialize failed!");
return nullptr;
}
nsCOMPtr<nsIURI> uri;
DebugOnly<nsresult> rv2 = mutator->Finalize(getter_AddRefs(uri));
MOZ_ASSERT(uri);
MOZ_ASSERT(NS_SUCCEEDED(rv2));
return uri.forget();
}
already_AddRefed<nsIURI>
DeserializeURI(const URIParams& aParams)
{
MOZ_ASSERT(NS_IsMainThread());
nsCOMPtr<nsIIPCSerializableURI> serializable;
switch (aParams.type()) {
case URIParams::TSimpleURIParams:
serializable = do_CreateInstance(kSimpleURICID);
break;
case URIParams::TStandardURLParams:
serializable = do_CreateInstance(kStandardURLCID);
break;
case URIParams::TJARURIParams:
serializable = do_CreateInstance(kJARURICID);
break;
case URIParams::TJSURIParams:
serializable = new nsJSURI();
break;
case URIParams::TIconURIParams:
serializable = do_CreateInstance(kIconURICID);
break;
case URIParams::TNullPrincipalURIParams:
serializable = new nsNullPrincipalURI();
break;
case URIParams::TSimpleNestedURIParams:
serializable = new nsSimpleNestedURI();
break;
case URIParams::THostObjectURIParams:
serializable = new nsHostObjectURI();
break;
default:
MOZ_CRASH("Unknown params!");
}
MOZ_ASSERT(serializable);
if (!serializable->Deserialize(aParams)) {
MOZ_ASSERT(false, "Deserialize failed!");
return nullptr;
}
nsCOMPtr<nsIURI> uri = do_QueryInterface(serializable);
MOZ_ASSERT(uri);
return uri.forget();
}
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;
}
void
SerializeURI(nsIURI* aURI,
URIParams& aParams)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aURI);
nsCOMPtr<nsIIPCSerializableURI> serializable = do_QueryInterface(aURI);
if (!serializable) {
MOZ_CRASH("All IPDL URIs must be serializable!");
}
serializable->Serialize(aParams);
if (aParams.type() == URIParams::T__None) {
MOZ_CRASH("Serialize failed!");
}
}
void
SerializeURI(nsIURI* aURI,
URIParams& aParams)
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(aURI);
nsCOMPtr<nsIIPCSerializableURI> serializable = do_QueryInterface(aURI);
if (serializable) {
serializable->Serialize(aParams);
if (aParams.type() == URIParams::T__None) {
MOZ_CRASH("Serialize failed!");
}
return;
}
nsCString scheme;
if (NS_FAILED(aURI->GetScheme(scheme))) {
MOZ_CRASH("This must never fail!");
}
bool allowed = false;
for (size_t i = 0; i < ArrayLength(kGenericURIAllowedSchemes); i++) {
const StringWithLengh& entry = kGenericURIAllowedSchemes[i];
if (scheme.EqualsASCII(entry.string, entry.length)) {
allowed = true;
break;
}
}
if (!allowed) {
MOZ_CRASH("All IPDL URIs must be serializable or an allowed "
"scheme!");
}
GenericURIParams params;
if (NS_FAILED(aURI->GetSpec(params.spec())) ||
NS_FAILED(aURI->GetOriginCharset(params.charset()))) {
MOZ_CRASH("This must never fail!");
}
aParams = params;
}
already_AddRefed<nsIURI>
DeserializeURI(const URIParams& aParams)
{
MOZ_ASSERT(NS_IsMainThread());
nsCOMPtr<nsIURI> uri;
if (aParams.type() != URIParams::TGenericURIParams) {
nsCOMPtr<nsIIPCSerializableURI> serializable;
switch (aParams.type()) {
case URIParams::TSimpleURIParams:
serializable = do_CreateInstance(kSimpleURICID);
break;
case URIParams::TStandardURLParams:
serializable = do_CreateInstance(kStandardURLCID);
break;
case URIParams::TJARURIParams:
serializable = do_CreateInstance(kJARURICID);
break;
default:
MOZ_CRASH("Unknown params!");
}
MOZ_ASSERT(serializable);
if (!serializable->Deserialize(aParams)) {
MOZ_ASSERT(false, "Deserialize failed!");
return nullptr;
}
uri = do_QueryInterface(serializable);
MOZ_ASSERT(uri);
return uri.forget();
}
MOZ_ASSERT(aParams.type() == URIParams::TGenericURIParams);
const GenericURIParams& params = aParams.get_GenericURIParams();
if (NS_FAILED(NS_NewURI(getter_AddRefs(uri), params.spec(),
params.charset().get()))) {
NS_WARNING("Failed to make new URI!");
return nullptr;
}
nsCString scheme;
if (NS_FAILED(uri->GetScheme(scheme))) {
MOZ_CRASH("This must never fail!");
}
bool allowed = false;
for (size_t i = 0; i < ArrayLength(kGenericURIAllowedSchemes); i++) {
const StringWithLengh& entry = kGenericURIAllowedSchemes[i];
if (scheme.EqualsASCII(entry.string, entry.length)) {
allowed = true;
break;
}
}
if (!allowed) {
MOZ_ASSERT(false, "This type of URI is not allowed!");
return nullptr;
}
return uri.forget();
}
