Head

GCC Code Coverage Report

Directory:	../		Exec	Total	Coverage
File:	/home/iojs/build/workspace/node-test-commit-linux-coverage-daily/nodes/benchmark/out/../src/api/hooks.cc	Lines:	74	74	100.0 %
Date:	2019-09-12 22:30:12	Branches:	8	14	57.1 %


#include "env-inl.h"
#include "node_internals.h"
#include "node_process.h"
#include "async_wrap.h"

namespace node {

using v8::Context;
using v8::HandleScope;
using v8::Integer;
using v8::Isolate;
using v8::Local;
using v8::Object;
using v8::String;
using v8::Value;
using v8::NewStringType;

void RunAtExit(Environment* env) {
  env->RunAtExitCallbacks();
}

void AtExit(void (*cb)(void* arg), void* arg) {
  auto env = Environment::GetThreadLocalEnv();
  AtExit(env, cb, arg);
}

void AtExit(Environment* env, void (*cb)(void* arg), void* arg) {
  CHECK_NOT_NULL(env);
  env->AtExit(cb, arg);
}

void EmitBeforeExit(Environment* env) {
  HandleScope handle_scope(env->isolate());
  Context::Scope context_scope(env->context());
  Local<Value> exit_code = env->process_object()
                               ->Get(env->context(), env->exit_code_string())
                               .ToLocalChecked()
                               ->ToInteger(env->context())
                               .ToLocalChecked();
  ProcessEmit(env, "beforeExit", exit_code).ToLocalChecked();
}

int EmitExit(Environment* env) {
  // process.emit('exit')
  HandleScope handle_scope(env->isolate());
  Context::Scope context_scope(env->context());
  Local<Object> process_object = env->process_object();
  process_object
      ->Set(env->context(),
            FIXED_ONE_BYTE_STRING(env->isolate(), "_exiting"),
            True(env->isolate()))
      .Check();

  Local<String> exit_code = env->exit_code_string();
  int code = process_object->Get(env->context(), exit_code)
                 .ToLocalChecked()
                 ->Int32Value(env->context())
                 .ToChecked();
  ProcessEmit(env, "exit", Integer::New(env->isolate(), code));

  // Reload exit code, it may be changed by `emit('exit')`
  return process_object->Get(env->context(), exit_code)
      .ToLocalChecked()
      ->Int32Value(env->context())
      .ToChecked();
}

void AddEnvironmentCleanupHook(Isolate* isolate,
                               void (*fun)(void* arg),
                               void* arg) {
  Environment* env = Environment::GetCurrent(isolate);
  CHECK_NOT_NULL(env);
  env->AddCleanupHook(fun, arg);
}

void RemoveEnvironmentCleanupHook(Isolate* isolate,
                                  void (*fun)(void* arg),
                                  void* arg) {
  Environment* env = Environment::GetCurrent(isolate);
  CHECK_NOT_NULL(env);
  env->RemoveCleanupHook(fun, arg);
}

async_id AsyncHooksGetExecutionAsyncId(Isolate* isolate) {
  Environment* env = Environment::GetCurrent(isolate);
  if (env == nullptr) return -1;
  return env->execution_async_id();
}

async_id AsyncHooksGetTriggerAsyncId(Isolate* isolate) {
  Environment* env = Environment::GetCurrent(isolate);
  if (env == nullptr) return -1;
  return env->trigger_async_id();
}


async_context EmitAsyncInit(Isolate* isolate,
                            Local<Object> resource,
                            const char* name,
                            async_id trigger_async_id) {
  HandleScope handle_scope(isolate);
  Local<String> type =
      String::NewFromUtf8(isolate, name, NewStringType::kInternalized)
          .ToLocalChecked();
  return EmitAsyncInit(isolate, resource, type, trigger_async_id);
}

async_context EmitAsyncInit(Isolate* isolate,
                            Local<Object> resource,
                            Local<String> name,
                            async_id trigger_async_id) {
  DebugSealHandleScope handle_scope(isolate);
  Environment* env = Environment::GetCurrent(isolate);
  CHECK_NOT_NULL(env);

  // Initialize async context struct
  if (trigger_async_id == -1)
    trigger_async_id = env->get_default_trigger_async_id();

  async_context context = {
    env->new_async_id(),  // async_id_
    trigger_async_id  // trigger_async_id_
  };

  // Run init hooks
  AsyncWrap::EmitAsyncInit(env, resource, name, context.async_id,
                           context.trigger_async_id);

  return context;
}

void EmitAsyncDestroy(Isolate* isolate, async_context asyncContext) {
  EmitAsyncDestroy(Environment::GetCurrent(isolate), asyncContext);
}

void EmitAsyncDestroy(Environment* env, async_context asyncContext) {
  AsyncWrap::EmitDestroy(env, asyncContext.async_id);
}

}  // namespace node


Generated by: GCOVR (Version 3.4)

