toolkit/components/sessionstore/SessionStoreParent.cpp
author Lee Salzman <lsalzman@mozilla.com>
Sat, 28 Jan 2023 11:24:54 +0000
changeset 650885 f4f63f0138feb7535fa58c3f77fd8a51361371d8
parent 646471 98688d081f5682d6debd751795030364d02c7be7
permissions -rw-r--r--
Bug 1812970 - Avoid using Skia's deprecated clip ops. r=jrmuizel Skia upstream removed deprecated clip ops that could be used to replace the clipping stack and bypass clips. We shouldn't really need to do this anymore, as we can work around it just using public APIs. The only SkCanvas operation that allows us to bypass clipping is writePixels, which still allows us to implement CopySurface/putImageData. Other instances where we were using the replace op for DrawTargetWebgl layering support can just be worked around by creating a separate DrawTargetSkia pointing to the same pixel data, but on which no clipping or transforms are applied so that we can freely do drawing operations on it to the base layer pixel data regardless of any user-applied clipping. Differential Revision: https://phabricator.services.mozilla.com/D168039

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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/. */

#include "mozilla/dom/SessionStoreParent.h"

#include "mozilla/AlreadyAddRefed.h"
#include "mozilla/Assertions.h"
#include "mozilla/Maybe.h"
#include "mozilla/RefPtr.h"
#include "mozilla/ScopeExit.h"
#include "mozilla/dom/BrowserParent.h"
#include "mozilla/dom/BrowserSessionStore.h"
#include "mozilla/dom/BrowserSessionStoreBinding.h"
#include "mozilla/dom/BrowsingContext.h"
#include "mozilla/dom/InProcessChild.h"
#include "mozilla/dom/InProcessParent.h"
#include "mozilla/dom/SessionStoreChild.h"
#include "mozilla/dom/SessionStoreUtilsBinding.h"
#include "SessionStoreFunctions.h"
#include "nsISupports.h"
#include "nsIXULRuntime.h"
#include "nsImportModule.h"
#include "nsIXPConnect.h"

#ifdef ANDROID
#  include "mozilla/widget/nsWindow.h"
#  include "mozilla/jni/GeckoBundleUtils.h"
#  include "JavaBuiltins.h"
#endif /* ANDROID */

using namespace mozilla;
using namespace mozilla::dom;

SessionStoreParent::SessionStoreParent(
    CanonicalBrowsingContext* aBrowsingContext,
    BrowserSessionStore* aSessionStore)
    : mBrowsingContext(aBrowsingContext), mSessionStore(aSessionStore) {}

