[DevTools] Filter any messages from previous sessions 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 58 matching lines @@
 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(int, int, scoped_ptr<base::DictionaryValue>)>;
 
   explicit DevToolsProtocolDispatcher(const Notifier& notifier);
   ~DevToolsProtocolDispatcher();
 
   CommandHandler FindCommandHandler(const std::string& method);
 
 ${setters}\
 
  private:
   using Response = DevToolsProtocolClient::Response;
@@ skipping 126 matching lines @@
 }  // namespace ${domain}
 """)
 
 tmpl_event = string.Template("""\
   void ${Command}(
       scoped_refptr<${Command}Params> params);
 """)
 
 tmpl_response = string.Template("""\
   void Send${Command}Response(
+      int session_id,
       DevToolsCommandId command_id,
       scoped_refptr<${Command}Response> params);
 """)
 
 tmpl_setter = string.Template("""\
   void Set${Domain}Handler(
       devtools::${domain}::${Domain}Handler* ${domain}_handler);
 """)
 
 tmpl_callback = string.Template("""\
   bool On${Domain}${Command}(
+      int session_id,
       DevToolsCommandId command_id,
       scoped_ptr<base::DictionaryValue> params);
 """)
 
 tmpl_field = string.Template("""\
   devtools::${domain}::${Domain}Handler* ${domain}_handler_;
 """)
 
 template_cc = string.Template(header + """\
 
@@ skipping 69 matching lines @@
           base::Unretained(this));
 """)
 
 tmpl_init_client = string.Template("""\
   ${domain}_handler_->SetClient(make_scoped_ptr(
       new devtools::${domain}::Client(notifier_)));
 """)
 
 tmpl_callback_impl = string.Template("""\
 bool DevToolsProtocolDispatcher::On${Domain}${Command}(
-    DevToolsCommandId command_id,
+    int session_id, DevToolsCommandId command_id,
     scoped_ptr<base::DictionaryValue> params) {
 ${prep}\
   Response response = ${domain}_handler_->${Command}(${args});
   scoped_ptr<base::DictionaryValue> protocol_response;
-  if (client_.SendError(command_id, response))
+  if (client_.SendError(session_id, command_id, response))
     return true;
   if (response.IsFallThrough())
     return false;
   scoped_ptr<base::DictionaryValue> result(new base::DictionaryValue());
 ${wrap}\
-  client_.SendSuccess(command_id, result.Pass());
+  client_.SendSuccess(session_id, command_id, result.Pass());
   return true;
 }
 """)
 
 tmpl_wrap = string.Template("""\
   result->Set("${proto_param}", devtools::CreateValue(out_${param}));
 """)
 
 tmpl_callback_async_impl = string.Template("""\
 bool DevToolsProtocolDispatcher::On${Domain}${Command}(
+    int session_id,
     DevToolsCommandId command_id,
     scoped_ptr<base::DictionaryValue> params) {
 ${prep}\
   Response response = ${domain}_handler_->${Command}(${args});
-  if (client_.SendError(command_id, response))
+  if (client_.SendError(session_id, command_id, response))
     return true;
   return !response.IsFallThrough();
 }
 """)
 
 tmpl_prep_req = string.Template("""\
   ${raw_type} in_${param}${init};
   if (!params || !params->Get${Type}("${proto_param}", &in_${param})) {
-    client_.SendError(command_id, Response::InvalidParams("${proto_param}"));
+    client_.SendError(session_id, command_id, Response::InvalidParams("${proto_param}"));
     return true;
   }
 """)
 
 tmpl_prep_req_list = string.Template("""\
   base::ListValue* list_${param} = nullptr;
   if (!params || !params->GetList("${proto_param}", &list_${param})) {
-    client_.SendError(command_id, Response::InvalidParams("${proto_param}"));
+    client_.SendError(session_id, command_id, Response::InvalidParams("${proto_param}"));
     return true;
   }
   std::vector<${item_type}> in_${param};
   for (base::ListValue::const_iterator it =
       list_${param}->begin(); it != list_${param}->end(); ++it) {
     ${item_raw_type} item;
     if (!(*it)->GetAs${ItemType}(&item)) {
-      client_.SendError(command_id, Response::InvalidParams("${proto_param}"));
+      client_.SendError(session_id, command_id, Response::InvalidParams("${proto_param}"));
       return true;
     }
     in_${param}.push_back(${item_pass});
   }
 """)
 
 tmpl_prep_opt = string.Template("""\
   ${raw_type} in_${param}${init};
   bool ${param}_found = params && params->Get${Type}(
       "${proto_param}",
@@ skipping 32 matching lines @@
 tmpl_event_impl = string.Template("""\
 void Client::${Command}(
     scoped_refptr<${Command}Params> params) {
   SendNotification("${Domain}.${command}",
                    params->ToValue().Pass());
 }
 """)
 
 tmpl_response_impl = string.Template("""\
 void Client::Send${Command}Response(
+    int session_id,
     DevToolsCommandId command_id,
     scoped_refptr<${Command}Response> params) {
-  SendSuccess(command_id, params->ToValue().Pass());
+  SendSuccess(session_id, command_id, params->ToValue().Pass());
 }
 """)
 
 tmpl_typename = string.Template("devtools::${domain}::${declared_name}")
 
 def Capitalize(s):
   return s[:1].upper() + s[1:]
 
 def Uncamelcase(s):
   result = ""
@@ skipping 258 matching lines @@
       if json_command.get("async"):
         domain_needs_client = True
         json_returns = []
         if "returns" in json_command:
           json_returns = json_command["returns"]
         command_map["declared_name"] = "%sResponse" % command_map["Command"]
         DeclareStruct(json_returns, command_map)
         # TODO(vkuzkokov) Pass async callback instance similar to how
         # InspectorBackendDispatcher does it. This, however, can work
         # only if Blink and Chrome are in the same repo.
-        args.insert(0, "command_id")
+        args.insert(0, "session_id")
+        args.insert(1, "command_id")
         handler_method_impls.append(
             tmpl_callback_async_impl.substitute(command_map,
                 prep = "".join(prep),
                 args = "\n      " + ",\n      ".join(args)))
         client_methods.append(tmpl_response.substitute(command_map))
         client_method_impls.append(tmpl_response_impl.substitute(command_map))
       else:
         wrap = []
         if "returns" in json_command:
           for json_param in json_command["returns"]:
@@ skipping 72 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()