tor-browser

ProfilingSources.h (5936B)

---

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