[DevTools] Move IO and Tracing to new generator.

third_party/inspector_protocol/lib/DispatcherBase_cpp.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.
 
 //#include "DispatcherBase.h"
 //#include "Parser.h"
 
 {% for namespace in config.protocol.namespace %}
 namespace {{namespace}} {
 {% endfor %}
@@ skipping 40 matching lines @@
 const char DispatcherBase::kInvalidParamsString[] = "Invalid parameters";
 
 DispatcherBase::WeakPtr::WeakPtr(DispatcherBase* dispatcher) : m_dispatcher(dispatcher) { }
 
 DispatcherBase::WeakPtr::~WeakPtr()
 {
     if (m_dispatcher)
         m_dispatcher->m_weakPtrs.erase(this);
 }
 
-DispatcherBase::Callback::Callback(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId)
+DispatcherBase::Callback::Callback(std::unique_ptr<DispatcherBase::WeakPtr> backendImpl, int callId, int callbackId)
     : m_backendImpl(std::move(backendImpl))
-    , m_callId(callId) { }
+    , m_callId(callId)
+    , m_callbackId(callbackId) { }
 
 DispatcherBase::Callback::~Callback() = default;
 
 void DispatcherBase::Callback::dispose()
 {
     m_backendImpl = nullptr;
 }
 
 void DispatcherBase::Callback::sendIfActive(std::unique_ptr<protocol::DictionaryValue> partialMessage, const DispatchResponse& response)
 {
     if (!m_backendImpl || !m_backendImpl->get())
         return;
     m_backendImpl->get()->sendResponse(m_callId, response, std::move(partialMessage));
     m_backendImpl = nullptr;
 }
 
+void DispatcherBase::Callback::fallThroughIfActive()
+{
+    if (!m_backendImpl || !m_backendImpl->get())
+        return;
+    m_backendImpl->get()->markFallThrough(m_callbackId);
+    m_backendImpl = nullptr;
+}
+
 DispatcherBase::DispatcherBase(FrontendChannel* frontendChannel)
-    : m_frontendChannel(frontendChannel) { }
+    : m_frontendChannel(frontendChannel)
+    , m_lastCallbackId(0)
+    , m_lastCallbackFallThrough(false) { }
 
 DispatcherBase::~DispatcherBase()
 {
     clearFrontend();
 }
 
+int DispatcherBase::nextCallbackId()
+{
+    m_lastCallbackFallThrough = false;
+    return ++m_lastCallbackId;
+}
+
+void DispatcherBase::markFallThrough(int callbackId)
+{
+    if (callbackId == m_lastCallbackId)
+        m_lastCallbackFallThrough = true;
+}
+
 // static
 bool DispatcherBase::getCommandName(const String& message, String* result)
 {
     std::unique_ptr<protocol::Value> value = StringUtil::parseJSON(message);
     if (!value)
         return false;
 
     protocol::DictionaryValue* object = DictionaryValue::cast(value.get());
     if (!object)
         return false;
@@ skipping 66 matching lines @@
 std::unique_ptr<DispatcherBase::WeakPtr> DispatcherBase::weakPtr()
 {
     std::unique_ptr<DispatcherBase::WeakPtr> weak(new DispatcherBase::WeakPtr(this));
     m_weakPtrs.insert(weak.get());
     return weak;
 }
 
 UberDispatcher::UberDispatcher(FrontendChannel* frontendChannel)
     : m_frontendChannel(frontendChannel) { }
 
+UberDispatcher::UberDispatcher(FrontendChannel* frontendChannel, bool fallThroughForNotFound)
+    : m_frontendChannel(frontendChannel)
+    , m_fallThroughForNotFound(fallThroughForNotFound) { }
+
 void UberDispatcher::registerBackend(const String& name, std::unique_ptr<protocol::DispatcherBase> dispatcher)
 {
     m_dispatchers[name] = std::move(dispatcher);
 }
 
 DispatchResponse::Status UberDispatcher::dispatch(std::unique_ptr<Value> parsedMessage)
 {
     if (!parsedMessage) {
         reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kParseError, "Message must be a valid JSON");
         return DispatchResponse::kError;
@@ skipping 15 matching lines @@
     protocol::Value* methodValue = messageObject->get("method");
     String method;
     success = methodValue && methodValue->asString(&method);
     if (!success) {
         reportProtocolErrorTo(m_frontendChannel, callId, DispatchResponse::kInvalidRequest, "Message must have string 'method' porperty", nullptr);
         return DispatchResponse::kError;
     }
 
     size_t dotIndex = method.find(".");
     if (dotIndex == StringUtil::kNotFound) {
+        if (m_fallThroughForNotFound)
+            return DispatchResponse::kFallThrough;
         reportProtocolErrorTo(m_frontendChannel, callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
         return DispatchResponse::kError;
     }
     String domain = StringUtil::substring(method, 0, dotIndex);
     auto it = m_dispatchers.find(domain);
     if (it == m_dispatchers.end()) {
+        if (m_fallThroughForNotFound)
+            return DispatchResponse::kFallThrough;
         reportProtocolErrorTo(m_frontendChannel, callId, DispatchResponse::kMethodNotFound, "'" + method + "' wasn't found", nullptr);
         return DispatchResponse::kError;
     }
     return it->second->dispatch(callId, method, std::move(messageObject));
 }
 
 UberDispatcher::~UberDispatcher() = default;
 
 {% for namespace in config.protocol.namespace %}
 } // namespace {{namespace}}
 {% endfor %}