add DevTools page-agent implementation to display additional files in the source tree

Author: petekanev

runtime/src/main/java/com/tns/AndroidJsV8Inspector.java

@@ -17,15 +17,13 @@
 import java.util.LinkedList;
 import java.util.List;
 import java.util.Queue;
-import java.util.concurrent.ConcurrentLinkedQueue;
 import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.atomic.AtomicBoolean;
 
 import fi.iki.elonen.NanoHTTPD;
 import fi.iki.elonen.NanoWSD;
 
 class AndroidJsV8Inspector {
-    private static boolean DEBUG_LOG_ENABLED = true;
+    private static boolean DEBUG_LOG_ENABLED = false;
 
     private JsV8InspectorServer server;
     private Context context;

runtime/src/main/jni/v8_inspector/src/inspector/protocol/GenericTypes.cpp

@@ -0,0 +1,103 @@
+// 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 "src/inspector/protocol/GenericTypes.h"
+
+#include "src/inspector/protocol/Protocol.h"
+
+namespace v8_inspector {
+namespace protocol {
+namespace GenericTypes {
+
+// ------------- Enum values from types.
+
+const char Metainfo::domainName[] = "GenericTypes";
+const char Metainfo::commandPrefix[] = "GenericTypes.";
+const char Metainfo::version[] = "1.1";
+
+std::unique_ptr<SearchMatch> SearchMatch::parse(protocol::Value* value, ErrorSupport* errors) {
+    if (!value || value->type() != protocol::Value::TypeObject) {
+        errors->addError("object expected");
+        return nullptr;
+    }
+
+    std::unique_ptr<SearchMatch> result(new SearchMatch());
+    protocol::DictionaryValue* object = DictionaryValue::cast(value);
+    errors->push();
+    protocol::Value* lineNumberValue = object->get("lineNumber");
+    errors->setName("lineNumber");
+    result->m_lineNumber = ValueConversions<double>::parse(lineNumberValue, errors);
+    protocol::Value* lineContentValue = object->get("lineContent");
+    errors->setName("lineContent");
+    result->m_lineContent = ValueConversions<String>::parse(lineContentValue, errors);
+    errors->pop();
+    if (errors->hasErrors()) {
+        return nullptr;
+    }
+    return result;
+}
+
+std::unique_ptr<protocol::DictionaryValue> SearchMatch::serialize() const {
+    std::unique_ptr<protocol::DictionaryValue> result = DictionaryValue::create();
+    result->setValue("lineNumber", ValueConversions<double>::serialize(m_lineNumber));
+    result->setValue("lineContent", ValueConversions<String>::serialize(m_lineContent));
+    return result;
+}
+
+std::unique_ptr<SearchMatch> SearchMatch::clone() const {
+    ErrorSupport errors;
+    return parse(serialize().get(), &errors);
+}
+
+// ------------- Enum values from params.
+
+
+// ------------- Frontend notifications.
+
+void Frontend::flush() {
+    m_frontendChannel->flushProtocolNotifications();
+}
+
+// --------------------- Dispatcher.
+
+class DispatcherImpl : public protocol::DispatcherBase {
+    public:
+        DispatcherImpl(FrontendChannel* frontendChannel, Backend* backend)
+            : DispatcherBase(frontendChannel)
+            , m_backend(backend) {
+        }
+        ~DispatcherImpl() override { }
+        void dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) override;
+
+    protected:
+        using CallHandler = void (DispatcherImpl::*)(int callId, std::unique_ptr<DictionaryValue> messageObject, ErrorSupport* errors);
+        using DispatchMap = protocol::HashMap<String, CallHandler>;
+        DispatchMap m_dispatchMap;
+
+
+        Backend* m_backend;
+};
+
+void DispatcherImpl::dispatch(int callId, const String& method, std::unique_ptr<protocol::DictionaryValue> messageObject) {
+    protocol::HashMap<String, CallHandler>::iterator it = m_dispatchMap.find(method);
+    if (it == m_dispatchMap.end()) {
+        reportProtocolError(callId, MethodNotFound, "'" + method + "' wasn't found", nullptr);
+        return;
+    }
+
+    protocol::ErrorSupport errors;
+    (this->*(it->second))(callId, std::move(messageObject), &errors);
+}
+
+
+// static
+void Dispatcher::wire(UberDispatcher* dispatcher, Backend* backend) {
+    dispatcher->registerBackend("GenericTypes", wrapUnique(new DispatcherImpl(dispatcher->channel(), backend)));
+}
+
+} // GenericTypes
+} // namespace v8_inspector
+} // namespace protocol

