2014-10-31 12:17:05 -06:00
|
|
|
// Copyright (c) 2014 GitHub, Inc.
|
2014-07-31 01:08:54 -06:00
|
|
|
// Use of this source code is governed by the MIT license that can be
|
|
|
|
// found in the LICENSE file.
|
|
|
|
|
2024-01-10 15:23:35 -07:00
|
|
|
#include <optional>
|
2014-07-31 01:08:54 -06:00
|
|
|
#include <set>
|
2014-10-11 05:11:34 -06:00
|
|
|
#include <string>
|
2019-05-28 15:15:42 -06:00
|
|
|
#include <utility>
|
2014-07-31 01:08:54 -06:00
|
|
|
|
2015-08-04 14:12:57 -06:00
|
|
|
#include "base/files/file_util.h"
|
2020-03-09 10:13:59 -06:00
|
|
|
#include "base/task/thread_pool.h"
|
2019-04-05 12:19:06 -06:00
|
|
|
#include "base/threading/thread_restrictions.h"
|
2021-05-13 19:21:36 -06:00
|
|
|
#include "base/trace_event/trace_config.h"
|
2014-07-31 01:08:54 -06:00
|
|
|
#include "content/public/browser/tracing_controller.h"
|
2019-10-31 01:56:00 -06:00
|
|
|
#include "shell/common/gin_converters/callback_converter.h"
|
|
|
|
#include "shell/common/gin_converters/file_path_converter.h"
|
|
|
|
#include "shell/common/gin_converters/value_converter.h"
|
|
|
|
#include "shell/common/gin_helper/dictionary.h"
|
2019-11-01 00:10:32 -06:00
|
|
|
#include "shell/common/gin_helper/promise.h"
|
2019-06-19 14:46:59 -06:00
|
|
|
#include "shell/common/node_includes.h"
|
2014-07-31 01:08:54 -06:00
|
|
|
|
|
|
|
using content::TracingController;
|
|
|
|
|
2019-10-31 01:56:00 -06:00
|
|
|
namespace gin {
|
2014-07-31 01:08:54 -06:00
|
|
|
|
2018-04-17 19:55:30 -06:00
|
|
|
template <>
|
2015-09-02 01:16:49 -06:00
|
|
|
struct Converter<base::trace_event::TraceConfig> {
|
2014-07-31 01:08:54 -06:00
|
|
|
static bool FromV8(v8::Isolate* isolate,
|
2015-05-22 05:11:22 -06:00
|
|
|
v8::Local<v8::Value> val,
|
2015-09-02 01:16:49 -06:00
|
|
|
base::trace_event::TraceConfig* out) {
|
2018-12-20 05:11:17 -07:00
|
|
|
// (alexeykuzmin): A combination of "categoryFilter" and "traceOptions"
|
|
|
|
// has to be checked first because none of the fields
|
|
|
|
// in the `memory_dump_config` dict below are mandatory
|
|
|
|
// and we cannot check the config format.
|
2019-10-31 01:56:00 -06:00
|
|
|
gin_helper::Dictionary options;
|
2018-12-20 05:11:17 -07:00
|
|
|
if (ConvertFromV8(isolate, val, &options)) {
|
|
|
|
std::string category_filter, trace_options;
|
|
|
|
if (options.Get("categoryFilter", &category_filter) &&
|
|
|
|
options.Get("traceOptions", &trace_options)) {
|
|
|
|
*out = base::trace_event::TraceConfig(category_filter, trace_options);
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-07-05 09:25:18 -06:00
|
|
|
base::Value::Dict memory_dump_config;
|
2018-12-20 05:11:17 -07:00
|
|
|
if (ConvertFromV8(isolate, val, &memory_dump_config)) {
|
2023-03-10 09:07:42 -07:00
|
|
|
*out = base::trace_event::TraceConfig(std::move(memory_dump_config));
|
2018-12-20 05:11:17 -07:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
2014-10-11 05:11:34 -06:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2019-10-31 01:56:00 -06:00
|
|
|
} // namespace gin
|
2014-07-31 01:08:54 -06:00
|
|
|
|
|
|
|
namespace {
|
|
|
|
|
2019-05-28 15:15:42 -06:00
|
|
|
using CompletionCallback = base::OnceCallback<void(const base::FilePath&)>;
|
2015-08-04 14:12:57 -06:00
|
|
|
|
2024-01-10 15:23:35 -07:00
|
|
|
std::optional<base::FilePath> CreateTemporaryFileOnIO() {
|
2019-05-28 15:15:42 -06:00
|
|
|
base::FilePath temp_file_path;
|
|
|
|
if (!base::CreateTemporaryFile(&temp_file_path))
|
2024-01-10 15:23:35 -07:00
|
|
|
return std::nullopt;
|
|
|
|
return std::make_optional(std::move(temp_file_path));
|
2019-05-28 15:15:42 -06:00
|
|
|
}
|
2015-08-04 14:12:57 -06:00
|
|
|
|
2019-11-01 00:10:32 -06:00
|
|
|
void StopTracing(gin_helper::Promise<base::FilePath> promise,
|
2024-01-10 15:23:35 -07:00
|
|
|
std::optional<base::FilePath> file_path) {
|
2021-06-21 19:04:31 -06:00
|
|
|
auto resolve_or_reject = base::BindOnce(
|
2020-11-23 11:20:40 -07:00
|
|
|
[](gin_helper::Promise<base::FilePath> promise,
|
2024-01-10 15:23:35 -07:00
|
|
|
const base::FilePath& path, std::optional<std::string> error) {
|
2020-11-23 11:20:40 -07:00
|
|
|
if (error) {
|
|
|
|
promise.RejectWithErrorMessage(error.value());
|
|
|
|
} else {
|
|
|
|
promise.Resolve(path);
|
|
|
|
}
|
|
|
|
},
|
2021-06-21 19:04:31 -06:00
|
|
|
std::move(promise), *file_path);
|
2023-05-31 07:54:41 -06:00
|
|
|
|
|
|
|
auto* instance = TracingController::GetInstance();
|
|
|
|
if (!instance->IsTracing()) {
|
|
|
|
std::move(resolve_or_reject)
|
2024-01-10 15:23:35 -07:00
|
|
|
.Run(std::make_optional(
|
2023-05-31 07:54:41 -06:00
|
|
|
"Failed to stop tracing - no trace in progress"));
|
|
|
|
} else if (file_path) {
|
2021-06-21 19:04:31 -06:00
|
|
|
auto split_callback = base::SplitOnceCallback(std::move(resolve_or_reject));
|
2019-05-28 15:15:42 -06:00
|
|
|
auto endpoint = TracingController::CreateFileEndpoint(
|
2021-06-21 19:04:31 -06:00
|
|
|
*file_path,
|
2024-01-10 15:23:35 -07:00
|
|
|
base::BindOnce(std::move(split_callback.first), std::nullopt));
|
2023-05-31 07:54:41 -06:00
|
|
|
if (!instance->StopTracing(endpoint)) {
|
2021-06-21 19:04:31 -06:00
|
|
|
std::move(split_callback.second)
|
2024-01-10 15:23:35 -07:00
|
|
|
.Run(std::make_optional("Failed to stop tracing"));
|
2020-11-23 11:20:40 -07:00
|
|
|
}
|
2019-05-28 15:15:42 -06:00
|
|
|
} else {
|
2021-06-21 19:04:31 -06:00
|
|
|
std::move(resolve_or_reject)
|
2024-01-10 15:23:35 -07:00
|
|
|
.Run(std::make_optional(
|
2021-06-21 19:04:31 -06:00
|
|
|
"Failed to create temporary file for trace data"));
|
2019-05-28 15:15:42 -06:00
|
|
|
}
|
2015-08-04 14:12:57 -06:00
|
|
|
}
|
|
|
|
|
2019-10-31 01:56:00 -06:00
|
|
|
v8::Local<v8::Promise> StopRecording(gin_helper::Arguments* args) {
|
2019-11-01 00:10:32 -06:00
|
|
|
gin_helper::Promise<base::FilePath> promise(args->isolate());
|
2019-02-21 05:32:44 -07:00
|
|
|
v8::Local<v8::Promise> handle = promise.GetHandle();
|
|
|
|
|
2019-05-28 15:15:42 -06:00
|
|
|
base::FilePath path;
|
|
|
|
if (args->GetNext(&path) && !path.empty()) {
|
2024-01-10 15:23:35 -07:00
|
|
|
StopTracing(std::move(promise), std::make_optional(path));
|
2019-05-28 15:15:42 -06:00
|
|
|
} else {
|
|
|
|
// use a temporary file.
|
2020-03-09 10:13:59 -06:00
|
|
|
base::ThreadPool::PostTaskAndReplyWithResult(
|
|
|
|
FROM_HERE, {base::MayBlock(), base::TaskPriority::USER_VISIBLE},
|
2019-05-28 15:15:42 -06:00
|
|
|
base::BindOnce(CreateTemporaryFileOnIO),
|
|
|
|
base::BindOnce(StopTracing, std::move(promise)));
|
|
|
|
}
|
|
|
|
|
2019-02-21 05:32:44 -07:00
|
|
|
return handle;
|
2015-08-04 14:12:57 -06:00
|
|
|
}
|
|
|
|
|
2019-01-30 13:39:55 -07:00
|
|
|
v8::Local<v8::Promise> GetCategories(v8::Isolate* isolate) {
|
2019-11-01 00:10:32 -06:00
|
|
|
gin_helper::Promise<const std::set<std::string>&> promise(isolate);
|
2019-02-21 05:32:44 -07:00
|
|
|
v8::Local<v8::Promise> handle = promise.GetHandle();
|
2019-01-30 13:39:55 -07:00
|
|
|
|
2019-02-21 05:32:44 -07:00
|
|
|
// Note: This method always succeeds.
|
2019-03-13 15:30:21 -06:00
|
|
|
TracingController::GetInstance()->GetCategories(base::BindOnce(
|
2019-11-01 00:10:32 -06:00
|
|
|
gin_helper::Promise<const std::set<std::string>&>::ResolvePromise,
|
2019-03-13 15:30:21 -06:00
|
|
|
std::move(promise)));
|
2019-01-11 18:00:43 -07:00
|
|
|
|
2019-03-13 15:30:21 -06:00
|
|
|
return handle;
|
2019-01-30 19:53:55 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
v8::Local<v8::Promise> StartTracing(
|
|
|
|
v8::Isolate* isolate,
|
|
|
|
const base::trace_event::TraceConfig& trace_config) {
|
2019-11-01 00:10:32 -06:00
|
|
|
gin_helper::Promise<void> promise(isolate);
|
2019-02-21 05:32:44 -07:00
|
|
|
v8::Local<v8::Promise> handle = promise.GetHandle();
|
2019-01-30 19:53:55 -07:00
|
|
|
|
2019-05-28 15:15:42 -06:00
|
|
|
if (!TracingController::GetInstance()->StartTracing(
|
2019-06-19 15:23:04 -06:00
|
|
|
trace_config,
|
2019-11-01 00:10:32 -06:00
|
|
|
base::BindOnce(gin_helper::Promise<void>::ResolvePromise,
|
2019-06-19 15:23:04 -06:00
|
|
|
std::move(promise)))) {
|
2019-05-28 15:15:42 -06:00
|
|
|
// If StartTracing returns false, that means it didn't invoke its callback.
|
|
|
|
// Return an already-resolved promise and abandon the previous promise (it
|
|
|
|
// was std::move()d into the StartTracing callback and has been deleted by
|
|
|
|
// this point).
|
2019-11-01 00:10:32 -06:00
|
|
|
return gin_helper::Promise<void>::ResolvedPromise(isolate);
|
2019-05-28 15:15:42 -06:00
|
|
|
}
|
2019-02-21 05:32:44 -07:00
|
|
|
return handle;
|
2019-01-11 18:00:43 -07:00
|
|
|
}
|
|
|
|
|
2019-08-22 18:03:28 -06:00
|
|
|
void OnTraceBufferUsageAvailable(
|
2019-11-01 00:10:32 -06:00
|
|
|
gin_helper::Promise<gin_helper::Dictionary> promise,
|
2019-08-22 18:03:28 -06:00
|
|
|
float percent_full,
|
|
|
|
size_t approximate_count) {
|
2023-10-10 04:45:44 -06:00
|
|
|
auto dict = gin_helper::Dictionary::CreateEmpty(promise.isolate());
|
2019-02-13 14:24:57 -07:00
|
|
|
dict.Set("percentage", percent_full);
|
|
|
|
dict.Set("value", approximate_count);
|
|
|
|
|
2019-11-01 00:10:32 -06:00
|
|
|
promise.Resolve(dict);
|
2019-02-13 14:24:57 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
v8::Local<v8::Promise> GetTraceBufferUsage(v8::Isolate* isolate) {
|
2019-11-01 00:10:32 -06:00
|
|
|
gin_helper::Promise<gin_helper::Dictionary> promise(isolate);
|
2019-02-21 05:32:44 -07:00
|
|
|
v8::Local<v8::Promise> handle = promise.GetHandle();
|
2019-02-13 14:24:57 -07:00
|
|
|
|
2019-02-21 05:32:44 -07:00
|
|
|
// Note: This method always succeeds.
|
|
|
|
TracingController::GetInstance()->GetTraceBufferUsage(
|
|
|
|
base::BindOnce(&OnTraceBufferUsageAvailable, std::move(promise)));
|
|
|
|
return handle;
|
2019-01-11 18:00:43 -07:00
|
|
|
}
|
|
|
|
|
2018-04-17 19:55:30 -06:00
|
|
|
void Initialize(v8::Local<v8::Object> exports,
|
|
|
|
v8::Local<v8::Value> unused,
|
|
|
|
v8::Local<v8::Context> context,
|
|
|
|
void* priv) {
|
2019-10-31 01:56:00 -06:00
|
|
|
gin_helper::Dictionary dict(context->GetIsolate(), exports);
|
2019-01-11 18:00:43 -07:00
|
|
|
dict.SetMethod("getCategories", &GetCategories);
|
|
|
|
dict.SetMethod("startRecording", &StartTracing);
|
2015-08-04 14:12:57 -06:00
|
|
|
dict.SetMethod("stopRecording", &StopRecording);
|
2019-01-11 18:00:43 -07:00
|
|
|
dict.SetMethod("getTraceBufferUsage", &GetTraceBufferUsage);
|
2014-07-31 01:08:54 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
} // namespace
|
|
|
|
|
2023-02-08 18:31:38 -07:00
|
|
|
NODE_LINKED_BINDING_CONTEXT_AWARE(electron_browser_content_tracing, Initialize)
|