#ifdef ANDROID
static void DoSessionStoreUpdate(CanonicalBrowsingContext* aBrowsingContext,
                                 const Maybe<nsCString>& aDocShellCaps,
                                 const Maybe<bool>& aPrivatedMode,
                                 SessionStoreFormData* aFormData,
                                 SessionStoreScrollData* aScroll,
                                 const MaybeSessionStoreZoom& aZoom,
                                 bool aNeedCollectSHistory, uint32_t aEpoch) {
  RefPtr<BrowserSessionStore> sessionStore =
      BrowserSessionStore::GetOrCreate(aBrowsingContext->Top());

  nsCOMPtr<nsIWidget> widget =
      aBrowsingContext->GetParentProcessWidgetContaining();
  if (RefPtr<nsWindow> window = nsWindow::From(widget)) {
    AutoJSAPI jsapi;
    if (!jsapi.Init(xpc::PrivilegedJunkScope())) {
      return;
    }
    jni::Object::LocalRef formDataBundle(jni::GetGeckoThreadEnv());
    jni::Object::LocalRef scrollBundle(jni::GetGeckoThreadEnv());

    if (aFormData) {
      JS::Rooted<JSObject*> object(jsapi.cx());
      ErrorResult rv;
      aFormData->ToJSON(jsapi.cx(), &object);

      JS::Rooted<JS::Value> value(jsapi.cx(), JS::ObjectValue(*object));

      if (NS_FAILED(jni::BoxData(jsapi.cx(), value, formDataBundle, true))) {
        JS_ClearPendingException(jsapi.cx());
        return;
      }
    }

    if (aScroll) {
      JS::Rooted<JSObject*> object(jsapi.cx());
      ErrorResult rv;
      aScroll->ToJSON(jsapi.cx(), &object);
      JS::Rooted<JS::Value> value(jsapi.cx(), JS::ObjectValue(*object));

      if (NS_FAILED(jni::BoxData(jsapi.cx(), value, scrollBundle, true))) {
        JS_ClearPendingException(jsapi.cx());
        return;
      }
    }

    GECKOBUNDLE_START(update);
    GECKOBUNDLE_PUT(update, "formdata", formDataBundle);
    GECKOBUNDLE_PUT(update, "scroll", scrollBundle);
    if (aZoom) {
      GECKOBUNDLE_START(zoomBundle);
      GECKOBUNDLE_PUT(zoomBundle, "resolution",
                      java::sdk::Double::New(Get<0>(*aZoom)));
      GECKOBUNDLE_START(displaySizeBundle);
      GECKOBUNDLE_PUT(displaySizeBundle, "width",
                      java::sdk::Integer::ValueOf(Get<1>(*aZoom)));
      GECKOBUNDLE_PUT(displaySizeBundle, "height",
                      java::sdk::Integer::ValueOf(Get<2>(*aZoom)));
      GECKOBUNDLE_FINISH(displaySizeBundle);
      GECKOBUNDLE_PUT(zoomBundle, "displaySize", displaySizeBundle);
      GECKOBUNDLE_FINISH(zoomBundle);
      GECKOBUNDLE_PUT(update, "zoom", zoomBundle);
    }
    GECKOBUNDLE_FINISH(update);

    window->OnUpdateSessionStore(update);
  }
}
#else
static void DoSessionStoreUpdate(CanonicalBrowsingContext* aBrowsingContext,
                                 const Maybe<nsCString>& aDocShellCaps,
                                 const Maybe<bool>& aPrivatedMode,
                                 SessionStoreFormData* aFormData,
                                 SessionStoreScrollData* aScroll,
                                 const MaybeSessionStoreZoom& aZoom,
                                 bool aNeedCollectSHistory, uint32_t aEpoch) {
  UpdateSessionStoreData data;
  if (aDocShellCaps.isSome()) {
    auto& disallow = data.mDisallow.Construct();
    if (!aDocShellCaps->IsEmpty()) {
      disallow = aDocShellCaps.value();
    } else {
      disallow.SetIsVoid(true);
    }
  }

  if (aPrivatedMode.isSome()) {
    data.mIsPrivate.Construct() = aPrivatedMode.value();
  }

  RefPtr<BrowserSessionStore> sessionStore =
      BrowserSessionStore::GetOrCreate(aBrowsingContext->Top());

  if (!aFormData) {
    SessionStoreFormData* formData = sessionStore->GetFormdata();
    data.mFormdata.Construct(formData);
  } else {
    data.mFormdata.Construct(aFormData);
  }

  if (!aScroll) {
    SessionStoreScrollData* scroll = sessionStore->GetScroll();
    data.mScroll.Construct(scroll);
  } else {
    data.mScroll.Construct(aScroll);
  }

  nsCOMPtr<nsISessionStoreFunctions> funcs = do_ImportESModule(
      "resource://gre/modules/SessionStoreFunctions.sys.mjs", fallible);
  nsCOMPtr<nsIXPConnectWrappedJS> wrapped = do_QueryInterface(funcs);
  if (!wrapped) {
    return;
  }

  AutoJSAPI jsapi;
  if (!jsapi.Init(wrapped->GetJSObjectGlobal())) {
    return;
  }

  JS::Rooted<JS::Value> update(jsapi.cx());
  if (!ToJSValue(jsapi.cx(), data, &update)) {
    return;
  }

  JS::Rooted<JS::Value> key(jsapi.cx(),
                            aBrowsingContext->Top()->PermanentKey());

  Unused << funcs->UpdateSessionStore(nullptr, aBrowsingContext, key, aEpoch,
                                      aNeedCollectSHistory, update);
}
#endif

void SessionStoreParent::FlushAllSessionStoreChildren(
    const std::function<void()>& aDone) {
  if (!mBrowsingContext) {
    aDone();
    return;
  }

  nsTArray<RefPtr<SessionStoreParent::FlushTabStatePromise>> flushPromises;

  // We're special casing this for when the SessionStore{Child, Parent} have
  // been created in the same process. This is only ever true for the parent
  // process session store actor, and is needed because
  // nsFrameLoader::RequestTabStateFlush expect flushes to happen faster than we
  // can manage by using the common path of sending a message the
  // SessionStoreChild. Ideally we should be able to do just that, but not
  // without more work.
  if (InProcessParent::ChildActorFor(this)) {
    // Here we assume that the session store data collection only collect for in
    // (parent-)process content type browsing contexts, which we only flush one
    // session store actor.
    flushPromises.AppendElement(FlushSessionStore());
  } else {
    // While here we flush all participating actors.
    BrowserParent* browserParent = static_cast<BrowserParent*>(Manager());
    browserParent->VisitAll([&flushPromises](BrowserParent* aBrowser) {
      if (PSessionStoreParent* sessionStoreParent =
              SingleManagedOrNull(aBrowser->ManagedPSessionStoreParent())) {
        flushPromises.AppendElement(
            static_cast<SessionStoreParent*>(sessionStoreParent)
                ->FlushSessionStore());
      }
    });
  }

  RefPtr<SessionStoreParent::FlushTabStatePromise::AllPromiseType>
      flushPromise = SessionStoreParent::FlushTabStatePromise::All(
          GetMainThreadSerialEventTarget(), flushPromises);

  mBrowsingContext->UpdateSessionStoreSessionStorage([aDone, flushPromise]() {
    flushPromise->Then(GetCurrentSerialEventTarget(), __func__,
                       [aDone]() { aDone(); });
  });
}

