[DevTools] filter any messages from previous session in DevToolsAgentHostImpl

content/browser/devtools/protocol/devtools_protocol_handler_generator.py

 #!/usr/bin/env python
 # Copyright 2014 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.
 
 import sys
 import string
 import json
 
 blink_protocol_path = sys.argv[1]
@@ skipping 56 matching lines @@
 
 template<>
 base::Value* CreateValue(const std::string& param);
 
 ${types}\
 
 }  // namespace devtools
 
 class DevToolsProtocolDispatcher {
  public:
-  using Notifier = DevToolsProtocolClient::RawMessageCallback;
   using CommandHandler =
-      base::Callback<bool(int, scoped_ptr<base::DictionaryValue>)>;
+      base::Callback<bool(DevToolsCommandId,
+                          scoped_ptr<base::DictionaryValue>)>;
 
-  explicit DevToolsProtocolDispatcher(const Notifier& notifier);
+  explicit DevToolsProtocolDispatcher(DevToolsProtocolDelegate* notifier);
   ~DevToolsProtocolDispatcher();
 
   CommandHandler FindCommandHandler(const std::string& method);
 
 ${setters}\
 
  private:
   using Response = DevToolsProtocolClient::Response;
   using CommandHandlers = std::map<std::string, CommandHandler>;
 
 ${methods}\
 
-  Notifier notifier_;
+  DevToolsProtocolDelegate* notifier_;
   DevToolsProtocolClient client_;
   CommandHandlers command_handlers_;
 ${fields}\
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DEVTOOLS_PROTOCOL_DEVTOOLS_PROTOCOL_DISPATCHER_H_
 """)
 
@@ skipping 96 matching lines @@
 tmpl_handler = string.Template("""\
 namespace ${domain} {
 class ${Domain}Handler;
 }  // namespace domain
 """)
 
 tmpl_client = string.Template("""\
 namespace ${domain} {
 class Client : public DevToolsProtocolClient {
  public:
-  explicit Client(const RawMessageCallback& raw_message_callback);
+  explicit Client(DevToolsProtocolDelegate* notifier);
   ~Client() override;
 
 ${methods}\
 };
 }  // namespace ${domain}
 """)
 
 tmpl_event = string.Template("""\
   void ${Command}(
       scoped_refptr<${Command}Params> params);
@@ skipping 23 matching lines @@
 template_cc = string.Template(header + """\
 
 #include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 ${includes}\
 
 namespace content {
 
 DevToolsProtocolDispatcher::DevToolsProtocolDispatcher(
-    const Notifier& notifier)
+    DevToolsProtocolDelegate* notifier)
     : notifier_(notifier),
       client_(notifier),
       ${fields_init} {
 }
 
 DevToolsProtocolDispatcher::~DevToolsProtocolDispatcher() {
 }
 
 DevToolsProtocolDispatcher::CommandHandler
 DevToolsProtocolDispatcher::FindCommandHandler(const std::string& method) {
@@ skipping 132 matching lines @@
 
 tmpl_arg_opt = string.Template(
     "${param}_found ? ${param_pass} : nullptr")
 
 tmpl_object_pass = string.Template(
     "make_scoped_ptr<base::DictionaryValue>(${name}->DeepCopy())")
 
 tmpl_client_impl = string.Template("""\
 namespace ${domain} {
 
-Client::Client(const RawMessageCallback& raw_message_callback)
-    : DevToolsProtocolClient(raw_message_callback) {
+Client::Client(DevToolsProtocolDelegate* notifier)
+    : DevToolsProtocolClient(notifier) {
 }
 
 Client::~Client() {
 }
 
 ${methods}\
 
 }  // namespace ${domain}
 """)
 
@@ skipping 374 matching lines @@
 output_h_file.close()
 
 output_cc_file.write(template_cc.substitute({},
     major = blink_protocol["version"]["major"],
     minor = blink_protocol["version"]["minor"],
     includes = "".join(sorted(includes)),
     fields_init = ",\n      ".join(fields_init),
     methods = "\n".join(handler_method_impls),
     types = "\n".join(type_impls)))
 output_cc_file.close()