gecko-dev/uriloader/exthandler/HandlerServiceParent.cpp

292 строки
8.3 KiB
C++

#include "mozilla/Logging.h"
#include "HandlerServiceParent.h"
#include "nsIHandlerService.h"
#include "nsIMIMEInfo.h"
#include "ContentHandlerService.h"
#include "nsStringEnumerator.h"
#ifdef MOZ_WIDGET_GTK
#include "unix/nsGNOMERegistry.h"
#endif
using mozilla::dom::HandlerInfo;
using mozilla::dom::HandlerApp;
using mozilla::dom::ContentHandlerService;
using mozilla::dom::RemoteHandlerApp;
namespace {
class ProxyHandlerInfo final : public nsIHandlerInfo {
public:
explicit ProxyHandlerInfo(const HandlerInfo& aHandlerInfo);
NS_DECL_ISUPPORTS;
NS_DECL_NSIHANDLERINFO;
nsTArray<nsCString>& Extensions() {
return mHandlerInfo.extensions();
}
protected:
~ProxyHandlerInfo() {}
HandlerInfo mHandlerInfo;
nsHandlerInfoAction mPrefAction;
nsCOMPtr<nsIMutableArray> mPossibleApps;
};
NS_IMPL_ISUPPORTS(ProxyHandlerInfo, nsIHandlerInfo)
ProxyHandlerInfo::ProxyHandlerInfo(const HandlerInfo& aHandlerInfo)
: mHandlerInfo(aHandlerInfo),
mPrefAction(nsIHandlerInfo::alwaysAsk),
mPossibleApps(do_CreateInstance(NS_ARRAY_CONTRACTID))
{
for (auto& happ : aHandlerInfo.possibleApplicationHandlers()) {
mPossibleApps->AppendElement(new RemoteHandlerApp(happ));
}
}
/* readonly attribute ACString type; */
NS_IMETHODIMP ProxyHandlerInfo::GetType(nsACString & aType)
{
aType.Assign(mHandlerInfo.type());
return NS_OK;
}
/* attribute AString description; */
NS_IMETHODIMP ProxyHandlerInfo::GetDescription(nsAString & aDescription)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
NS_IMETHODIMP ProxyHandlerInfo::SetDescription(const nsAString & aDescription)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* attribute nsIHandlerApp preferredApplicationHandler; */
NS_IMETHODIMP ProxyHandlerInfo::GetPreferredApplicationHandler(nsIHandlerApp * *aPreferredApplicationHandler)
{
*aPreferredApplicationHandler = new RemoteHandlerApp(mHandlerInfo.preferredApplicationHandler());
NS_IF_ADDREF(*aPreferredApplicationHandler);
return NS_OK;
}
NS_IMETHODIMP ProxyHandlerInfo::SetPreferredApplicationHandler(nsIHandlerApp *aApp)
{
nsString name;
nsString detailedDescription;
if (aApp) {
aApp->GetName(name);
aApp->GetDetailedDescription(detailedDescription);
}
mHandlerInfo.preferredApplicationHandler() = HandlerApp(name, detailedDescription);
return NS_OK;
}
/* readonly attribute nsIMutableArray possibleApplicationHandlers; */
NS_IMETHODIMP ProxyHandlerInfo::GetPossibleApplicationHandlers(nsIMutableArray * *aPossibleApplicationHandlers)
{
*aPossibleApplicationHandlers = mPossibleApps;
NS_IF_ADDREF(*aPossibleApplicationHandlers);
return NS_OK;
}
/* readonly attribute boolean hasDefaultHandler; */
NS_IMETHODIMP ProxyHandlerInfo::GetHasDefaultHandler(bool *aHasDefaultHandler)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* readonly attribute AString defaultDescription; */
NS_IMETHODIMP ProxyHandlerInfo::GetDefaultDescription(nsAString & aDefaultDescription)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void launchWithURI (in nsIURI aURI, [optional] in nsIInterfaceRequestor aWindowContext); */
NS_IMETHODIMP ProxyHandlerInfo::LaunchWithURI(nsIURI *aURI, nsIInterfaceRequestor *aWindowContext)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* attribute ProxyHandlerInfoAction preferredAction; */
NS_IMETHODIMP ProxyHandlerInfo::GetPreferredAction(nsHandlerInfoAction *aPreferredAction)
{
*aPreferredAction = mPrefAction;
return NS_OK;
}
NS_IMETHODIMP ProxyHandlerInfo::SetPreferredAction(nsHandlerInfoAction aPreferredAction)
{
mHandlerInfo.preferredAction() = aPreferredAction;
mPrefAction = aPreferredAction;
return NS_OK;
}
/* attribute boolean alwaysAskBeforeHandling; */
NS_IMETHODIMP ProxyHandlerInfo::GetAlwaysAskBeforeHandling(bool *aAlwaysAskBeforeHandling)
{
*aAlwaysAskBeforeHandling = mHandlerInfo.alwaysAskBeforeHandling();
return NS_OK;
}
NS_IMETHODIMP ProxyHandlerInfo::SetAlwaysAskBeforeHandling(bool aAlwaysAskBeforeHandling)
{
mHandlerInfo.alwaysAskBeforeHandling() = aAlwaysAskBeforeHandling;
return NS_OK;
}
class ProxyMIMEInfo : public nsIMIMEInfo
{
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIMIMEINFO
NS_FORWARD_NSIHANDLERINFO(mProxyHandlerInfo->);
explicit ProxyMIMEInfo(const HandlerInfo &aHandlerInfo)
: mProxyHandlerInfo(new ProxyHandlerInfo(aHandlerInfo))
{
}
private:
virtual ~ProxyMIMEInfo() {}
RefPtr<ProxyHandlerInfo> mProxyHandlerInfo;
protected:
/* additional members */
};
NS_IMPL_ISUPPORTS(ProxyMIMEInfo, nsIMIMEInfo, nsIHandlerInfo)
/* nsIUTF8StringEnumerator getFileExtensions (); */
NS_IMETHODIMP ProxyMIMEInfo::GetFileExtensions(nsIUTF8StringEnumerator * *_retval)
{
return NS_NewUTF8StringEnumerator(_retval, &mProxyHandlerInfo->Extensions(), this);
}
/* void setFileExtensions (in AUTF8String aExtensions); */
NS_IMETHODIMP ProxyMIMEInfo::SetFileExtensions(const nsACString & aExtensions)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* boolean extensionExists (in AUTF8String aExtension); */
NS_IMETHODIMP ProxyMIMEInfo::ExtensionExists(const nsACString & aExtension, bool *_retval)
{
*_retval = mProxyHandlerInfo->Extensions().Contains(aExtension);
return NS_OK;
}
/* void appendExtension (in AUTF8String aExtension); */
NS_IMETHODIMP ProxyMIMEInfo::AppendExtension(const nsACString & aExtension)
{
mProxyHandlerInfo->Extensions().AppendElement(aExtension);
return NS_OK;
}
/* attribute AUTF8String primaryExtension; */
NS_IMETHODIMP ProxyMIMEInfo::GetPrimaryExtension(nsACString & aPrimaryExtension)
{
const auto& extensions = mProxyHandlerInfo->Extensions();
if (extensions.IsEmpty()) {
return NS_ERROR_FAILURE;
}
aPrimaryExtension = extensions[0];
return NS_OK;
}
NS_IMETHODIMP ProxyMIMEInfo::SetPrimaryExtension(const nsACString & aPrimaryExtension)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* readonly attribute ACString MIMEType; */
NS_IMETHODIMP ProxyMIMEInfo::GetMIMEType(nsACString & aMIMEType)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* boolean equals (in nsIMIMEInfo aMIMEInfo); */
NS_IMETHODIMP ProxyMIMEInfo::Equals(nsIMIMEInfo *aMIMEInfo, bool *_retval)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* readonly attribute nsIArray possibleLocalHandlers; */
NS_IMETHODIMP ProxyMIMEInfo::GetPossibleLocalHandlers(nsIArray * *aPossibleLocalHandlers)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
/* void launchWithFile (in nsIFile aFile); */
NS_IMETHODIMP ProxyMIMEInfo::LaunchWithFile(nsIFile *aFile)
{
return NS_ERROR_NOT_IMPLEMENTED;
}
static already_AddRefed<nsIHandlerInfo> WrapHandlerInfo(const HandlerInfo& aHandlerInfo) {
nsCOMPtr<nsIHandlerInfo> info;
if (aHandlerInfo.isMIMEInfo()) {
info = new ProxyMIMEInfo(aHandlerInfo);
} else {
info = new ProxyHandlerInfo(aHandlerInfo);
}
return info.forget();
}
} // anonymous namespace
HandlerServiceParent::HandlerServiceParent()
{
}
HandlerServiceParent::~HandlerServiceParent()
{
}
mozilla::ipc::IPCResult
HandlerServiceParent::RecvFillHandlerInfo(const HandlerInfo& aHandlerInfoData,
const nsCString& aOverrideType,
HandlerInfo* handlerInfoData)
{
nsCOMPtr<nsIHandlerInfo> info(WrapHandlerInfo(aHandlerInfoData));
nsCOMPtr<nsIHandlerService> handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID);
handlerSvc->FillHandlerInfo(info, aOverrideType);
ContentHandlerService::nsIHandlerInfoToHandlerInfo(info, handlerInfoData);
return IPC_OK();
}
mozilla::ipc::IPCResult
HandlerServiceParent::RecvExists(const HandlerInfo& aHandlerInfo,
bool* exists)
{
nsCOMPtr<nsIHandlerInfo> info(WrapHandlerInfo(aHandlerInfo));
nsCOMPtr<nsIHandlerService> handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID);
handlerSvc->Exists(info, exists);
return IPC_OK();
}
mozilla::ipc::IPCResult
HandlerServiceParent::RecvExistsForProtocol(const nsCString& aProtocolScheme,
bool* aHandlerExists)
{
#ifdef MOZ_WIDGET_GTK
// Check the GNOME registry for a protocol handler
*aHandlerExists = nsGNOMERegistry::HandlerExists(aProtocolScheme.get());
#else
*aHandlerExists = false;
#endif
return IPC_OK();
}
mozilla::ipc::IPCResult
HandlerServiceParent::RecvGetTypeFromExtension(const nsCString& aFileExtension,
nsCString* type)
{
nsCOMPtr<nsIHandlerService> handlerSvc = do_GetService(NS_HANDLERSERVICE_CONTRACTID);
handlerSvc->GetTypeFromExtension(aFileExtension, *type);
return IPC_OK();
}
void HandlerServiceParent::ActorDestroy(ActorDestroyReason aWhy)
{
}