tor-browser

The Tor Browser
git clone https://git.dasho.dev/tor-browser.git
Log | Files | Refs | README | LICENSE

URLClassifierChild.h (4115B)

      1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
      2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
      3 /* This Source Code Form is subject to the terms of the Mozilla Public
      4 * License, v. 2.0. If a copy of the MPL was not distributed with this
      5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
      6 
      7 #ifndef mozilla_dom_URLClassifierChild_h
      8 #define mozilla_dom_URLClassifierChild_h
      9 
     10 #include "mozilla/dom/PURLClassifierChild.h"
     11 #include "mozilla/dom/PURLClassifierLocalByNameChild.h"
     12 #include "mozilla/dom/PURLClassifierLocalChild.h"
     13 #include "mozilla/ipc/URIUtils.h"
     14 #include "mozilla/net/UrlClassifierFeatureResult.h"
     15 #include "nsIURIClassifier.h"
     16 #include "nsIUrlClassifierFeature.h"
     17 
     18 namespace mozilla::dom {
     19 
     20 class URLClassifierChild : public PURLClassifierChild {
     21 public:
     22  void SetCallback(nsIURIClassifierCallback* aCallback) {
     23    mCallback = aCallback;
     24  }
     25 
     26  mozilla::ipc::IPCResult Recv__delete__(const Maybe<ClassifierInfo>& aInfo,
     27                                         const nsresult& aResult) {
     28    MOZ_ASSERT(mCallback);
     29    if (aInfo.isSome()) {
     30      mCallback->OnClassifyComplete(aResult, aInfo.ref().list(),
     31                                    aInfo.ref().provider(),
     32                                    aInfo.ref().fullhash());
     33    }
     34    return IPC_OK();
     35  }
     36 
     37 private:
     38  nsCOMPtr<nsIURIClassifierCallback> mCallback;
     39 };
     40 
     41 class URLClassifierLocalChild : public PURLClassifierLocalChild {
     42 public:
     43  void SetFeaturesAndCallback(
     44      const nsTArray<RefPtr<nsIUrlClassifierFeature>>& aFeatures,
     45      nsIUrlClassifierFeatureCallback* aCallback) {
     46    mCallback = aCallback;
     47    mFeatures = aFeatures.Clone();
     48  }
     49 
     50  mozilla::ipc::IPCResult Recv__delete__(
     51      nsTArray<URLClassifierLocalResult>&& aResults) {
     52    nsTArray<RefPtr<nsIUrlClassifierFeatureResult>> finalResults;
     53 
     54    nsTArray<URLClassifierLocalResult> results = std::move(aResults);
     55    for (URLClassifierLocalResult& result : results) {
     56      for (nsIUrlClassifierFeature* feature : mFeatures) {
     57        nsAutoCString name;
     58        nsresult rv = feature->GetName(name);
     59        if (NS_WARN_IF(NS_FAILED(rv))) {
     60          continue;
     61        }
     62 
     63        if (result.featureName() != name) {
     64          continue;
     65        }
     66 
     67        RefPtr<nsIURI> uri = result.uri();
     68        if (NS_WARN_IF(!uri)) {
     69          continue;
     70        }
     71 
     72        RefPtr<net::UrlClassifierFeatureResult> r =
     73            new net::UrlClassifierFeatureResult(uri, feature,
     74                                                result.matchingList());
     75        finalResults.AppendElement(r);
     76        break;
     77      }
     78    }
     79 
     80    mCallback->OnClassifyComplete(finalResults);
     81    return IPC_OK();
     82  }
     83 
     84 private:
     85  nsCOMPtr<nsIUrlClassifierFeatureCallback> mCallback;
     86  nsTArray<RefPtr<nsIUrlClassifierFeature>> mFeatures;
     87 };
     88 
     89 class URLClassifierLocalByNameChild : public PURLClassifierLocalByNameChild {
     90 public:
     91  void SetFeaturesAndCallback(const nsTArray<nsCString>& aFeatures,
     92                              nsIUrlClassifierFeatureCallback* aCallback) {
     93    mCallback = aCallback;
     94    mFeatures = aFeatures.Clone();
     95  }
     96 
     97  mozilla::ipc::IPCResult Recv__delete__(
     98      nsTArray<URLClassifierLocalResult>&& aResults) {
     99    nsTArray<RefPtr<nsIUrlClassifierFeatureResult>> finalResults;
    100 
    101    nsTArray<URLClassifierLocalResult> results = std::move(aResults);
    102    for (URLClassifierLocalResult& result : results) {
    103      for (nsCString feature : mFeatures) {
    104        if (result.featureName() != feature) {
    105          continue;
    106        }
    107 
    108        RefPtr<nsIURI> uri = result.uri();
    109        if (NS_WARN_IF(!uri)) {
    110          continue;
    111        }
    112 
    113        RefPtr<net::UrlClassifierFeatureResult> r =
    114            new net::UrlClassifierFeatureResult(uri, nullptr,
    115                                                result.matchingList());
    116        finalResults.AppendElement(r);
    117        break;
    118      }
    119    }
    120 
    121    mCallback->OnClassifyComplete(finalResults);
    122    return IPC_OK();
    123  }
    124 
    125 private:
    126  nsCOMPtr<nsIUrlClassifierFeatureCallback> mCallback;
    127  nsTArray<nsCString> mFeatures;
    128 };
    129 
    130 }  // namespace mozilla::dom
    131 
    132 #endif  // mozilla_dom_URLClassifierChild_h