Line	Branch	Exec	Source
1			#include "env-inl.h"
2			#include "node_internals.h"
3			#include "node_process.h"
4			#include "async_wrap.h"
5
6			namespace node {
7
8			using v8::Context;
9			using v8::HandleScope;
10			using v8::Integer;
11			using v8::Isolate;
12			using v8::Local;
13			using v8::Object;
14			using v8::String;
15			using v8::Value;
16			using v8::NewStringType;
17
18		4699	void RunAtExit(Environment* env) {
19		4699	env->RunAtExitCallbacks();
20		4699	}
21
22		7	void AtExit(void (cb)(void arg), void* arg) {
23		7	auto env = Environment::GetThreadLocalEnv();
24		7	AtExit(env, cb, arg);
25		7	}
26
27		7	void AtExit(Environment* env, void (cb)(void arg), void* arg) {
28	✗✓	7	CHECK_NOT_NULL(env);
29		7	env->AtExit(cb, arg);
30		7	}
31
32		4657	void EmitBeforeExit(Environment* env) {
33		4657	HandleScope handle_scope(env->isolate());
34		4657	Context::Scope context_scope(env->context());
35			Local<Value> exit_code = env->process_object()
36		18628	->Get(env->context(), env->exit_code_string())
37		9314	.ToLocalChecked()
38		18628	->ToInteger(env->context())
39		9314	.ToLocalChecked();
40		13969	ProcessEmit(env, "beforeExit", exit_code).ToLocalChecked();
41		4656	}
42
43		4642	int EmitExit(Environment* env) {
44			// process.emit('exit')
45		4642	HandleScope handle_scope(env->isolate());
46		4642	Context::Scope context_scope(env->context());
47		4642	Local<Object> process_object = env->process_object();
48			process_object
49			->Set(env->context(),
50			FIXED_ONE_BYTE_STRING(env->isolate(), "_exiting"),
51		23210	True(env->isolate()))
52		9284	.Check();
53
54		4642	Local<String> exit_code = env->exit_code_string();
55		13926	int code = process_object->Get(env->context(), exit_code)
56		9284	.ToLocalChecked()
57		18568	->Int32Value(env->context())
58		9284	.ToChecked();
59		9284	ProcessEmit(env, "exit", Integer::New(env->isolate(), code));
60
61			// Reload exit code, it may be changed by `emit('exit')`
62		13911	return process_object->Get(env->context(), exit_code)
63		9274	.ToLocalChecked()
64		18548	->Int32Value(env->context())
65		13911	.ToChecked();
66			}
67
68		31	void AddEnvironmentCleanupHook(Isolate* isolate,
69			void (fun)(void arg),
70			void* arg) {
71		31	Environment* env = Environment::GetCurrent(isolate);
72	✗✓	31	CHECK_NOT_NULL(env);
73		31	env->AddCleanupHook(fun, arg);
74		31	}
75
76		24	void RemoveEnvironmentCleanupHook(Isolate* isolate,
77			void (fun)(void arg),
78			void* arg) {
79		24	Environment* env = Environment::GetCurrent(isolate);
80	✗✓	24	CHECK_NOT_NULL(env);
81		24	env->RemoveCleanupHook(fun, arg);
82		24	}
83
84		2	async_id AsyncHooksGetExecutionAsyncId(Isolate* isolate) {
85		2	Environment* env = Environment::GetCurrent(isolate);
86	✗✓	2	if (env == nullptr) return -1;
87		2	return env->execution_async_id();
88			}
89
90		2	async_id AsyncHooksGetTriggerAsyncId(Isolate* isolate) {
91		2	Environment* env = Environment::GetCurrent(isolate);
92	✗✓	2	if (env == nullptr) return -1;
93		2	return env->trigger_async_id();
94			}
95
96
97		539	async_context EmitAsyncInit(Isolate* isolate,
98			Local<Object> resource,
99			const char* name,
100			async_id trigger_async_id) {
101		539	HandleScope handle_scope(isolate);
102			Local<String> type =
103			String::NewFromUtf8(isolate, name, NewStringType::kInternalized)
104		1078	.ToLocalChecked();
105		539	return EmitAsyncInit(isolate, resource, type, trigger_async_id);
106			}
107
108		547	async_context EmitAsyncInit(Isolate* isolate,
109			Local<Object> resource,
110			Local<String> name,
111			async_id trigger_async_id) {
112		547	DebugSealHandleScope handle_scope(isolate);
113		547	Environment* env = Environment::GetCurrent(isolate);
114	✗✓	547	CHECK_NOT_NULL(env);
115
116			// Initialize async context struct
117	✓✓	547	if (trigger_async_id == -1)
118		544	trigger_async_id = env->get_default_trigger_async_id();
119
120			async_context context = {
121		547	env->new_async_id(), // async_id_
122			trigger_async_id // trigger_async_id_
123		547	};
124
125			// Run init hooks
126			AsyncWrap::EmitAsyncInit(env, resource, name, context.async_id,
127		547	context.trigger_async_id);
128
129		547	return context;
130			}
131
132		3	void EmitAsyncDestroy(Isolate* isolate, async_context asyncContext) {
133		3	EmitAsyncDestroy(Environment::GetCurrent(isolate), asyncContext);
134		3	}
135
136		542	void EmitAsyncDestroy(Environment* env, async_context asyncContext) {
137		542	AsyncWrap::EmitDestroy(env, asyncContext.async_id);
138		542	}
139
140			} // namespace node