JSIPCValueUtils.h - mozsearch

Enable keyboard shortcuts

/* -*- 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/. */

#ifndef MOZILLA_DOM_IPC_JSACTOR_JSIPCVALUEUTILS_H_

#define MOZILLA_DOM_IPC_JSACTOR_JSIPCVALUEUTILS_H_

#include "js/RootingAPI.h"

#include "js/Value.h"

#include "jstypes.h"

#include "mozilla/Maybe.h"

#include "mozilla/dom/JSActor.h"

#include "mozilla/dom/JSIPCValue.h"

// This file contains a number of useful methods for JSIPCValue, mostly dealing

// with turning it to and from a JS value.

namespace mozilla::dom {

// Return true if a message for an actor with the given name should be

// sent typed.

bool JSActorSupportsTypedSend(const nsACString& aName);

class JSIPCValueUtils {

 public:

  struct Context {

    explicit Context(JSContext* aCx, bool aStrict = true)

        : mCx(aCx), mStrict(aStrict) {}

    MOZ_IMPLICIT operator JSContext*() const { return mCx; }

    JSContext* mCx;

    // If we encounter a JS value that can't be directly serialized to

    // JSIPCValue, we fall back to using structured cloning. mStrict

    // determines the behavior if this structured cloning fails. If mStrict is

    // true, then the entire serialization will fail. If it is false, we'll

    // instead serialize to a fallback value. See UntypedFromJSVal for details.

    bool mStrict;

};

  // Convert a JS value to an IPDL representation of that value, or return

  // Nothing if the value isn't supported. If aSendTyped is false, the result

  // will always just be a wrapper around a StructuredCloneData.

  static JSIPCValue FromJSVal(Context& aCx, JS::Handle<JS::Value> aVal,

                              bool aSendTyped, ErrorResult& aError);

  // Same as the above, except with support for a transfers object, if needed.

  static JSIPCValue FromJSVal(Context& aCx, JS::Handle<JS::Value> aVal,

                              JS::Handle<JS::Value> aTransferable,

                              bool aSendTyped, ErrorResult& aError);

  // This is equivalent to calling FromJSVal with aSendTyped equal to true.

  static JSIPCValue TypedFromJSVal(Context& aCx, JS::Handle<JS::Value> aVal,

                                   ErrorResult& aError);

  // Wrapper class to abstract away the details of the auxiliary data structure

  // needed for PrepareForSending.

  class SCDHolder final {

   public:

    SCDHolder() = default;

    ~SCDHolder() = default;

    friend class JSIPCValueUtils;

   private:

    nsTArray<UniquePtr<ipc::StructuredCloneData>> mSCDs;

};

  // Prepare a JSIPCValue for IPC by turning any StructuredCloneData it

  // contains into ClonedMessageData. Auxiliary data needed for IPC

  // serialization will be added to aHolder, so it needs to be kept alive

  // until aValue is sent over IPC.

  [[nodiscard]] static bool PrepareForSending(SCDHolder& aHolder,

                                              JSIPCValue& aValue);

  // Convert the IPDL representation of a JS value back into the equivalent

  // JS value. This will return false on failure.

  static void ToJSVal(JSContext* aCx, JSIPCValue&& aIn,

                      JS::MutableHandle<JS::Value> aOut, ErrorResult& aError);

};

}  // namespace mozilla::dom

#endif  // MOZILLA_DOM_IPC_JSACTOR_JSIPCVALUEUTILS_H_