Roll third_party/inspector_protocol to 344219890fe40130571f5a5b17f261a654e3b8cc.

This roll includes:
- [inspector_protocol] Support redirects and types whitelisting.

TBR=kozyatinskiy@chromium.org
BUG=none

Review-Url: https://codereview.chromium.org/2572643002
Cr-Commit-Position: refs/heads/master@{#438024}

third_party/inspector_protocol/CodeGenerator.py

@@ -440,6 +440,12 @@ class Protocol(object):
         return self.check_options(self.config.protocol.options, domain, event, "include_events", "exclude_events", True)
 
 
+    def generate_type(self, domain, typename):
+        if not self.config.protocol.options:
+            return domain in self.generate_domains
+        return self.check_options(self.config.protocol.options, domain, typename, "include_types", "exclude_types", True)
+
+
     def is_async_command(self, domain, command):
         if not self.config.protocol.options:
             return False
@@ -473,6 +479,10 @@ class Protocol(object):
         return True
 
 
+    def is_imported_dependency(self, domain):
+        return domain in self.generate_domains or domain in self.imported_domains
+
+
 def main():
     jinja_dir, config_file, config = read_config()
 

third_party/inspector_protocol/README.chromium

@@ -2,7 +2,7 @@ Name: inspector protocol
 Short Name: inspector_protocol
 URL: https://chromium.googlesource.com/deps/inspector_protocol/
 Version: 0
-Revision: c65b17da8a32bc6ab25b4ebbef1008f23c69e7d1
+Revision: 344219890fe40130571f5a5b17f261a654e3b8cc
 License: BSD
 License File: LICENSE
 Security Critical: no

third_party/inspector_protocol/lib/DispatcherBase_cpp.template

@@ -248,7 +248,13 @@ void UberDispatcher::registerBackend(const String& name, std::unique_ptr<protoco
     m_dispatchers[name] = std::move(dispatcher);
 }
 
-DispatchResponse::Status UberDispatcher::dispatch(std::unique_ptr<Value> parsedMessage)
+void UberDispatcher::setupRedirects(const HashMap<String, String>& redirects)
+{
+    for (const auto& pair : redirects)
+        m_redirects[pair.first] = pair.second;
+}
+
+DispatchResponse::Status UberDispatcher::dispatch(std::unique_ptr<Value> parsedMessage, int* outCallId, String* outMethod)
 {
     if (!parsedMessage) {
         reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kParseError, "Message must be a valid JSON");
@@ -263,6 +269,8 @@ DispatchResponse::Status UberDispatcher::dispatch(std::unique_ptr<Value> parsedM
     int callId = 0;
     protocol::Value* callIdValue = messageObject->get("id");
     bool success = callIdValue && callIdValue->asInteger(&callId);
+    if (outCallId)
+        *outCallId = callId;
     if (!success) {
         reportProtocolErrorTo(m_frontendChannel, DispatchResponse::kInvalidRequest, "Message must have integer 'id' porperty");
         return DispatchResponse::kError;
@@ -271,11 +279,17 @@ DispatchResponse::Status UberDispatcher::dispatch(std::unique_ptr<Value> parsedM
     protocol::Value* methodValue = messageObject->get("method");
     String method;
     success = methodValue && methodValue->asString(&method);
+    if (outMethod)
+        *outMethod = method;
     if (!success) {
         reportProtocolErrorTo(m_frontendChannel, callId, DispatchResponse::kInvalidRequest, "Message must have string 'method' porperty", nullptr);
         return DispatchResponse::kError;
     }
 
+    HashMap<String, String>::iterator redirectIt = m_redirects.find(method);
+    if (redirectIt != m_redirects.end())
+        method = redirectIt->second;
+
     size_t dotIndex = method.find(".");
     if (dotIndex == StringUtil::kNotFound) {
         if (m_fallThroughForNotFound)

third_party/inspector_protocol/lib/DispatcherBase_h.template

@@ -113,7 +113,8 @@ class {{config.lib.export_macro}} UberDispatcher {
 public:
     explicit UberDispatcher(FrontendChannel*);
     void registerBackend(const String& name, std::unique_ptr<protocol::DispatcherBase>);
-    DispatchResponse::Status dispatch(std::unique_ptr<Value> message);
+    void setupRedirects(const HashMap<String, String>&);
+    DispatchResponse::Status dispatch(std::unique_ptr<Value> message, int* callId = nullptr, String* method = nullptr);
     FrontendChannel* channel() { return m_frontendChannel; }
     bool fallThroughForNotFound() { return m_fallThroughForNotFound; }
     void setFallThroughForNotFound(bool);
@@ -122,6 +123,7 @@ public:
 private:
     FrontendChannel* m_frontendChannel;
     bool m_fallThroughForNotFound;
+    HashMap<String, String> m_redirects;
     protocol::HashMap<String, std::unique_ptr<protocol::DispatcherBase>> m_dispatchers;
 };
 

third_party/inspector_protocol/templates/TypeBuilder_cpp.template

@@ -19,6 +19,7 @@ const char Metainfo::domainName[] = "{{domain.domain}}";
 const char Metainfo::commandPrefix[] = "{{domain.domain}}.";
 const char Metainfo::version[] = "{{domain.version}}";
   {% for type in domain.types %}
+    {% if not protocol.generate_type(domain.domain, type.id) %}{% continue %} {% endif %}
     {% if "enum" in type %}
 
 namespace {{type.id}}Enum {
@@ -200,18 +201,23 @@ public:
         , m_backend(backend)
         , m_fallThroughForNotFound(fallThroughForNotFound) {
   {% for command in domain.commands %}
-    {% if "redirect" in command %}{% continue %}{% endif %}
+    {% if "redirect" in command %}
+      m_redirects["{{domain.domain}}.{{command.name}}"] = "{{command.redirect}}.{{command.name}}";
+      {% continue %}
+    {% endif %}
     {% if not protocol.generate_command(domain.domain, command.name) %}{% continue %}{% endif %}
         m_dispatchMap["{{domain.domain}}.{{command.name}}"] = &DispatcherImpl::{{command.name}};
   {% endfor %}
     }
     ~DispatcherImpl() override { }
     DispatchResponse::Status dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+    HashMap<String, String>& redirects() { return m_redirects; }
 
 protected:
     using CallHandler = DispatchResponse::Status (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
     using DispatchMap = protocol::HashMap<String, CallHandler>;
     DispatchMap m_dispatchMap;
+    HashMap<String, String> m_redirects;
 
   {% for command in domain.commands %}
     {% if "redirect" in command %}{% continue %}{% endif %}
@@ -337,9 +343,9 @@ DispatchResponse::Status DispatcherImpl::{{command.name}}(int callId, std::uniqu
           &out_{{parameter.name}}
         {%- endfor %}
       {% endif %});
-      {% if "returns" in command %}
     if (response.status() == DispatchResponse::kFallThrough)
         return response.status();
+      {% if "returns" in command %}
     std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
     if (response.status() == DispatchResponse::kSuccess) {
         {% for parameter in command.returns %}
@@ -378,9 +384,11 @@ DispatchResponse::Status DispatcherImpl::{{command.name}}(int callId, std::uniqu
   {% endfor %}
 
 // static
-void Dispatcher::wire(UberDispatcher* dispatcher, Backend* backend)
+void Dispatcher::wire(UberDispatcher* uber, Backend* backend)
 {
-    dispatcher->registerBackend("{{domain.domain}}", std::unique_ptr<protocol::DispatcherBase>(new DispatcherImpl(dispatcher->channel(), backend, dispatcher->fallThroughForNotFound())));
+    std::unique_ptr<DispatcherImpl> dispatcher(new DispatcherImpl(uber->channel(), backend, uber->fallThroughForNotFound()));
+    uber->setupRedirects(dispatcher->redirects());
+    uber->registerBackend("{{domain.domain}}", std::move(dispatcher));
 }
 
 } // {{domain.domain}}

third_party/inspector_protocol/templates/TypeBuilder_h.template

@@ -14,7 +14,9 @@
 // For each imported domain we generate a ValueConversions struct instead of a full domain definition
 // and include Domain::API version from there.
 {% for name in domain.dependencies %}
+  {% if protocol.is_imported_dependency(name) %}
 #include {{format_include(config.protocol.package, name)}}
+  {% endif %}
 {% endfor %}
 {% if protocol.is_exported_domain(domain.domain) %}
 #include {{format_include(config.exported.package, domain.domain)}}
@@ -27,6 +29,7 @@ namespace {{domain.domain}} {
 
 // ------------- Forward and enum declarations.
   {% for type in domain.types %}
+    {% if not protocol.generate_type(domain.domain, type.id) %}{% continue %}{% endif %}
     {% if type.type == "object" %}
       {% if "properties" in type %}
 // {{type.description}}
@@ -41,6 +44,7 @@ using {{type.id}} = {{protocol.resolve_type(type).type}};
     {% endif %}
   {% endfor %}
   {% for type in domain.types %}
+    {% if not protocol.generate_type(domain.domain, type.id) %}{% continue %}{% endif %}
     {% if "enum" in type %}
 
 namespace {{type.id}}Enum {
@@ -67,6 +71,7 @@ namespace {{param.name | to_title_case}}Enum {
 
 // ------------- Type and builder declarations.
   {% for type in domain.types %}
+    {% if not protocol.generate_type(domain.domain, type.id) %}{% continue %}{% endif %}
     {% if not (type.type == "object") or not ("properties" in type) %}{% continue %}{% endif %}
 
 // {{type.description}}