gecko-dev/dom/media/gmp/GMPServiceParent.h

253 строки
8.5 KiB
C++

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* 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/. */
#ifndef GMPServiceParent_h_
#define GMPServiceParent_h_
#include "GMPService.h"
#include "mozilla/gmp/PGMPServiceParent.h"
#include "mozIGeckoMediaPluginChromeService.h"
#include "nsClassHashtable.h"
#include "nsDataHashtable.h"
#include "mozilla/Atomics.h"
#include "nsIAsyncShutdown.h"
#include "nsThreadUtils.h"
#include "mozilla/MozPromise.h"
#include "GMPStorage.h"
template <class>
struct already_AddRefed;
namespace mozilla {
namespace gmp {
class GMPParent;
class GMPServiceParent;
class GeckoMediaPluginServiceParent final
: public GeckoMediaPluginService,
public mozIGeckoMediaPluginChromeService,
public nsIAsyncShutdownBlocker {
public:
static already_AddRefed<GeckoMediaPluginServiceParent> GetSingleton();
GeckoMediaPluginServiceParent();
nsresult Init() override;
NS_DECL_ISUPPORTS_INHERITED
NS_DECL_NSIASYNCSHUTDOWNBLOCKER
// mozIGeckoMediaPluginService
NS_IMETHOD HasPluginForAPI(const nsACString& aAPI, nsTArray<nsCString>* aTags,
bool* aRetVal) override;
NS_IMETHOD GetNodeId(const nsAString& aOrigin,
const nsAString& aTopLevelOrigin,
const nsAString& aGMPName,
UniquePtr<GetNodeIdCallback>&& aCallback) override;
NS_DECL_MOZIGECKOMEDIAPLUGINCHROMESERVICE
NS_DECL_NSIOBSERVER
RefPtr<GenericPromise> EnsureInitialized();
RefPtr<GenericPromise> AsyncAddPluginDirectory(const nsAString& aDirectory);
// GMP thread access only
bool IsShuttingDown();
already_AddRefed<GMPStorage> GetMemoryStorageFor(const nsACString& aNodeId);
nsresult ForgetThisSiteNative(
const nsAString& aSite, const mozilla::OriginAttributesPattern& aPattern);
// Notifies that some user of this class is created/destroyed.
void ServiceUserCreated(GMPServiceParent* aServiceParent);
void ServiceUserDestroyed(GMPServiceParent* aServiceParent);
void UpdateContentProcessGMPCapabilities();
AbstractThread* MainThread() const { return mMainThread; }
private:
friend class GMPServiceParent;
virtual ~GeckoMediaPluginServiceParent();
void ClearStorage();
already_AddRefed<GMPParent> SelectPluginForAPI(
const nsACString& aNodeId, const nsCString& aAPI,
const nsTArray<nsCString>& aTags);
already_AddRefed<GMPParent> FindPluginForAPIFrom(
size_t aSearchStartIndex, const nsCString& aAPI,
const nsTArray<nsCString>& aTags, size_t* aOutPluginIndex);
nsresult GetNodeId(const nsAString& aOrigin, const nsAString& aTopLevelOrigin,
const nsAString& aGMPName, nsACString& aOutId);
void UnloadPlugins();
void CrashPlugins();
void NotifySyncShutdownComplete();
void RemoveOnGMPThread(const nsAString& aDirectory,
const bool aDeleteFromDisk, const bool aCanDefer);
struct DirectoryFilter {
virtual bool operator()(nsIFile* aPath) = 0;
~DirectoryFilter() {}
};
void ClearNodeIdAndPlugin(DirectoryFilter& aFilter);
void ClearNodeIdAndPlugin(nsIFile* aPluginStorageDir,
DirectoryFilter& aFilter);
void ForgetThisSiteOnGMPThread(
const nsACString& aOrigin,
const mozilla::OriginAttributesPattern& aPattern);
void ClearRecentHistoryOnGMPThread(PRTime aSince);
already_AddRefed<GMPParent> GetById(uint32_t aPluginId);
protected:
friend class GMPParent;
void ReAddOnGMPThread(const RefPtr<GMPParent>& aOld);
void PluginTerminated(const RefPtr<GMPParent>& aOld);
void InitializePlugins(AbstractThread* aAbstractGMPThread) override;
RefPtr<GenericPromise> LoadFromEnvironment();
RefPtr<GenericPromise> AddOnGMPThread(nsString aDirectory);
RefPtr<GetGMPContentParentPromise> GetContentParent(
GMPCrashHelper* aHelper, const nsACString& aNodeIdString,
const nsCString& aAPI, const nsTArray<nsCString>& aTags) override;
RefPtr<GetGMPContentParentPromise> GetContentParent(
GMPCrashHelper* aHelper, const NodeId& aNodeId, const nsCString& aAPI,
const nsTArray<nsCString>& aTags) override;
private:
// Creates a copy of aOriginal. Note that the caller is responsible for
// adding this to GeckoMediaPluginServiceParent::mPlugins.
already_AddRefed<GMPParent> ClonePlugin(const GMPParent* aOriginal);
nsresult EnsurePluginsOnDiskScanned();
nsresult InitStorage();
class PathRunnable : public Runnable {
public:
enum EOperation {
REMOVE,
REMOVE_AND_DELETE_FROM_DISK,
};
PathRunnable(GeckoMediaPluginServiceParent* aService,
const nsAString& aPath, EOperation aOperation,
bool aDefer = false)
: Runnable("gmp::GeckoMediaPluginServiceParent::PathRunnable"),
mService(aService),
mPath(aPath),
mOperation(aOperation),
mDefer(aDefer) {}
NS_DECL_NSIRUNNABLE
private:
RefPtr<GeckoMediaPluginServiceParent> mService;
nsString mPath;
EOperation mOperation;
bool mDefer;
};
// Protected by mMutex from the base class.
nsTArray<RefPtr<GMPParent>> mPlugins;
bool mShuttingDown;
// True if we've inspected MOZ_GMP_PATH on the GMP thread and loaded any
// plugins found there into mPlugins.
Atomic<bool> mScannedPluginOnDisk;
template <typename T>
class MainThreadOnly {
public:
MOZ_IMPLICIT MainThreadOnly(T aValue) : mValue(aValue) {}
operator T&() {
MOZ_ASSERT(NS_IsMainThread());
return mValue;
}
private:
T mValue;
};
MainThreadOnly<bool> mWaitingForPluginsSyncShutdown;
nsTArray<nsString> mPluginsWaitingForDeletion;
nsCOMPtr<nsIFile> mStorageBaseDir;
// Hashes of (origin,topLevelOrigin) to the node id for
// non-persistent sessions.
nsClassHashtable<nsUint32HashKey, nsCString> mTempNodeIds;
// Hashes node id to whether that node id is allowed to store data
// persistently on disk.
nsDataHashtable<nsCStringHashKey, bool> mPersistentStorageAllowed;
// Synchronization for barrier that ensures we've loaded GMPs from
// MOZ_GMP_PATH before allowing GetContentParentFrom() to proceed.
Monitor mInitPromiseMonitor;
MozPromiseHolder<GenericPromise> mInitPromise;
bool mLoadPluginsFromDiskComplete;
// Hashes nodeId to the hashtable of storage for that nodeId.
nsRefPtrHashtable<nsCStringHashKey, GMPStorage> mTempGMPStorage;
// Tracks how many IPC connections to GMPServices running in content
// processes we have. When this is empty we can safely shut down.
// Synchronized across thread via mMutex in base class.
nsTArray<GMPServiceParent*> mServiceParents;
const RefPtr<AbstractThread> mMainThread;
};
nsresult ReadSalt(nsIFile* aPath, nsACString& aOutData);
bool MatchOrigin(nsIFile* aPath, const nsACString& aSite,
const mozilla::OriginAttributesPattern& aPattern);
class GMPServiceParent final : public PGMPServiceParent {
public:
explicit GMPServiceParent(GeckoMediaPluginServiceParent* aService);
virtual ~GMPServiceParent();
ipc::IPCResult RecvGetGMPNodeId(const nsString& aOrigin,
const nsString& aTopLevelOrigin,
const nsString& aGMPName,
nsCString* aID) override;
void ActorDestroy(ActorDestroyReason aWhy) override;
static bool Create(Endpoint<PGMPServiceParent>&& aGMPService);
ipc::IPCResult RecvLaunchGMP(const nsCString& aNodeId, const nsCString& aAPI,
nsTArray<nsCString>&& aTags,
nsTArray<ProcessId>&& aAlreadyBridgedTo,
uint32_t* aOutPluginId, ProcessId* aOutID,
nsCString* aOutDisplayName,
Endpoint<PGMPContentParent>* aOutEndpoint,
nsresult* aOutRv,
nsCString* aOutErrorDescription) override;
ipc::IPCResult RecvLaunchGMPForNodeId(
const NodeIdData& nodeId, const nsCString& aAPI,
nsTArray<nsCString>&& aTags, nsTArray<ProcessId>&& aAlreadyBridgedTo,
uint32_t* aOutPluginId, ProcessId* aOutID, nsCString* aOutDisplayName,
Endpoint<PGMPContentParent>* aOutEndpoint, nsresult* aOutRv,
nsCString* aOutErrorDescription) override;
private:
void CloseTransport(Monitor* aSyncMonitor, bool* aCompleted);
RefPtr<GeckoMediaPluginServiceParent> mService;
};
} // namespace gmp
} // namespace mozilla
#endif // GMPServiceParent_h_