ProfilingSources.h

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 js_ProfilingSources_h

#define js_ProfilingSources_h

#include "mozilla/Variant.h"

#include <stdint.h>

#include "jstypes.h"

#include "js/TypeDecls.h"

#include "js/Utility.h"

#include "js/Vector.h"

/*

 * Struct to pass JS source data with content type information for profiler use.

*/

struct JS_PUBLIC_API ProfilerJSSourceData {

 public:

  struct SourceTextUTF16 {

   public:

    SourceTextUTF16(JS::UniqueTwoByteChars&& c, size_t l)

        : chars_(std::move(c)), length_(l) {}

    const JS::UniqueTwoByteChars& chars() const { return chars_; }

    size_t length() const { return length_; }

   private:

    // Not null-terminated string for source text. Always use it with the

    // length.

    JS::UniqueTwoByteChars chars_;

    size_t length_;

};

  struct SourceTextUTF8 {

   public:

    SourceTextUTF8(JS::UniqueChars&& c, size_t l)

        : chars_(std::move(c)), length_(l) {}

    const JS::UniqueChars& chars() const { return chars_; }

    size_t length() const { return length_; }

   private:

    // Not null-terminated string for source text. Always use it with the

    // length.

    JS::UniqueChars chars_;

    size_t length_;

};

/*

   * Represents a source file that can be retrieved later in the parent process.

   * Used when source text is not immediately available in the current process

   * but can be fetched using the file path information.

*/

  struct RetrievableFile {};

  struct Unavailable {};

  using ProfilerSourceVariant =

      mozilla::Variant<SourceTextUTF16, SourceTextUTF8, RetrievableFile,

                       Unavailable>;

  // Constructors

  ProfilerJSSourceData(uint32_t sourceId, JS::UniqueChars&& filePath,

                       size_t pathLen)

      : sourceId_(sourceId),

        filePath_(std::move(filePath)),

        filePathLength_(pathLen),

        data_(Unavailable{}) {}

  // UTF-8 source text with filePath

  ProfilerJSSourceData(uint32_t sourceId, JS::UniqueChars&& chars,

                       size_t length, JS::UniqueChars&& filePath,

                       size_t pathLen)

      : sourceId_(sourceId),

        filePath_(std::move(filePath)),

        filePathLength_(pathLen),

        data_(SourceTextUTF8{std::move(chars), length}) {}

  // UTF-16 source text with filePath

  ProfilerJSSourceData(uint32_t sourceId, JS::UniqueTwoByteChars&& chars,

                       size_t length, JS::UniqueChars&& filePath,

                       size_t pathLen)

      : sourceId_(sourceId),

        filePath_(std::move(filePath)),

        filePathLength_(pathLen),

        data_(SourceTextUTF16{std::move(chars), length}) {}

  // For the cases where no sourceId and filepath are needed.

  ProfilerJSSourceData(JS::UniqueChars&& chars, size_t length)

      : sourceId_(0),

        filePath_(nullptr),

        filePathLength_(0),

        data_(SourceTextUTF8{std::move(chars), length}) {}

  ProfilerJSSourceData()

      : sourceId_(0), filePathLength_(0), data_(Unavailable{}) {}

  static ProfilerJSSourceData CreateRetrievableFile(uint32_t sourceId,

                                                    JS::UniqueChars&& filePath,

                                                    size_t pathLength) {

    ProfilerJSSourceData result(sourceId, std::move(filePath), pathLength);

    result.data_.emplace<RetrievableFile>();

    return result;

  ProfilerJSSourceData(ProfilerJSSourceData&&) = default;

  ProfilerJSSourceData& operator=(ProfilerJSSourceData&&) = default;

  // No copy constructors as this class owns its string storage.

  ProfilerJSSourceData(const ProfilerJSSourceData& other) = delete;

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

  uint32_t sourceId() const { return sourceId_; }

  // Consumer should always check for filePathLength before calling this.

  const char* filePath() const {

    MOZ_ASSERT(filePath_);

    return filePath_.get();

  size_t filePathLength() const { return filePathLength_; }

  const ProfilerSourceVariant& data() const { return data_; }

  // Used only for memory reporting.

  size_t SizeOf() const {

    // Size of sourceId + filepath

    size_t size = sizeof(uint32_t) + filePathLength_ * sizeof(char);

    data_.match(

        [&](const SourceTextUTF16& srcText) {

          size += srcText.length() * sizeof(char16_t);

},

        [&](const SourceTextUTF8& srcText) {

          size += srcText.length() * sizeof(char);

},

        [](const RetrievableFile&) {}, [](const Unavailable&) {});

    return size;

 private:

  // Unique identifier for this source across the process. This can be used

  // to refer to this source from places that don't want to hold a strong

  // reference on the source itself.

  //  Generated by ScriptSource and retrieved via ScriptSource::id(). See

  //  ScriptSource::id_ for more details.

  uint32_t sourceId_;

  // Null-terminated file path for the source.

  // It can be nullptr if:

  // - The source has no filename.

  // - filename allocation fails during copy.

  JS::UniqueChars filePath_;

  size_t filePathLength_;

  ProfilerSourceVariant data_;

};

namespace js {

using ProfilerJSSources =

    js::Vector<ProfilerJSSourceData, 0, js::SystemAllocPolicy>;

/*

 * Main API for getting the profiled JS sources.

*/

JS_PUBLIC_API ProfilerJSSources GetProfilerScriptSources(JSRuntime* rt);

/**

 * Retrieve the JS sources that are only retrievable from the parent process.

 * See RetrievableFile struct for more information.

 * */

JS_PUBLIC_API ProfilerJSSourceData

RetrieveProfilerSourceContent(JSContext* cx, const char* filename);

}  // namespace js

#endif /* js_ProfilingSources_h */