gecko-dev/toolkit/components/extensions/ExtensionPolicyService.h

/* -*-  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 mozilla_ExtensionPolicyService_h
#define mozilla_ExtensionPolicyService_h

#include "mozilla/MemoryReporting.h"
#include "mozilla/extensions/WebExtensionPolicy.h"
#include "nsCOMPtr.h"
#include "nsCycleCollectionParticipant.h"
#include "nsHashKeys.h"
#include "nsIAddonPolicyService.h"
#include "nsAtom.h"
#include "nsIDOMEventListener.h"
#include "nsIMemoryReporter.h"
#include "nsIObserver.h"
#include "nsIObserverService.h"
#include "nsISupports.h"
#include "nsPointerHashKeys.h"
#include "nsRefPtrHashtable.h"
#include "nsTHashtable.h"

class nsIChannel;
class nsIObserverService;
class nsIDocument;
class nsIPIDOMWindowInner;
class nsIPIDOMWindowOuter;

namespace mozilla {
namespace dom {
  class ContentFrameMessageManager;
  class Promise;
}
namespace extensions {
  class DocInfo;
  class DocumentObserver;
  class WebExtensionContentScript;
}

using extensions::DocInfo;
using extensions::WebExtensionPolicy;

class ExtensionPolicyService final : public nsIAddonPolicyService
                                   , public nsIObserver
                                   , public nsIDOMEventListener
                                   , public nsIMemoryReporter
{
public:
  NS_DECL_CYCLE_COLLECTION_CLASS_AMBIGUOUS(ExtensionPolicyService,
                                           nsIAddonPolicyService)
  NS_DECL_CYCLE_COLLECTING_ISUPPORTS
  NS_DECL_NSIADDONPOLICYSERVICE
  NS_DECL_NSIOBSERVER
  NS_DECL_NSIDOMEVENTLISTENER
  NS_DECL_NSIMEMORYREPORTER

  static ExtensionPolicyService& GetSingleton();

  static already_AddRefed<ExtensionPolicyService> GetInstance()
  {
    return do_AddRef(&GetSingleton());
  }

  WebExtensionPolicy*
  GetByID(const nsAtom* aAddonId)
  {
    return mExtensions.GetWeak(aAddonId);
  }

  WebExtensionPolicy* GetByID(const nsAString& aAddonId)
  {
    RefPtr<nsAtom> atom = NS_AtomizeMainThread(aAddonId);
    return GetByID(atom);
  }

  WebExtensionPolicy* GetByURL(const extensions::URLInfo& aURL);

  WebExtensionPolicy* GetByHost(const nsACString& aHost) const
  {
    return mExtensionHosts.GetWeak(aHost);
  }

  void GetAll(nsTArray<RefPtr<WebExtensionPolicy>>& aResult);

  bool RegisterExtension(WebExtensionPolicy& aPolicy);
  bool UnregisterExtension(WebExtensionPolicy& aPolicy);

  bool RegisterObserver(extensions::DocumentObserver& aPolicy);
  bool UnregisterObserver(extensions::DocumentObserver& aPolicy);

  void BaseCSP(nsAString& aDefaultCSP) const;
  void DefaultCSP(nsAString& aDefaultCSP) const;

  bool UseRemoteExtensions() const;
  bool IsExtensionProcess() const;

  nsresult InjectContentScripts(WebExtensionPolicy* aExtension);

protected:
  virtual ~ExtensionPolicyService();

private:
  ExtensionPolicyService();

  void RegisterObservers();
  void UnregisterObservers();

  void CheckRequest(nsIChannel* aChannel);
  void CheckDocument(nsIDocument* aDocument);
  void CheckWindow(nsPIDOMWindowOuter* aWindow);

  void CheckContentScripts(const DocInfo& aDocInfo, bool aIsPreload);

  already_AddRefed<dom::Promise>
  ExecuteContentScript(nsPIDOMWindowInner* aWindow,
                       extensions::WebExtensionContentScript& aScript);

  RefPtr<dom::Promise>
  ExecuteContentScripts(JSContext* aCx, nsPIDOMWindowInner* aWindow,
                        const nsTArray<RefPtr<extensions::WebExtensionContentScript>>& aScripts);

  nsRefPtrHashtable<nsPtrHashKey<const nsAtom>, WebExtensionPolicy> mExtensions;
  nsRefPtrHashtable<nsCStringHashKey, WebExtensionPolicy> mExtensionHosts;

  nsTHashtable<nsRefPtrHashKey<dom::ContentFrameMessageManager>> mMessageManagers;

  nsRefPtrHashtable<nsPtrHashKey<const extensions::DocumentObserver>,
                    extensions::DocumentObserver> mObservers;

  nsCOMPtr<nsIObserverService> mObs;

  static bool sRemoteExtensions;
};

} // namespace mozilla

#endif // mozilla_ExtensionPolicyService_h