already_AddRefed<SessionStoreParent::FlushTabStatePromise>
SessionStoreParent::FlushSessionStore() {
  if (!mBrowsingContext) {
    return nullptr;
  }

  RefPtr<SessionStoreParent::FlushTabStatePromise> promise =
      SendFlushTabState();
  return promise.forget();
}

void SessionStoreParent::FinalFlushAllSessionStoreChildren(
    const std::function<void()>& aDone) {
  if (!mBrowsingContext) {
    aDone();
    return;
  }

  SessionStoreChild* sessionStoreChild =
      static_cast<SessionStoreChild*>(InProcessParent::ChildActorFor(this));
  if (!sessionStoreChild || mozilla::SessionHistoryInParent()) {
    return FlushAllSessionStoreChildren(aDone);
  }

  sessionStoreChild->FlushSessionStore();
  mBrowsingContext->UpdateSessionStoreSessionStorage(aDone);
}

mozilla::ipc::IPCResult SessionStoreParent::RecvSessionStoreUpdate(
    const Maybe<nsCString>& aDocShellCaps, const Maybe<bool>& aPrivatedMode,
    const MaybeSessionStoreZoom& aZoom, const bool aNeedCollectSHistory,
    const uint32_t& aEpoch) {
  if (!mBrowsingContext) {
    return IPC_OK();
  }

  RefPtr<SessionStoreFormData> formData =
      mHasNewFormData ? mSessionStore->GetFormdata() : nullptr;
  RefPtr<SessionStoreScrollData> scroll =
      mHasNewScrollPosition ? mSessionStore->GetScroll() : nullptr;

  DoSessionStoreUpdate(mBrowsingContext, aDocShellCaps, aPrivatedMode, formData,
                       scroll, aZoom, aNeedCollectSHistory, aEpoch);

  mHasNewFormData = false;
  mHasNewScrollPosition = false;

  return IPC_OK();
}

mozilla::ipc::IPCResult SessionStoreParent::RecvIncrementalSessionStoreUpdate(
    const MaybeDiscarded<BrowsingContext>& aBrowsingContext,
    const Maybe<FormData>& aFormData, const Maybe<nsPoint>& aScrollPosition,
    uint32_t aEpoch) {
  if (!aBrowsingContext.IsNull()) {
    if (aFormData.isSome()) {
      mHasNewFormData = true;
    }
    if (aScrollPosition.isSome()) {
      mHasNewScrollPosition = true;
    }

    mSessionStore->UpdateSessionStore(
        aBrowsingContext.GetMaybeDiscarded()->Canonical(), aFormData,
        aScrollPosition, aEpoch);
  }

  return IPC_OK();
}

mozilla::ipc::IPCResult SessionStoreParent::RecvResetSessionStore(
    const MaybeDiscarded<BrowsingContext>& aBrowsingContext, uint32_t aEpoch) {
  if (!aBrowsingContext.IsNull()) {
    mSessionStore->RemoveSessionStore(
        aBrowsingContext.GetMaybeDiscarded()->Canonical());
  }
  return IPC_OK();
}

void SessionStoreParent::SessionStoreUpdate(
    const Maybe<nsCString>& aDocShellCaps, const Maybe<bool>& aPrivatedMode,
    const MaybeSessionStoreZoom& aZoom, const bool aNeedCollectSHistory,
    const uint32_t& aEpoch) {
  Unused << RecvSessionStoreUpdate(aDocShellCaps, aPrivatedMode, aZoom,
                                   aNeedCollectSHistory, aEpoch);
}

void SessionStoreParent::IncrementalSessionStoreUpdate(
    const MaybeDiscarded<BrowsingContext>& aBrowsingContext,
    const Maybe<FormData>& aFormData, const Maybe<nsPoint>& aScrollPosition,
    uint32_t aEpoch) {
  Unused << RecvIncrementalSessionStoreUpdate(aBrowsingContext, aFormData,
                                              aScrollPosition, aEpoch);
}

void SessionStoreParent::ResetSessionStore(
    const MaybeDiscarded<BrowsingContext>& aBrowsingContext, uint32_t aEpoch) {
  Unused << RecvResetSessionStore(aBrowsingContext, aEpoch);
}

NS_IMPL_CYCLE_COLLECTION(SessionStoreParent, mBrowsingContext, mSessionStore)