DevTools: migrate protocol dispatcher off RefPtr.

third_party/WebKit/Source/platform/inspector_protocol/Dispatcher_cpp.template

 // This file is generated
 
 // Copyright (c) 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 "platform/inspector_protocol/{{class_name}}.h"
 
 #include "platform/inspector_protocol/FrontendChannel.h"
 #include "platform/inspector_protocol/Parser.h"
+#include "wtf/HashSet.h"
 #include "wtf/text/CString.h"
 
 namespace blink {
 namespace protocol {
 
 using protocol::Maybe;
 
+class DispatcherImpl;
+
+class DispatcherImplWeakPtr {
+public:
+    DispatcherImplWeakPtr(DispatcherImpl* dispatcher) : m_dispatcher(dispatcher) { }
+    ~DispatcherImplWeakPtr();
+    DispatcherImpl* get() { return m_dispatcher; }
+    void dispose() { m_dispatcher = nullptr; }
+private:
+    DispatcherImpl* m_dispatcher;
+};
+
 class DispatcherImpl : public Dispatcher {
 public:
     DispatcherImpl(FrontendChannel* frontendChannel)
         : m_frontendChannel(frontendChannel)
 {% for domain in api.domains %}
         , m_{{domain.domain | lower}}Agent(0)
 {% endfor %}
     {
 {% for domain in api.domains %}
   {% for command in domain.commands %}
     {% if "redirect" in command %}{% continue %}{% endif %}
     {% if "handlers" in command and not ("renderer" in command["handlers"]) %}{% continue %}{% endif %}
         m_dispatchMap.add("{{domain.domain}}.{{command.name}}", &DispatcherImpl::{{domain.domain}}_{{command.name}});
   {% endfor %}
 {% endfor %}
 
         // Initialize common errors.
         m_commonErrors.insert(ParseError, -32700);
         m_commonErrors.insert(InvalidRequest, -32600);
         m_commonErrors.insert(MethodNotFound, -32601);
         m_commonErrors.insert(InvalidParams, -32602);
         m_commonErrors.insert(InternalError, -32603);
         m_commonErrors.insert(ServerError, -32000);
     }
 
-    virtual void clearFrontend() { m_frontendChannel = 0; }
+    ~DispatcherImpl() { clearFrontend(); }
+
+    virtual void clearFrontend()
+    {
+        m_frontendChannel = nullptr;
+        for (auto& weak : m_weakPtrs)
+            weak->dispose();
+        m_weakPtrs.clear();
+    }
+
+    PassOwnPtr<DispatcherImplWeakPtr> weakPtr()
+    {
+        OwnPtr<DispatcherImplWeakPtr> weak = adoptPtr(new DispatcherImplWeakPtr(this));
+        m_weakPtrs.add(weak.get());
+        return weak.release();
+    }
+
     virtual void dispatch(int sessionId, const String& message);
     virtual void reportProtocolError(int sessionId, int callId, CommonErrorCode, const String& errorMessage, ErrorSupport* errors) const;
     using Dispatcher::reportProtocolError;
 
     void sendResponse(int sessionId, int callId, const ErrorString& invocationError, ErrorSupport* errors, PassOwnPtr<protocol::DictionaryValue> result);
-    bool isActive() { return m_frontendChannel; }
 
 {% for domain in api.domains %}
     virtual void registerAgent({{domain.domain}}CommandHandler* agent) { ASSERT(!m_{{domain.domain | lower}}Agent); m_{{domain.domain | lower}}Agent = agent; }
 {% endfor %}
 
 private:
+    friend class CallbackBase;
+    friend class DispatcherImplWeakPtr;
     using CallHandler = void (DispatcherImpl::*)(int sessionId, int callId, PassOwnPtr<DictionaryValue> messageObject, ErrorSupport* errors);
     using DispatchMap = HashMap<String, CallHandler>;
 
 {% for domain in api.domains %}
   {% for command in domain.commands %}
     {% if "redirect" in command %}{% continue %}{% endif %}
     {% if "handlers" in command and not ("renderer" in command["handlers"]) %}{% continue %}{% endif %}
     void {{domain.domain}}_{{command.name}}(int sessionId, int callId, PassOwnPtr<DictionaryValue> requestMessageObject, ErrorSupport*);
   {% endfor %}
 {% endfor %}
@@ skipping 11 matching lines @@
 
     void sendResponse(int sessionId, int callId, ErrorString invocationError)
     {
         sendResponse(sessionId, callId, invocationError, nullptr, DictionaryValue::create());
     }
 
     static const char InvalidParamsFormatString[];
 
     DispatchMap m_dispatchMap;
     Vector<int> m_commonErrors;
+    HashSet<DispatcherImplWeakPtr*> m_weakPtrs;
 };
 
+DispatcherImplWeakPtr::~DispatcherImplWeakPtr()
+{
+    if (m_dispatcher)
+        m_dispatcher->m_weakPtrs.remove(this);
+}
+
 const char DispatcherImpl::InvalidParamsFormatString[] = "Some arguments of method '%s' can't be processed";
 {% for domain in api.domains %}
   {% for command in domain.commands %}
     {% if "redirect" in command %}{% continue %}{% endif %}
     {% if "handlers" in command and not ("renderer" in command["handlers"]) %}{% continue %}{% endif %}
 
     {% if "async" in command %}
-Dispatcher::{{domain.domain}}CommandHandler::{{command.name | to_title_case}}Callback::{{command.name | to_title_case}}Callback(PassRefPtr<DispatcherImpl> backendImpl, int sessionId, int id) : CallbackBase(backendImpl, sessionId, id) { }
+Dispatcher::{{domain.domain}}CommandHandler::{{command.name | to_title_case}}Callback::{{command.name | to_title_case}}Callback(PassOwnPtr<DispatcherImplWeakPtr> backendImpl, int sessionId, int id) : CallbackBase(backendImpl, sessionId, id) { }
 
 void Dispatcher::{{domain.domain}}CommandHandler::{{command.name | to_title_case}}Callback::sendSuccess(
       {%- for parameter in command.returns -%}
         {%- if "optional" in parameter -%}
         const Maybe<{{resolve_type(parameter).raw_type}}>& {{parameter.name}}
         {%- else -%}
         {{resolve_type(parameter).pass_type}} {{parameter.name}}
         {%- endif -%}
         {%- if not loop.last -%}, {% endif -%}
       {% endfor %})
@@ skipping 39 matching lines @@
         {% endif %}
       {% endfor %}
     errors->pop();
     if (errors->hasErrors()) {
         reportProtocolError(sessionId, callId, InvalidParams, String::format(InvalidParamsFormatString, "{{domain.domain}}.{{command.name}}"), errors);
         return;
     }
     {% endif %}
 
     {% if "async" in command %}
-    RefPtr<{{domain.domain}}CommandHandler::{{command.name | to_title_case}}Callback> callback = adoptRef(new {{domain.domain}}CommandHandler::{{command.name | to_title_case}}Callback(this, sessionId, callId));
+    OwnPtr<{{domain.domain}}CommandHandler::{{command.name | to_title_case}}Callback> callback = adoptPtr(new {{domain.domain}}CommandHandler::{{command.name | to_title_case}}Callback(weakPtr(), sessionId, callId));
     {% elif "returns" in command %}
     // Declare output parameters.
     OwnPtr<protocol::DictionaryValue> result = DictionaryValue::create();
       {% for property in command.returns %}
         {% if "optional" in property %}
     Maybe<{{resolve_type(property).raw_type}}> out_{{property.name}};
         {% else %}
     {{resolve_type(property).type}} out_{{property.name}};
         {% endif %}
       {% endfor %}
     {% endif %}
 
+    OwnPtr<DispatcherImplWeakPtr> weak = weakPtr();
     ErrorString error;
     m_{{domain.domain | lower}}Agent->{{command.name}}(&error
       {%- for property in command.parameters -%}
         {%- if "optional" in property -%}
         , in_{{property.name}}
         {%- else -%}
         , {{resolve_type(property).to_pass_type % ("in_" + property.name)}}
         {%- endif -%}
       {%- endfor %}
       {%- if "async" in command -%}
         , callback.release()
       {%- elif "returns" in command %}
         {%- for property in command.returns -%}
           , &out_{{property.name}}
         {%- endfor %}
       {% endif %});
     {% if "returns" in command and not("async" in command) %}
     if (!error.length()) {
       {% for parameter in command.returns %}
         {% if "optional" in parameter %}
         if (out_{{parameter.name}}.isJust())
             result->setValue("{{parameter.name}}", toValue(out_{{parameter.name}}.fromJust()));
         {% else %}
         result->setValue("{{parameter.name}}", toValue({{resolve_type(parameter).to_raw_type % ("out_" + parameter.name)}}));
         {% endif %}
       {% endfor %}
     }
-    sendResponse(sessionId, callId, error, result.release());
+    if (weak->get())
+        weak->get()->sendResponse(sessionId, callId, error, result.release());
     {% elif not("async" in command) %}
-    sendResponse(sessionId, callId, error);
+    if (weak->get())
+        weak->get()->sendResponse(sessionId, callId, error);
     {% endif %}
 }
   {% endfor %}
 {% endfor %}
 
-PassRefPtr<Dispatcher> Dispatcher::create(FrontendChannel* frontendChannel)
+PassOwnPtr<Dispatcher> Dispatcher::create(FrontendChannel* frontendChannel)
 {
-    return adoptRef(new DispatcherImpl(frontendChannel));
+    return adoptPtr(new DispatcherImpl(frontendChannel));
 }
 
 void DispatcherImpl::dispatch(int sessionId, const String& message)
 {
-    RefPtr<Dispatcher> protect(this);
     int callId = 0;
     OwnPtr<protocol::Value> parsedMessage = parseJSON(message);
     ASSERT(parsedMessage);
     OwnPtr<protocol::DictionaryValue> messageObject = DictionaryValue::cast(parsedMessage.release());
     ASSERT(messageObject);
 
     protocol::Value* callIdValue = messageObject->get("id");
     bool success = callIdValue->asNumber(&callId);
     ASSERT_UNUSED(success, success);
 
@@ skipping 59 matching lines @@
     protocol::DictionaryValue* object = DictionaryValue::cast(value.get());
     if (!object)
         return false;
 
     if (!object->getString("method", result))
         return false;
 
     return true;
 }
 
-Dispatcher::CallbackBase::CallbackBase(PassRefPtr<DispatcherImpl> backendImpl, int sessionId, int id)
-    : m_backendImpl(backendImpl), m_sessionId(sessionId), m_id(id), m_alreadySent(false) { }
+Dispatcher::CallbackBase::CallbackBase(PassOwnPtr<DispatcherImplWeakPtr> backendImpl, int sessionId, int id)
+    : m_backendImpl(backendImpl), m_sessionId(sessionId), m_id(id) { }
 
 Dispatcher::CallbackBase::~CallbackBase() { }
 
 void Dispatcher::CallbackBase::sendFailure(const ErrorString& error)
 {
     ASSERT(error.length());
     sendIfActive(nullptr, error);
 }
 
-bool Dispatcher::CallbackBase::isActive()
+void Dispatcher::CallbackBase::dispose()
 {
-    return !m_alreadySent && m_backendImpl->isActive();
+    m_backendImpl = nullptr;
 }
 
 void Dispatcher::CallbackBase::sendIfActive(PassOwnPtr<protocol::DictionaryValue> partialMessage, const ErrorString& invocationError)
 {
-    if (m_alreadySent)
+    if (!m_backendImpl->get())
         return;
-    m_backendImpl->sendResponse(m_sessionId, m_id, invocationError, nullptr, partialMessage);
-    m_alreadySent = true;
+    m_backendImpl->get()->sendResponse(m_sessionId, m_id, invocationError, nullptr, partialMessage);
+    m_backendImpl = nullptr;
 }
 
 } // namespace protocol
 } // namespace blink