runtime/src/main/jni/v8_inspector/src/inspector/protocol/GenericTypes.h

@@ -0,0 +1,149 @@
+// 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.
+
+#ifndef v8_inspector_protocol_GenericTypes_h
+#define v8_inspector_protocol_GenericTypes_h
+
+#include "src/inspector/protocol/Protocol.h"
+// For each imported domain we generate a ValueConversions struct instead of a full domain definition
+// and include Domain::API version from there.
+
+namespace v8_inspector {
+namespace protocol {
+namespace GenericTypes {
+
+// ------------- Forward and enum declarations.
+// Search match in a resource.
+class SearchMatch;
+
+// ------------- Type and builder declarations.
+
+// Search match in a resource.
+class  SearchMatch {
+        PROTOCOL_DISALLOW_COPY(SearchMatch);
+    public:
+        static std::unique_ptr<SearchMatch> parse(protocol::Value* value, ErrorSupport* errors);
+
+        ~SearchMatch() { }
+
+        double getLineNumber() {
+            return m_lineNumber;
+        }
+        void setLineNumber(double value) {
+            m_lineNumber = value;
+        }
+
+        String getLineContent() {
+            return m_lineContent;
+        }
+        void setLineContent(const String& value) {
+            m_lineContent = value;
+        }
+
+        std::unique_ptr<protocol::DictionaryValue> serialize() const;
+        std::unique_ptr<SearchMatch> clone() const;
+
+        template<int STATE>
+        class SearchMatchBuilder {
+            public:
+                enum {
+                    NoFieldsSet = 0,
+                    LineNumberSet = 1 << 1,
+                    LineContentSet = 1 << 2,
+                    AllFieldsSet = (LineNumberSet | LineContentSet | 0)
+                };
+
+
+                SearchMatchBuilder<STATE | LineNumberSet>& setLineNumber(double value) {
+                    static_assert(!(STATE & LineNumberSet), "property lineNumber should not be set yet");
+                    m_result->setLineNumber(value);
+                    return castState<LineNumberSet>();
+                }
+
+                SearchMatchBuilder<STATE | LineContentSet>& setLineContent(const String& value) {
+                    static_assert(!(STATE & LineContentSet), "property lineContent should not be set yet");
+                    m_result->setLineContent(value);
+                    return castState<LineContentSet>();
+                }
+
+                std::unique_ptr<SearchMatch> build() {
+                    static_assert(STATE == AllFieldsSet, "state should be AllFieldsSet");
+                    return std::move(m_result);
+                }
+
+            private:
+                friend class SearchMatch;
+                SearchMatchBuilder() : m_result(new SearchMatch()) { }
+
+                template<int STEP> SearchMatchBuilder<STATE | STEP>& castState() {
+                    return *reinterpret_cast<SearchMatchBuilder<STATE | STEP>*>(this);
+                }
+
+                std::unique_ptr<protocol::GenericTypes::SearchMatch> m_result;
+        };
+
+        static SearchMatchBuilder<0> create() {
+            return SearchMatchBuilder<0>();
+        }
+
+    private:
+        SearchMatch() {
+            m_lineNumber = 0;
+        }
+
+        double m_lineNumber;
+        String m_lineContent;
+};
+
+
+// ------------- Backend interface.
+
+class  Backend {
+    public:
+        virtual ~Backend() { }
+
+
+        virtual void disable(ErrorString*) { }
+};
+
+// ------------- Frontend interface.
+
+class  Frontend {
+    public:
+        Frontend(FrontendChannel* frontendChannel) : m_frontendChannel(frontendChannel) { }
+
+        void flush();
+    private:
+        FrontendChannel* m_frontendChannel;
+};
+
+// ------------- Dispatcher.
+
+class  Dispatcher {
+    public:
+        static void wire(UberDispatcher*, Backend*);
+
+    private:
+        Dispatcher() { }
+};
+
+// ------------- Metainfo.
+
+class  Metainfo {
+    public:
+        using BackendClass = Backend;
+        using FrontendClass = Frontend;
+        using DispatcherClass = Dispatcher;
+        static const char domainName[];
+        static const char commandPrefix[];
+        static const char version[];
+};
+
+} // namespace GenericTypes
+} // namespace v8_inspector
+} // namespace protocol
+
+#endif // !defined(v8_inspector_protocol_GenericTypes_h)