toolkit/components/extensions/WebExtensionContentScript.h

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2; -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 #ifndef mozilla_extensions_WebExtensionContentScript_h
   7 #define mozilla_extensions_WebExtensionContentScript_h
   8
   9 #include "mozilla/dom/BindingDeclarations.h"
  10 #include "mozilla/dom/WebExtensionContentScriptBinding.h"
  11
  12 #include "jspubtd.h"
  13
  14 #include "mozilla/Maybe.h"
  15 #include "mozilla/Variant.h"
  16 #include "mozilla/extensions/MatchGlob.h"
  17 #include "mozilla/extensions/MatchPattern.h"
  18 #include "nsCOMPtr.h"
  19 #include "nsCycleCollectionParticipant.h"
  20 #include "nsISupports.h"
  21 #include "nsIDocShell.h"
  22 #include "nsPIDOMWindow.h"
  23 #include "nsWrapperCache.h"
  24
  25 class nsILoadInfo;
  26 class nsPIDOMWindowOuter;
  27
  28 namespace mozilla {
  29 namespace dom {
  30 class WindowGlobalChild;
  31 }
  32
  33 namespace extensions {
  34
  35 using dom::Nullable;
  36 using ContentScriptInit = dom::WebExtensionContentScriptInit;
  37
  38 class WebExtensionPolicy;
  39
  40 class MOZ_STACK_CLASS DocInfo final {
  41  public:
  42   DocInfo(const URLInfo& aURL, nsILoadInfo* aLoadInfo);
  43
  44   MOZ_IMPLICIT DocInfo(nsPIDOMWindowOuter* aWindow);
  45
  46   const URLInfo& URL() const { return mURL; }
  47
  48   // The principal of the document, or the expected principal of a request.
  49   // May be null for non-DOMWindow DocInfo objects unless
  50   // URL().InheritsPrincipal() is true.
  51   nsIPrincipal* Principal() const;
  52
  53   // Returns the URL of the document's principal. Note that this must *only*
  54   // be called for content principals.
  55   const URLInfo& PrincipalURL() const;
  56
  57   bool IsTopLevel() const;
  58   bool IsSameOriginWithTop() const;
  59   bool ShouldMatchActiveTabPermission() const;
  60
  61   uint64_t FrameID() const;
  62
  63   nsPIDOMWindowOuter* GetWindow() const {
  64     if (mObj.is<Window>()) {
  65       return mObj.as<Window>();
  66     }
  67     return nullptr;
  68   }
  69
  70   nsILoadInfo* GetLoadInfo() const {
  71     if (mObj.is<LoadInfo>()) {
  72       return mObj.as<LoadInfo>();
  73     }
  74     return nullptr;
  75   }
  76
  77   already_AddRefed<nsILoadContext> GetLoadContext() const {
  78     nsCOMPtr<nsILoadContext> loadContext;
  79     if (nsPIDOMWindowOuter* window = GetWindow()) {
  80       nsIDocShell* docShell = window->GetDocShell();
  81       loadContext = do_QueryInterface(docShell);
  82     } else if (nsILoadInfo* loadInfo = GetLoadInfo()) {
  83       nsCOMPtr<nsISupports> requestingContext = loadInfo->GetLoadingContext();
  84       loadContext = do_QueryInterface(requestingContext);
  85     }
  86     return loadContext.forget();
  87   }
  88
  89  private:
  90   void SetURL(const URLInfo& aURL);
  91
  92   const URLInfo mURL;
  93   mutable Maybe<const URLInfo> mPrincipalURL;
  94
  95   mutable Maybe<bool> mIsTopLevel;
  96
  97   mutable Maybe<nsCOMPtr<nsIPrincipal>> mPrincipal;
  98   mutable Maybe<uint64_t> mFrameID;
  99
 100   using Window = nsPIDOMWindowOuter*;
 101   using LoadInfo = nsILoadInfo*;
 102
 103   const Variant<LoadInfo, Window> mObj;
 104 };
 105
 106 class MozDocumentMatcher : public nsISupports, public nsWrapperCache {
 107   NS_DECL_CYCLE_COLLECTING_ISUPPORTS
 108   NS_DECL_CYCLE_COLLECTION_WRAPPERCACHE_CLASS(MozDocumentMatcher)
 109
 110   using MatchGlobArray = nsTArray<RefPtr<MatchGlob>>;
 111
 112   static already_AddRefed<MozDocumentMatcher> Constructor(
 113       dom::GlobalObject& aGlobal, const dom::MozDocumentMatcherInit& aInit,
 114       ErrorResult& aRv);
 115
 116   bool Matches(const DocInfo& aDoc, bool aIgnorePermissions) const;
 117   bool Matches(const DocInfo& aDoc) const { return Matches(aDoc, false); }
 118
 119   bool MatchesURI(const URLInfo& aURL, bool aIgnorePermissions) const;
 120   bool MatchesURI(const URLInfo& aURL) const { return MatchesURI(aURL, false); }
 121
 122   bool MatchesWindowGlobal(dom::WindowGlobalChild& aWindow,
 123                            bool aIgnorePermissions) const;
 124
 125   WebExtensionPolicy* GetExtension() { return mExtension; }
 126
 127   WebExtensionPolicy* Extension() { return mExtension; }
 128   const WebExtensionPolicy* Extension() const { return mExtension; }
 129
 130   bool AllFrames() const { return mAllFrames; }
 131   bool CheckPermissions() const { return mCheckPermissions; }
 132   bool MatchAboutBlank() const { return mMatchAboutBlank; }
 133
 134   MatchPatternSet* Matches() { return mMatches; }
 135   const MatchPatternSet* GetMatches() const { return mMatches; }
 136
 137   MatchPatternSet* GetExcludeMatches() { return mExcludeMatches; }
 138   const MatchPatternSet* GetExcludeMatches() const { return mExcludeMatches; }
 139
 140   Nullable<uint64_t> GetFrameID() const { return mFrameID; }
 141
 142   void GetOriginAttributesPatterns(JSContext* aCx,
 143                                    JS::MutableHandle<JS::Value> aVal,
 144                                    ErrorResult& aError) const;
 145
 146   WebExtensionPolicy* GetParentObject() const { return mExtension; }
 147   virtual JSObject* WrapObject(JSContext* aCx,
 148                                JS::Handle<JSObject*> aGivenProto) override;
 149
 150  protected:
 151   friend class WebExtensionPolicy;
 152
 153   virtual ~MozDocumentMatcher() = default;
 154
 155   MozDocumentMatcher(dom::GlobalObject& aGlobal,
 156                      const dom::MozDocumentMatcherInit& aInit, bool aRestricted,
 157                      ErrorResult& aRv);
 158
 159   RefPtr<WebExtensionPolicy> mExtension;
 160
 161   bool mHasActiveTabPermission;
 162   bool mRestricted;
 163
 164   RefPtr<MatchPatternSet> mMatches;
 165   RefPtr<MatchPatternSet> mExcludeMatches;
 166
 167   Nullable<MatchGlobSet> mIncludeGlobs;
 168   Nullable<MatchGlobSet> mExcludeGlobs;
 169
 170   bool mAllFrames;
 171   bool mCheckPermissions;
 172   Nullable<uint64_t> mFrameID;
 173   bool mMatchAboutBlank;
 174   Nullable<dom::Sequence<OriginAttributesPattern>> mOriginAttributesPatterns;
 175 };
 176
 177 class WebExtensionContentScript final : public MozDocumentMatcher {
 178  public:
 179   using RunAtEnum = dom::ContentScriptRunAt;
 180
 181   static already_AddRefed<WebExtensionContentScript> Constructor(
 182       dom::GlobalObject& aGlobal, WebExtensionPolicy& aExtension,
 183       const ContentScriptInit& aInit, ErrorResult& aRv);
 184
 185   RunAtEnum RunAt() const { return mRunAt; }
 186
 187   void GetCssPaths(nsTArray<nsString>& aPaths) const {
 188     aPaths.AppendElements(mCssPaths);
 189   }
 190   void GetJsPaths(nsTArray<nsString>& aPaths) const {
 191     aPaths.AppendElements(mJsPaths);
 192   }
 193
 194   virtual JSObject* WrapObject(JSContext* aCx,
 195                                JS::Handle<JSObject*> aGivenProto) override;
 196
 197  protected:
 198   friend class WebExtensionPolicy;
 199
 200   virtual ~WebExtensionContentScript() = default;
 201
 202   WebExtensionContentScript(dom::GlobalObject& aGlobal,
 203                             WebExtensionPolicy& aExtension,
 204                             const ContentScriptInit& aInit, ErrorResult& aRv);
 205
 206  private:
 207   nsTArray<nsString> mCssPaths;
 208   nsTArray<nsString> mJsPaths;
 209
 210   RunAtEnum mRunAt;
 211 };
 212
 213 }  // namespace extensions
 214 }  // namespace mozilla
 215
 216 #endif  // mozilla_extensions_WebExtensionContentScript_h