ContentClassifierEngine.h

Enable keyboard shortcuts

/* 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 https://mozilla.org/MPL/2.0/. */

#ifndef mozilla_ContentClassifierEngine_h

#define mozilla_ContentClassifierEngine_h

#include "content_classifier_ffi.h"

#include "nsError.h"

#include "nsString.h"

#include "nsTArray.h"

#include "nsIChannel.h"

namespace mozilla {

class ContentClassifierService;

class ContentClassifierResult {

  bool mMatched = false;

  bool mException = false;

  bool mImportant = false;

  nsresult mEngineResult = NS_ERROR_UNEXPECTED;

 public:

  ContentClassifierResult(bool aMatched, bool aException, bool aImportant,

                          nsresult aEngineResult)

      : mMatched(aMatched),

        mException(aException),

        mImportant(aImportant),

        mEngineResult(aEngineResult) {}

  explicit ContentClassifierResult(nsresult aEngineResult)

      : mMatched(false),

        mException(false),

        mImportant(false),

        mEngineResult(aEngineResult) {}

  nsresult EngineResult() { return mEngineResult; }

  bool Hit() { return NS_SUCCEEDED(mEngineResult) && mMatched && !mException; }

  bool Exception() { return NS_SUCCEEDED(mEngineResult) && mException; }

  bool Important() { return NS_SUCCEEDED(mEngineResult) && mImportant; }

  // Used to combine results from multiple engines. Respects important as a lock

  // on the result.

  void Accumulate(const ContentClassifierResult& aOther);

};

class ContentClassifierRequest {

  friend class ContentClassifierEngine;

  nsCString mUrl;

  nsCString mSchemelessSite;

  nsCString mSourceSchemelessSite;

  nsCString mRequestType;

  bool mThirdParty = false;

  bool mValid = false;

 public:

  bool Valid() const { return mValid; }

  const nsCString& Url() const { return mUrl; }

  explicit ContentClassifierRequest(nsIChannel* aChannel);

};

class ContentClassifierEngine final {

 public:

  ContentClassifierEngine() : mEngine(nullptr) {

    if (!sInitializedETLDService) {

      nsresult rv = content_classifier_initialize_domain_resolver();

      if (NS_SUCCEEDED(rv)) {

        sInitializedETLDService = true;

  ~ContentClassifierEngine() {

    if (mEngine) {

      content_classifier_engine_destroy(mEngine);

      mEngine = nullptr;

  nsresult InitFromRules(const nsTArray<nsCString>& aRules) {

    return content_classifier_engine_from_rules(&aRules, &mEngine);

  ContentClassifierResult CheckNetworkRequest(

      const ContentClassifierRequest& aRequest);

 private:

  static inline bool sInitializedETLDService = false;

  ContentClassifierFFIEngine* mEngine;

  ContentClassifierEngine(const ContentClassifierEngine&) = delete;

  ContentClassifierEngine& operator=(const ContentClassifierEngine&) = delete;

};

}  // namespace mozilla

#endif  // mozilla_ContentClassifierEngine_h