tor-browser

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

WebBrowserPersistRemoteDocument.cpp (6161B)

      1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
      2 *
      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 #include "WebBrowserPersistRemoteDocument.h"
      8 
      9 #include "WebBrowserPersistDocumentParent.h"
     10 #include "WebBrowserPersistResourcesParent.h"
     11 #include "WebBrowserPersistSerializeParent.h"
     12 #include "mozilla/ipc/BackgroundUtils.h"
     13 #include "mozilla/net/CookieJarSettings.h"
     14 #include "nsDebug.h"
     15 #include "nsIPrincipal.h"
     16 #include "nsISHEntry.h"
     17 
     18 namespace mozilla {
     19 
     20 NS_IMPL_ISUPPORTS(WebBrowserPersistRemoteDocument, nsIWebBrowserPersistDocument)
     21 
     22 WebBrowserPersistRemoteDocument ::WebBrowserPersistRemoteDocument(
     23    WebBrowserPersistDocumentParent* aActor, const Attrs& aAttrs,
     24    nsIInputStream* aPostData)
     25    : mActor(aActor), mAttrs(aAttrs), mPostData(aPostData) {
     26  auto principalOrErr = ipc::PrincipalInfoToPrincipal(mAttrs.principal());
     27  if (principalOrErr.isOk()) {
     28    mPrincipal = principalOrErr.unwrap();
     29  } else {
     30    NS_WARNING("Failed to obtain principal!");
     31  }
     32 
     33  net::CookieJarSettings::Deserialize(mAttrs.cookieJarSettings(),
     34                                      getter_AddRefs(mCookieJarSettings));
     35 }
     36 
     37 WebBrowserPersistRemoteDocument::~WebBrowserPersistRemoteDocument() {
     38  if (mActor) {
     39    (void)WebBrowserPersistDocumentParent::Send__delete__(mActor);
     40    // That will call mActor->ActorDestroy, which calls this->ActorDestroy
     41    // (whether or not the IPC send succeeds).
     42  }
     43  MOZ_ASSERT(!mActor);
     44 }
     45 
     46 void WebBrowserPersistRemoteDocument::ActorDestroy(void) { mActor = nullptr; }
     47 
     48 NS_IMETHODIMP
     49 WebBrowserPersistRemoteDocument::GetIsClosed(bool* aIsClosed) {
     50  *aIsClosed = !mActor;
     51  return NS_OK;
     52 }
     53 
     54 NS_IMETHODIMP
     55 WebBrowserPersistRemoteDocument::GetIsPrivate(bool* aIsPrivate) {
     56  *aIsPrivate = mAttrs.isPrivate();
     57  return NS_OK;
     58 }
     59 
     60 NS_IMETHODIMP
     61 WebBrowserPersistRemoteDocument::GetDocumentURI(nsACString& aURISpec) {
     62  aURISpec = mAttrs.documentURI();
     63  return NS_OK;
     64 }
     65 
     66 NS_IMETHODIMP
     67 WebBrowserPersistRemoteDocument::GetBaseURI(nsACString& aURISpec) {
     68  aURISpec = mAttrs.baseURI();
     69  return NS_OK;
     70 }
     71 
     72 NS_IMETHODIMP
     73 WebBrowserPersistRemoteDocument::GetContentType(nsACString& aContentType) {
     74  aContentType = mAttrs.contentType();
     75  return NS_OK;
     76 }
     77 
     78 NS_IMETHODIMP
     79 WebBrowserPersistRemoteDocument::GetCharacterSet(nsACString& aCharSet) {
     80  aCharSet = mAttrs.characterSet();
     81  return NS_OK;
     82 }
     83 
     84 NS_IMETHODIMP
     85 WebBrowserPersistRemoteDocument::GetTitle(nsAString& aTitle) {
     86  aTitle = mAttrs.title();
     87  return NS_OK;
     88 }
     89 
     90 NS_IMETHODIMP
     91 WebBrowserPersistRemoteDocument::GetReferrerInfo(
     92    nsIReferrerInfo** aReferrerInfo) {
     93  *aReferrerInfo = mAttrs.referrerInfo();
     94  NS_IF_ADDREF(*aReferrerInfo);
     95  return NS_OK;
     96 }
     97 
     98 NS_IMETHODIMP
     99 WebBrowserPersistRemoteDocument::GetCookieJarSettings(
    100    nsICookieJarSettings** aCookieJarSettings) {
    101  nsCOMPtr<nsICookieJarSettings> cookieJarSettings = mCookieJarSettings;
    102  cookieJarSettings.forget(aCookieJarSettings);
    103  return NS_OK;
    104 }
    105 
    106 NS_IMETHODIMP
    107 WebBrowserPersistRemoteDocument::GetContentDisposition(nsAString& aDisp) {
    108  aDisp = mAttrs.contentDisposition();
    109  return NS_OK;
    110 }
    111 
    112 NS_IMETHODIMP
    113 WebBrowserPersistRemoteDocument::GetCacheKey(uint32_t* aCacheKey) {
    114  *aCacheKey = mAttrs.sessionHistoryCacheKey();
    115  return NS_OK;
    116 }
    117 
    118 NS_IMETHODIMP
    119 WebBrowserPersistRemoteDocument::GetPersistFlags(uint32_t* aFlags) {
    120  *aFlags = mAttrs.persistFlags();
    121  return NS_OK;
    122 }
    123 
    124 NS_IMETHODIMP
    125 WebBrowserPersistRemoteDocument::SetPersistFlags(uint32_t aFlags) {
    126  if (!mActor) {
    127    return NS_ERROR_FAILURE;
    128  }
    129  if (!mActor->SendSetPersistFlags(aFlags)) {
    130    return NS_ERROR_FAILURE;
    131  }
    132  mAttrs.persistFlags() = aFlags;
    133  return NS_OK;
    134 }
    135 
    136 NS_IMETHODIMP
    137 WebBrowserPersistRemoteDocument::GetPostData(nsIInputStream** aStream) {
    138  nsCOMPtr<nsIInputStream> stream = mPostData;
    139  stream.forget(aStream);
    140  return NS_OK;
    141 }
    142 
    143 NS_IMETHODIMP
    144 WebBrowserPersistRemoteDocument::GetPrincipal(nsIPrincipal** aPrincipal) {
    145  nsCOMPtr<nsIPrincipal> nodePrincipal = mPrincipal;
    146  nodePrincipal.forget(aPrincipal);
    147  return NS_OK;
    148 }
    149 
    150 NS_IMETHODIMP
    151 WebBrowserPersistRemoteDocument::ReadResources(
    152    nsIWebBrowserPersistResourceVisitor* aVisitor) {
    153  if (!mActor) {
    154    return NS_ERROR_FAILURE;
    155  }
    156  RefPtr<WebBrowserPersistResourcesParent> subActor =
    157      new WebBrowserPersistResourcesParent(this, aVisitor);
    158  return mActor->SendPWebBrowserPersistResourcesConstructor(
    159             subActor.forget().take())
    160             ? NS_OK
    161             : NS_ERROR_FAILURE;
    162 }
    163 
    164 NS_IMETHODIMP
    165 WebBrowserPersistRemoteDocument::WriteContent(
    166    nsIOutputStream* aStream, nsIWebBrowserPersistURIMap* aMap,
    167    const nsACString& aRequestedContentType, uint32_t aEncoderFlags,
    168    uint32_t aWrapColumn, nsIWebBrowserPersistWriteCompletion* aCompletion) {
    169  if (!mActor) {
    170    return NS_ERROR_FAILURE;
    171  }
    172 
    173  nsresult rv;
    174  WebBrowserPersistURIMap map;
    175  uint32_t numMappedURIs;
    176  if (aMap) {
    177    rv = aMap->GetTargetBaseURI(map.targetBaseURI());
    178    NS_ENSURE_SUCCESS(rv, rv);
    179    rv = aMap->GetNumMappedURIs(&numMappedURIs);
    180    NS_ENSURE_SUCCESS(rv, rv);
    181    for (uint32_t i = 0; i < numMappedURIs; ++i) {
    182      WebBrowserPersistURIMapEntry& nextEntry =
    183          *(map.mapURIs().AppendElement());
    184      rv = aMap->GetURIMapping(i, nextEntry.mapFrom(), nextEntry.mapTo());
    185      NS_ENSURE_SUCCESS(rv, rv);
    186    }
    187  }
    188 
    189  auto* subActor =
    190      new WebBrowserPersistSerializeParent(this, aStream, aCompletion);
    191  nsCString requestedContentType(aRequestedContentType);  // Sigh.
    192  return mActor->SendPWebBrowserPersistSerializeConstructor(
    193             subActor, map, requestedContentType, aEncoderFlags, aWrapColumn)
    194             ? NS_OK
    195             : NS_ERROR_FAILURE;
    196 }
    197 
    198 // Forcing WebBrowserPersistRemoteDocument to implement GetHistory is the
    199 // easiest way to ensure that we can call GetHistory in
    200 // WebBrowserPersistDocumentChild::Start
    201 already_AddRefed<nsISHEntry> WebBrowserPersistRemoteDocument::GetHistory() {
    202  MOZ_CRASH("We should not call GetHistory on WebBrowserPersistRemoteDocument");
    203  return nullptr;
    204 }
    205 
    206 }  // namespace mozilla