[inspector_protocol] Support features for content/ generator.

lib/DispatcherBase_h.template

 // Copyright 2016 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef {{"_".join(config.protocol.namespace)}}_DispatcherBase_h
 #define {{"_".join(config.protocol.namespace)}}_DispatcherBase_h
 
 //#include "Collections.h"
 //#include "ErrorSupport.h"
 //#include "Forward.h"
@@ skipping 24 matching lines @@
     };
 
     Status status() const { return m_status; }
     const String& errorMessage() const { return m_errorMessage; }
     ErrorCode errorCode() const { return m_errorCode; }
     bool isSuccess() const { return m_status == kSuccess; }
 
     static DispatchResponse OK();
     static DispatchResponse Error(const String&);
     static DispatchResponse InternalError();
+    static DispatchResponse InvalidParams(const String&);
     static DispatchResponse FallThrough();
 
 private:
     Status m_status;
     String m_errorMessage;
     ErrorCode m_errorCode;
 };
 
 class {{config.lib.export_macro}} DispatcherBase {
     PROTOCOL_DISALLOW_COPY(DispatcherBase);
 public:
     static const char kInvalidParamsString[];
     class {{config.lib.export_macro}} WeakPtr {
     public:
         explicit WeakPtr(DispatcherBase*);
         ~WeakPtr();
         DispatcherBase* get() { return m_dispatcher; }
         void dispose() { m_dispatcher = nullptr; }
 
     private:
         DispatcherBase* m_dispatcher;
     };
 
     class {{config.lib.export_macro}} Callback {
     public:
-        Callback(std::unique_ptr<WeakPtr> backendImpl, int callId);
+        Callback(std::unique_ptr<WeakPtr> backendImpl, int callId, int callbackId);
         virtual ~Callback();
         void dispose();
 
     protected:
         void sendIfActive(std::unique_ptr<protocol::DictionaryValue> partialMessage, const DispatchResponse& response);
+        void fallThroughIfActive();
 
     private:
         std::unique_ptr<WeakPtr> m_backendImpl;
         int m_callId;
+        int m_callbackId;
     };
 
     explicit DispatcherBase(FrontendChannel*);
     virtual ~DispatcherBase();
 
     static bool getCommandName(const String& message, String* result);
 
     virtual DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) = 0;
 
     void sendResponse(int callId, const DispatchResponse&, std::unique_ptr<protocol::DictionaryValue> result);
     void sendResponse(int callId, const DispatchResponse&);
 
     void reportProtocolError(int callId, DispatchResponse::ErrorCode, const String& errorMessage, ErrorSupport* errors);
     void clearFrontend();
 
     std::unique_ptr<WeakPtr> weakPtr();
 
+    int nextCallbackId();
+    void markFallThrough(int callbackId);
+    bool lastCallbackFallThrough() { return m_lastCallbackFallThrough; }
+
 private:
     FrontendChannel* m_frontendChannel;
     protocol::HashSet<WeakPtr*> m_weakPtrs;
+    int m_lastCallbackId;
+    bool m_lastCallbackFallThrough;
 };
 
 class {{config.lib.export_macro}} UberDispatcher {
     PROTOCOL_DISALLOW_COPY(UberDispatcher);
 public:
     explicit UberDispatcher(FrontendChannel*);
     void registerBackend(const String& name, std::unique_ptr<protocol::DispatcherBase>);
     DispatchResponse::Status dispatch(std::unique_ptr<Value> message);
     FrontendChannel* channel() { return m_frontendChannel; }
+    bool fallThroughForNotFound() { return m_fallThroughForNotFound; }
+    void setFallThroughForNotFound(bool);
     virtual ~UberDispatcher();
 
 private:
     FrontendChannel* m_frontendChannel;
+    bool m_fallThroughForNotFound;
     protocol::HashMap<String, std::unique_ptr<protocol::DispatcherBase>> m_dispatchers;
 };
 
 {% for namespace in config.protocol.namespace %}
 } // namespace {{namespace}}
 {% endfor %}
 
 #endif // !defined({{"_".join(config.protocol.namespace)}}_DispatcherBase_h)