• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2021 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef ECMASCRIPT_TOOLING_BASE_PT_RETURNS_H
17 #define ECMASCRIPT_TOOLING_BASE_PT_RETURNS_H
18 
19 #include "base/pt_types.h"
20 
21 namespace panda::ecmascript::tooling {
22 class PtBaseReturns : public PtBaseTypes {
23 public:
24     PtBaseReturns() = default;
25     ~PtBaseReturns() override = default;
ToJson()26     std::unique_ptr<PtJson> ToJson() const override
27     {
28         return PtJson::CreateObject();
29     }
30 
31 private:
32     NO_COPY_SEMANTIC(PtBaseReturns);
33     NO_MOVE_SEMANTIC(PtBaseReturns);
34 };
35 
36 class EnableReturns : public PtBaseReturns {
37 public:
EnableReturns(UniqueDebuggerId id)38     explicit EnableReturns(UniqueDebuggerId id) : debuggerId_(id) {}
39     ~EnableReturns() override = default;
40 
41     std::unique_ptr<PtJson> ToJson() const override;
42 
43 private:
44     EnableReturns() = default;
45     NO_COPY_SEMANTIC(EnableReturns);
46     NO_MOVE_SEMANTIC(EnableReturns);
47 
48     UniqueDebuggerId debuggerId_ {};
49 };
50 
51 class SetBreakpointByUrlReturns : public PtBaseReturns {
52 public:
SetBreakpointByUrlReturns(const std::string & id,std::vector<std::unique_ptr<Location>> locations)53     explicit SetBreakpointByUrlReturns(const std::string &id, std::vector<std::unique_ptr<Location>> locations)
54         : id_(id), locations_(std::move(locations))
55     {}
56     ~SetBreakpointByUrlReturns() override = default;
57 
58     std::unique_ptr<PtJson> ToJson() const override;
59 
60 private:
61     SetBreakpointByUrlReturns() = default;
62     NO_COPY_SEMANTIC(SetBreakpointByUrlReturns);
63     NO_MOVE_SEMANTIC(SetBreakpointByUrlReturns);
64 
65     std::string id_ {};
66     std::vector<std::unique_ptr<Location>> locations_ {};
67 };
68 
69 class EvaluateOnCallFrameReturns : public PtBaseReturns {
70 public:
71     explicit EvaluateOnCallFrameReturns(std::unique_ptr<RemoteObject> result,
72         std::optional<std::unique_ptr<ExceptionDetails>> exceptionDetails = std::nullopt)
result_(std::move (result))73         : result_(std::move(result)), exceptionDetails_(std::move(exceptionDetails))
74     {}
75     ~EvaluateOnCallFrameReturns() override = default;
76     std::unique_ptr<PtJson> ToJson() const override;
77 
78 private:
79     EvaluateOnCallFrameReturns() = default;
80     NO_COPY_SEMANTIC(EvaluateOnCallFrameReturns);
81     NO_MOVE_SEMANTIC(EvaluateOnCallFrameReturns);
82 
83     std::unique_ptr<RemoteObject> result_ {};
84     std::optional<std::unique_ptr<ExceptionDetails>> exceptionDetails_ {};
85 };
86 
87 class GetPossibleBreakpointsReturns : public PtBaseReturns {
88 public:
GetPossibleBreakpointsReturns(std::vector<std::unique_ptr<BreakLocation>> locations)89     explicit GetPossibleBreakpointsReturns(std::vector<std::unique_ptr<BreakLocation>> locations)
90         : locations_(std::move(locations))
91     {}
92     ~GetPossibleBreakpointsReturns() override = default;
93 
94     std::unique_ptr<PtJson> ToJson() const override;
95 
96 private:
97     GetPossibleBreakpointsReturns() = default;
98     NO_COPY_SEMANTIC(GetPossibleBreakpointsReturns);
99     NO_MOVE_SEMANTIC(GetPossibleBreakpointsReturns);
100 
101     std::vector<std::unique_ptr<BreakLocation>> locations_ {};
102 };
103 
104 class GetScriptSourceReturns : public PtBaseReturns {
105 public:
106     explicit GetScriptSourceReturns(const std::string &scriptSource, std::optional<std::string> bytecode = std::nullopt)
scriptSource_(scriptSource)107         : scriptSource_(scriptSource), bytecode_(std::move(bytecode))
108     {}
109     ~GetScriptSourceReturns() override = default;
110 
111     std::unique_ptr<PtJson> ToJson() const override;
112 
113 private:
114     GetScriptSourceReturns() = default;
115     NO_COPY_SEMANTIC(GetScriptSourceReturns);
116     NO_MOVE_SEMANTIC(GetScriptSourceReturns);
117 
118     std::string scriptSource_ {};
119     std::optional<std::string> bytecode_ {};
120 };
121 
122 class RestartFrameReturns : public PtBaseReturns {
123 public:
RestartFrameReturns(std::vector<std::unique_ptr<CallFrame>> callFrames)124     explicit RestartFrameReturns(std::vector<std::unique_ptr<CallFrame>> callFrames)
125         : callFrames_(std::move(callFrames))
126     {}
127     ~RestartFrameReturns() override = default;
128     std::unique_ptr<PtJson> ToJson() const override;
129 
130 private:
131     RestartFrameReturns() = default;
132     NO_COPY_SEMANTIC(RestartFrameReturns);
133     NO_MOVE_SEMANTIC(RestartFrameReturns);
134 
135     std::vector<std::unique_ptr<CallFrame>> callFrames_ {};
136 };
137 
138 class SearchInContentReturns : public PtBaseReturns {
139 public:
SearchInContentReturns(std::vector<std::unique_ptr<SearchMatch>> result)140     explicit SearchInContentReturns(std::vector<std::unique_ptr<SearchMatch>> result) : result_(std::move(result))
141     {}
142     ~SearchInContentReturns() override = default;
143     std::unique_ptr<PtJson> ToJson() const override;
144 
145 private:
146     SearchInContentReturns() = default;
147     NO_COPY_SEMANTIC(SearchInContentReturns);
148     NO_MOVE_SEMANTIC(SearchInContentReturns);
149 
150     std::vector<std::unique_ptr<SearchMatch>> result_ {};
151 };
152 
153 class SetBreakpointReturns : public PtBaseReturns {
154 public:
SetBreakpointReturns(const std::string & id,std::unique_ptr<Location> location)155     explicit SetBreakpointReturns(const std::string &id, std::unique_ptr<Location> location)
156         : breakpointId_(id), location_(std::move(location))
157     {}
158     ~SetBreakpointReturns() override = default;
159     std::unique_ptr<PtJson> ToJson() const override;
160 
161 private:
162     SetBreakpointReturns() = default;
163     NO_COPY_SEMANTIC(SetBreakpointReturns);
164     NO_MOVE_SEMANTIC(SetBreakpointReturns);
165     std::string breakpointId_ {};
166     std::unique_ptr<Location> location_ {};
167 };
168 
169 class SetInstrumentationBreakpointReturns : public PtBaseReturns {
170 public:
SetInstrumentationBreakpointReturns(const std::string & id)171     explicit SetInstrumentationBreakpointReturns(const std::string &id) : breakpointId_(id)
172     {}
173     ~SetInstrumentationBreakpointReturns() override = default;
174     std::unique_ptr<PtJson> ToJson() const override;
175 
176 private:
177     SetInstrumentationBreakpointReturns() = default;
178     NO_COPY_SEMANTIC(SetInstrumentationBreakpointReturns);
179     NO_MOVE_SEMANTIC(SetInstrumentationBreakpointReturns);
180 
181     std::string breakpointId_ {};
182 };
183 
184 class SetScriptSourceReturns : public PtBaseReturns {
185 public:
186     explicit SetScriptSourceReturns(std::optional<std::vector<std::unique_ptr<CallFrame>>> callFrames = std::nullopt,
187         std::optional<bool> stackChanged = std::nullopt,
188         std::optional<std::unique_ptr<ExceptionDetails>> exceptionDetails = std::nullopt)
callFrames_(std::move (callFrames))189         : callFrames_(std::move(callFrames)),
190           stackChanged_(stackChanged),
191           exceptionDetails_(std::move(exceptionDetails))
192     {}
193     ~SetScriptSourceReturns() override = default;
194     std::unique_ptr<PtJson> ToJson() const override;
195 
196 private:
197     SetScriptSourceReturns() = default;
198     NO_COPY_SEMANTIC(SetScriptSourceReturns);
199     NO_MOVE_SEMANTIC(SetScriptSourceReturns);
200 
201     std::optional<std::vector<std::unique_ptr<CallFrame>>> callFrames_ {};
202     std::optional<bool> stackChanged_ {};
203     std::optional<std::unique_ptr<ExceptionDetails>> exceptionDetails_ {};
204 };
205 
206 class GetPropertiesReturns : public PtBaseReturns {
207 public:
208     explicit GetPropertiesReturns(std::vector<std::unique_ptr<PropertyDescriptor>> descriptor,
209         std::optional<std::vector<std::unique_ptr<InternalPropertyDescriptor>>> internalDescripties = std::nullopt,
210         std::optional<std::vector<std::unique_ptr<PrivatePropertyDescriptor>>> privateProperties = std::nullopt,
211         std::optional<std::unique_ptr<ExceptionDetails>> exceptionDetails = std::nullopt)
result_(std::move (descriptor))212         : result_(std::move(descriptor)),
213           internalPropertyDescripties_(std::move(internalDescripties)),
214           privateProperties_(std::move(privateProperties)),
215           exceptionDetails_(std::move(exceptionDetails))
216     {}
217     ~GetPropertiesReturns() override = default;
218     std::unique_ptr<PtJson> ToJson() const override;
219 
220 private:
221     GetPropertiesReturns() = default;
222     NO_COPY_SEMANTIC(GetPropertiesReturns);
223     NO_MOVE_SEMANTIC(GetPropertiesReturns);
224 
225     std::vector<std::unique_ptr<PropertyDescriptor>> result_ {};
226     std::optional<std::vector<std::unique_ptr<InternalPropertyDescriptor>>> internalPropertyDescripties_ {};
227     std::optional<std::vector<std::unique_ptr<PrivatePropertyDescriptor>>> privateProperties_ {};
228     std::optional<std::unique_ptr<ExceptionDetails>> exceptionDetails_ {};
229 };
230 
231 class CallFunctionOnReturns : public PtBaseReturns {
232 public:
233     explicit CallFunctionOnReturns(std::unique_ptr<RemoteObject> result,
234         std::optional<std::unique_ptr<ExceptionDetails>> exceptionDetails = std::nullopt)
result_(std::move (result))235         : result_(std::move(result)),
236           exceptionDetails_(std::move(exceptionDetails))
237     {}
238     ~CallFunctionOnReturns() override = default;
239     std::unique_ptr<PtJson> ToJson() const override;
240 
241 private:
242     CallFunctionOnReturns() = default;
243     NO_COPY_SEMANTIC(CallFunctionOnReturns);
244     NO_MOVE_SEMANTIC(CallFunctionOnReturns);
245 
246     std::unique_ptr<RemoteObject> result_ {};
247     std::optional<std::unique_ptr<ExceptionDetails>> exceptionDetails_ {};
248 };
249 
250 class StopSamplingReturns : public PtBaseReturns {
251 public:
StopSamplingReturns(std::unique_ptr<SamplingHeapProfile> profile)252     explicit StopSamplingReturns(std::unique_ptr<SamplingHeapProfile> profile)
253         : profile_(std::move(profile))
254     {}
255     ~StopSamplingReturns() override = default;
256 
257     std::unique_ptr<PtJson> ToJson() const override;
258 
259 private:
260     StopSamplingReturns() = default;
261     NO_COPY_SEMANTIC(StopSamplingReturns);
262     NO_MOVE_SEMANTIC(StopSamplingReturns);
263 
264     std::unique_ptr<SamplingHeapProfile> profile_ {};
265 };
266 
267 class GetHeapObjectIdReturns : public PtBaseReturns {
268 public:
GetHeapObjectIdReturns(HeapSnapshotObjectId heapSnapshotObjectId)269     explicit GetHeapObjectIdReturns(HeapSnapshotObjectId heapSnapshotObjectId)
270         : heapSnapshotObjectId_(std::move(heapSnapshotObjectId))
271     {}
272     ~GetHeapObjectIdReturns() override = default;
273 
274     std::unique_ptr<PtJson> ToJson() const override;
275 
276 private:
277     GetHeapObjectIdReturns() = default;
278     NO_COPY_SEMANTIC(GetHeapObjectIdReturns);
279     NO_MOVE_SEMANTIC(GetHeapObjectIdReturns);
280 
281     HeapSnapshotObjectId heapSnapshotObjectId_ {};
282 };
283 
284 class GetObjectByHeapObjectIdReturns : public PtBaseReturns {
285 public:
GetObjectByHeapObjectIdReturns(std::unique_ptr<RemoteObject> remoteObjectResult)286     explicit GetObjectByHeapObjectIdReturns(std::unique_ptr<RemoteObject> remoteObjectResult)
287         : remoteObjectResult_(std::move(remoteObjectResult))
288     {}
289     ~GetObjectByHeapObjectIdReturns() override = default;
290 
291     std::unique_ptr<PtJson> ToJson() const override;
292 
293 private:
294     GetObjectByHeapObjectIdReturns() = default;
295     NO_COPY_SEMANTIC(GetObjectByHeapObjectIdReturns);
296     NO_MOVE_SEMANTIC(GetObjectByHeapObjectIdReturns);
297 
298     std::unique_ptr<RemoteObject> remoteObjectResult_ {};
299 };
300 
301 class StopReturns : public PtBaseReturns {
302 public:
StopReturns(std::unique_ptr<Profile> profile)303     explicit StopReturns(std::unique_ptr<Profile> profile) : profile_(std::move(profile)) {}
304     ~StopReturns() override = default;
305     std::unique_ptr<PtJson> ToJson() const override;
306 
307 private:
308     StopReturns() = default;
309     NO_COPY_SEMANTIC(StopReturns);
310     NO_MOVE_SEMANTIC(StopReturns);
311 
312     std::unique_ptr<Profile> profile_ {};
313 };
314 
315 class GetHeapUsageReturns : public PtBaseReturns {
316 public:
GetHeapUsageReturns(double usedSize,double totalSize)317     explicit GetHeapUsageReturns(double usedSize, double totalSize)
318         : usedSize_(usedSize), totalSize_(totalSize) {}
319     ~GetHeapUsageReturns() override = default;
320     std::unique_ptr<PtJson> ToJson() const override;
321 
322 private:
323     GetHeapUsageReturns() = default;
324     NO_COPY_SEMANTIC(GetHeapUsageReturns);
325     NO_MOVE_SEMANTIC(GetHeapUsageReturns);
326 
327     double usedSize_ {0.0};
328     double totalSize_ {0.0};
329 };
330 
331 class GetBestEffortCoverageReturns : public PtBaseReturns {
332 public:
GetBestEffortCoverageReturns(std::vector<std::unique_ptr<ScriptCoverage>> result)333     explicit GetBestEffortCoverageReturns(std::vector<std::unique_ptr<ScriptCoverage>> result)
334         : result_(std::move(result))
335     {}
336     ~GetBestEffortCoverageReturns() override = default;
337     std::unique_ptr<PtJson> ToJson() const override;
338 
339 private:
340     GetBestEffortCoverageReturns() = default;
341     NO_COPY_SEMANTIC(GetBestEffortCoverageReturns);
342     NO_MOVE_SEMANTIC(GetBestEffortCoverageReturns);
343 
344     std::vector<std::unique_ptr<ScriptCoverage>> result_ {};
345 };
346 
347 class StartPreciseCoverageReturns : public PtBaseReturns {
348 public:
StartPreciseCoverageReturns(int64_t tamp)349     explicit StartPreciseCoverageReturns(int64_t tamp) : timestamp_(tamp) {}
350     ~StartPreciseCoverageReturns() override = default;
351     std::unique_ptr<PtJson> ToJson() const override;
352 
353 private:
354     StartPreciseCoverageReturns() = default;
355     NO_COPY_SEMANTIC(StartPreciseCoverageReturns);
356     NO_MOVE_SEMANTIC(StartPreciseCoverageReturns);
357 
358     int64_t timestamp_ {0};
359 };
360 
361 class TakePreciseCoverageReturns : public PtBaseReturns {
362 public:
TakePreciseCoverageReturns(std::vector<std::unique_ptr<ScriptCoverage>> result,int64_t tamp)363     explicit TakePreciseCoverageReturns(std::vector<std::unique_ptr<ScriptCoverage>> result, int64_t tamp)
364         : result_(std::move(result)),
365           timestamp_(tamp)
366     {}
367     ~TakePreciseCoverageReturns() override = default;
368     std::unique_ptr<PtJson> ToJson() const override;
369 
370 private:
371     TakePreciseCoverageReturns() = default;
372     NO_COPY_SEMANTIC(TakePreciseCoverageReturns);
373     NO_MOVE_SEMANTIC(TakePreciseCoverageReturns);
374 
375     std::vector<std::unique_ptr<ScriptCoverage>> result_ {};
376     int64_t timestamp_ {0};
377 };
378 
379 class TakeTypeProfileReturns : public PtBaseReturns {
380 public:
TakeTypeProfileReturns(std::vector<std::unique_ptr<ScriptTypeProfile>> result)381     explicit TakeTypeProfileReturns(std::vector<std::unique_ptr<ScriptTypeProfile>> result)
382         : result_(std::move(result))
383     {}
384     ~TakeTypeProfileReturns() override = default;
385     std::unique_ptr<PtJson> ToJson() const override;
386 
387 private:
388     TakeTypeProfileReturns() = default;
389     NO_COPY_SEMANTIC(TakeTypeProfileReturns);
390     NO_MOVE_SEMANTIC(TakeTypeProfileReturns);
391 
392     std::vector<std::unique_ptr<ScriptTypeProfile>> result_ {};
393 };
394 
395 class GetCategoriesReturns : public PtBaseReturns {
396 public:
GetCategoriesReturns(std::vector<std::string> categories)397     explicit GetCategoriesReturns(std::vector<std::string> categories)
398         : categories_(std::move(categories))
399     {}
400     ~GetCategoriesReturns() override = default;
401     std::unique_ptr<PtJson> ToJson() const override;
402 
403 private:
404     GetCategoriesReturns() = default;
405     NO_COPY_SEMANTIC(GetCategoriesReturns);
406     NO_MOVE_SEMANTIC(GetCategoriesReturns);
407 
408     std::vector<std::string> categories_ {};
409 };
410 
411 class RequestMemoryDumpReturns : public PtBaseReturns {
412 public:
RequestMemoryDumpReturns(std::string dumpGuid,bool success)413     explicit RequestMemoryDumpReturns(std::string dumpGuid, bool success)
414         : dumpGuid_(dumpGuid), success_(success) {}
415     ~RequestMemoryDumpReturns() override = default;
416     std::unique_ptr<PtJson> ToJson() const override;
417 
418 private:
419     RequestMemoryDumpReturns() = default;
420     NO_COPY_SEMANTIC(RequestMemoryDumpReturns);
421     NO_MOVE_SEMANTIC(RequestMemoryDumpReturns);
422 
423     std::string dumpGuid_ {};
424     bool success_ {};
425 };
426 }  // namespace panda::ecmascript::tooling
427 #endif