Line data    Source code

       1             : // Copyright 2016 The Chromium Authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef v8_inspector_protocol_Forward_h
       6             : #define v8_inspector_protocol_Forward_h
       7             : 
       8             : #include "src/inspector/string-util.h"
       9             : 
      10             : #include <vector>
      11             : 
      12             : namespace v8_inspector {
      13             : namespace protocol {
      14             : 
      15             : template<typename T> class Array;
      16             : class DictionaryValue;
      17             : class DispatchResponse;
      18             : class ErrorSupport;
      19             : class FundamentalValue;
      20             : class ListValue;
      21             : template<typename T> class Maybe;
      22             : class Object;
      23             : using Response = DispatchResponse;
      24             : class SerializedValue;
      25             : class StringValue;
      26             : class UberDispatcher;
      27             : class Value;
      28             : 
      29             : } // namespace v8_inspector
      30             : } // namespace protocol
      31             : 
      32             : #endif // !defined(v8_inspector_protocol_Forward_h)
      33             : 
      34             : 
      35             : // Copyright 2016 The Chromium Authors. All rights reserved.
      36             : // Use of this source code is governed by a BSD-style license that can be
      37             : // found in the LICENSE file.
      38             : 
      39             : #ifndef v8_inspector_protocol_Allocator_h
      40             : #define v8_inspector_protocol_Allocator_h
      41             : 
      42             : namespace v8_inspector {
      43             : namespace protocol {
      44             : 
      45             : enum NotNullTagEnum { NotNullLiteral };
      46             : 
      47             : #define PROTOCOL_DISALLOW_NEW()                                 \
      48             :     private:                                                    \
      49             :         void* operator new(size_t) = delete;                    \
      50             :         void* operator new(size_t, NotNullTagEnum, void*) = delete; \
      51             :         void* operator new(size_t, void*) = delete;             \
      52             :     public:
      53             : 
      54             : #define PROTOCOL_DISALLOW_COPY(ClassName) \
      55             :     private: \
      56             :         ClassName(const ClassName&) = delete; \
      57             :         ClassName& operator=(const ClassName&) = delete
      58             : 
      59             : } // namespace v8_inspector
      60             : } // namespace protocol
      61             : 
      62             : #endif // !defined(v8_inspector_protocol_Allocator_h)
      63             : 
      64             : 
      65             : // Copyright 2016 The Chromium Authors. All rights reserved.
      66             : // Use of this source code is governed by a BSD-style license that can be
      67             : // found in the LICENSE file.
      68             : 
      69             : #ifndef v8_inspector_protocol_FrontendChannel_h
      70             : #define v8_inspector_protocol_FrontendChannel_h
      71             : 
      72             : namespace v8_inspector {
      73             : namespace protocol {
      74             : 
      75   106060486 : class  Serializable {
      76             : public:
      77             :     virtual String serialize() = 0;
      78   106060486 :     virtual ~Serializable() = default;
      79             : };
      80             : 
      81        4573 : class  FrontendChannel {
      82             : public:
      83        4573 :     virtual ~FrontendChannel() { }
      84             :     virtual void sendProtocolResponse(int callId, std::unique_ptr<Serializable> message) = 0;
      85             :     virtual void sendProtocolNotification(std::unique_ptr<Serializable> message) = 0;
      86             :     virtual void flushProtocolNotifications() = 0;
      87             : };
      88             : 
      89             : } // namespace v8_inspector
      90             : } // namespace protocol
      91             : 
      92             : #endif // !defined(v8_inspector_protocol_FrontendChannel_h)