2013-02-04  Andrey Kosyakov  <caseq@chromium.org>

        Web Inspector: plumb trace events to Timeline agent

        https://bugs.webkit.org/show_bug.cgi?id=105796

        Reviewed by NOBODY (OOPS!).

        - plumb trace events to Timeline;

        - add TimelineTraceEventProcessor to process selected trace events;

        - emit timeline events from TimelineTraceEventProcessor.

        Note that actual event processing logic is a separate change.

        * CMakeLists.txt:

        * GNUmakefile.list.am:

        * Target.pri:

        * WebCore.gypi:

        * WebCore.vcproj/WebCore.vcproj:

        * WebCore.xcodeproj/project.pbxproj:

        * inspector/InspectorAllInOne.cpp:

        * inspector/InspectorClient.h:

        (InspectorClient):

        (WebCore::InspectorClient::setTraceEventCallback):

        * inspector/InspectorTimelineAgent.cpp:

        (WebCore::InspectorTimelineAgent::start):

        (WebCore::InspectorTimelineAgent::stop):

        (WebCore::InspectorTimelineAgent::InspectorTimelineAgent):

        (WebCore::InspectorTimelineAgent::page):

        (WebCore):

        * inspector/InspectorTimelineAgent.h:

        (WebCore):

        (InspectorTimelineAgent):

        * inspector/TimelineTraceEventProcessor.cpp: Added.

        (WebCore::TimelineTraceEventProcessor::TimelineTraceEventProcessor):

        (WebCore):

        (WebCore::TimelineTraceEventProcessor::~TimelineTraceEventProcessor):

        (WebCore::TimelineTraceEventProcessor::TraceEvent::parameter):

        (WebCore::TimelineTraceEventProcessor::processEventOnAnyThread):

        (WebCore::TimelineTraceEventProcessor::processEvent):

        (WebCore::TimelineTraceEventProcessor::sendTimelineRecord):

        (WebCore::TimelineTraceEventProcessor::processBackgroundEvents):

        * inspector/TimelineTraceEventProcessor.h: Added.

        (WebCore):

        (TimelineTraceEventProcessor):

        (TraceEvent):

        (WebCore::TimelineTraceEventProcessor::TraceEvent::TraceEvent):

        (WebCore::TimelineTraceEventProcessor::TraceEvent::timestamp):

        (WebCore::TimelineTraceEventProcessor::TraceEvent::phase):

        (WebCore::TimelineTraceEventProcessor::TraceEvent::name):

        (WebCore::TimelineTraceEventProcessor::TraceEvent::threadIdentifier):

        (WebCore::TimelineTraceEventProcessor::TraceEvent::argumentCount):

        (WebCore::TimelineTraceEventProcessor::TraceEvent::asBool):

        (WebCore::TimelineTraceEventProcessor::TraceEvent::asInt):

        (WebCore::TimelineTraceEventProcessor::TraceEvent::asUInt):

        (WebCore::TimelineTraceEventProcessor::TraceEvent::asDouble):

        (WebCore::TimelineTraceEventProcessor::TraceEvent::asString):

        (WebCore::TimelineTraceEventProcessor::EventTypeEntry::EventTypeEntry):

        (EventTypeEntry):

2013-02-04  Andrey Kosyakov  <caseq@chromium.org>

        Web Inspector: plumb trace events to Timeline agent

        https://bugs.webkit.org/show_bug.cgi?id=105796

        Reviewed by NOBODY (OOPS!).

        Plumb trace events to Inspector.

        * public/WebDevToolsAgentClient.h:

        (WebDevToolsAgentClient):

        (WebKit::WebDevToolsAgentClient::setTraceEventCallback):

        * src/InspectorClientImpl.cpp:

        (WebKit::InspectorClientImpl::setTraceEventCallback):

        (WebKit):

        * src/InspectorClientImpl.h:

        (InspectorClientImpl):

        * src/WebDevToolsAgentImpl.cpp:

        (WebKit::WebDevToolsAgentImpl::setTraceEventCallback):

        (WebKit):

        * src/WebDevToolsAgentImpl.h:

        (WebDevToolsAgentImpl):

    inspector/TimelineTraceEventProcessor.cpp

	Source/WebCore/inspector/TimelineTraceEventProcessor.cpp \

	Source/WebCore/inspector/TimelineTraceEventProcessor.h \

    inspector/TimelineTraceEventProcessor.cpp \

            'inspector/TimelineTraceEventProcessor.cpp',

            'inspector/TimelineTraceEventProcessor.h',

                        <File

                                RelativePath="..\inspector\TimelineTraceEventProcessor.cpp"

                                >

                                <FileConfiguration

                                        Name="Release|Win32"

                                        ExcludedFromBuild="true"

                                        >

                                        <Tool

                                                Name="VCCLCompilerTool"

                                        />

                                </FileConfiguration>

                                <FileConfiguration

                                        Name="Production|Win32"

                                        ExcludedFromBuild="true"

                                        >

                                        <Tool

                                                Name="VCCLCompilerTool"

                                        />

                                </FileConfiguration>

                        </File>

                        <File

                                RelativePath="..\inspector\TimelineTraceEventProcessor.h"

                                >

                        </File>

		49140256168E02E8002D6C6A /* TimelineTraceEventProcessor.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 49140254168E02B4002D6C6A /* TimelineTraceEventProcessor.cpp */; };

		49140257168E02EC002D6C6A /* TimelineTraceEventProcessor.h in Headers */ = {isa = PBXBuildFile; fileRef = 49140255168E02B4002D6C6A /* TimelineTraceEventProcessor.h */; };

		49140254168E02B4002D6C6A /* TimelineTraceEventProcessor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = TimelineTraceEventProcessor.cpp; sourceTree = "<group>"; };

		49140255168E02B4002D6C6A /* TimelineTraceEventProcessor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = TimelineTraceEventProcessor.h; sourceTree = "<group>"; };

				49140254168E02B4002D6C6A /* TimelineTraceEventProcessor.cpp */,

				49140255168E02B4002D6C6A /* TimelineTraceEventProcessor.h */,

				49140257168E02EC002D6C6A /* TimelineTraceEventProcessor.h in Headers */,

				49140256168E02E8002D6C6A /* TimelineTraceEventProcessor.cpp in Sources */,

#include "TimelineTraceEventProcessor.cpp"

    typedef void (*TraceEventCallback)(char phase, const unsigned char*, const char* name, unsigned long long id,

        int numArgs, const char* const* argNames, const unsigned char* argTypes, const unsigned long long* argValues,

        unsigned char flags);

    virtual void setTraceEventCallback(TraceEventCallback) { }

#include "TimelineTraceEventProcessor.h"

    if (m_client && m_pageAgent)

        m_traceEventProcessor = adoptRef(new TimelineTraceEventProcessor(m_weakFactory.createWeakPtr(), m_client));

    m_traceEventProcessor.clear();

    m_weakFactory.revokeAll();

    , m_weakFactory(this)

Page* InspectorTimelineAgent::page()

{

    return m_pageAgent ? m_pageAgent->page() : 0;

}

#include <wtf/WeakPtr.h>

class Page;

class TimelineTraceEventProcessor;

    friend class TimelineTraceEventProcessor;

    Page* page();

    WeakPtrFactory<InspectorTimelineAgent> m_weakFactory;

    RefPtr<TimelineTraceEventProcessor> m_traceEventProcessor;

/*

* Copyright (C) 2012 Google Inc. All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are

* met:

*

*     * Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

*     * Redistributions in binary form must reproduce the above

* copyright notice, this list of conditions and the following disclaimer

* in the documentation and/or other materials provided with the

* distribution.

*     * Neither the name of Google Inc. nor the names of its

* contributors may be used to endorse or promote products derived from

* this software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#include "config.h"

#if ENABLE(INSPECTOR)

#include "TimelineTraceEventProcessor.h"

#include "InspectorClient.h"

#include "InspectorInstrumentation.h"

#include "InspectorTimelineAgent.h"

#include "TimelineRecordFactory.h"

#include <wtf/CurrentTime.h>

#include <wtf/MainThread.h>

#include <wtf/ThreadSpecific.h>

#include <wtf/Vector.h>

namespace WebCore {

namespace {

class TraceEventDispatcher {

    WTF_MAKE_NONCOPYABLE(TraceEventDispatcher);

public:

    static TraceEventDispatcher* instance()

    {

        DEFINE_STATIC_LOCAL(TraceEventDispatcher, instance, ());

        return &instance;

    }

    void addProcessor(TimelineTraceEventProcessor* processor, InspectorClient* client)

    {

        MutexLocker locker(m_mutex);

        m_processors.append(processor);

        if (m_processors.size() == 1)

            client->setTraceEventCallback(dispatchEventOnAnyThread);

    }

    void removeProcessor(TimelineTraceEventProcessor* processor, InspectorClient* client)

    {

        MutexLocker locker(m_mutex);

        size_t index = m_processors.find(processor);

        if (index == notFound) {

            ASSERT_NOT_REACHED();

            return;

        }

        m_processors.remove(index);

        if (m_processors.isEmpty())

            client->setTraceEventCallback(0);

    }

private:

    enum { ProcessorsVectorInlineCapacity = 2 };

    TraceEventDispatcher() { }

    static void dispatchEventOnAnyThread(char phase, const unsigned char*, const char* name, unsigned long long id,

        int numArgs, const char* const* argNames, const unsigned char* argTypes, const unsigned long long* argValues,

        unsigned char flags)

    {

        TraceEventDispatcher* self = instance();

        Vector<RefPtr<TimelineTraceEventProcessor>, ProcessorsVectorInlineCapacity> processors;

        {

            MutexLocker locker(self->m_mutex);

            processors = self->m_processors;

        }

        for (int i = 0, size = processors.size(); i < size; ++i) {

            processors[i]->processEventOnAnyThread(static_cast<TimelineTraceEventProcessor::TraceEventPhase>(phase),

                name, id, numArgs, argNames, argTypes, argValues, flags);

        }

    }

    Mutex m_mutex;

    Vector<RefPtr<TimelineTraceEventProcessor>, ProcessorsVectorInlineCapacity> m_processors;

};

} // namespce

TimelineTraceEventProcessor::TimelineTraceEventProcessor(WeakPtr<InspectorTimelineAgent> timelineAgent, InspectorClient *client)

    : m_timelineAgent(timelineAgent)

    , m_inspectorClient(client)

    , m_pageId(reinterpret_cast<unsigned long long>(m_timelineAgent.get()->page()))

{

    TraceEventDispatcher::instance()->addProcessor(this, m_inspectorClient);

}

TimelineTraceEventProcessor::~TimelineTraceEventProcessor()

{

    TraceEventDispatcher::instance()->removeProcessor(this, m_inspectorClient);

}

const TimelineTraceEventProcessor::TraceValueUnion& TimelineTraceEventProcessor::TraceEvent::parameter(const char* name, TraceValueTypes expectedType) const

{

    const static TraceValueUnion missingValue;

    for (int i = 0; i < m_argumentCount; ++i) {

        if (!strcmp(name, m_argumentNames[i])) {

            if (m_argumentTypes[i] != expectedType) {

                ASSERT_NOT_REACHED();

                return missingValue;

            }

            return *reinterpret_cast<const TraceValueUnion*>(m_argumentValues + i);

        }

    }

    ASSERT_NOT_REACHED();

    return missingValue;

}

void TimelineTraceEventProcessor::processEventOnAnyThread(TraceEventPhase phase, const char* name, unsigned long long,

    int numArgs, const char* const* argNames, const unsigned char* argTypes, const unsigned long long* argValues,

    unsigned char)

{

    HashMap<String, EventTypeEntry>::iterator it = m_handlersByType.find(name);

    if (it == m_handlersByType.end())

        return;

    TraceEvent event(WTF::monotonicallyIncreasingTime(), phase, name, currentThread(), numArgs, argNames, argTypes, argValues);

    if (!isMainThread()) {

        MutexLocker locker(m_backgroundEventsMutex);

        m_backgroundEvents.append(event);

        return;

    }

    processEvent(it->value, event);

}

void TimelineTraceEventProcessor::processEvent(const EventTypeEntry& eventTypeEntry, const TraceEvent& event)

{

    ASSERT(isMainThread());

    TraceEventHandler handler = 0;

    switch (event.phase()) {

    case TracePhaseBegin:

        handler = eventTypeEntry.m_begin;

        break;

    case TracePhaseEnd:

        handler = eventTypeEntry.m_end;

        break;

    case TracePhaseInstant:

        handler = eventTypeEntry.m_instant;

        break;

    default:

        ASSERT_NOT_REACHED();

    }

    if (!handler) {

        ASSERT_NOT_REACHED();

        return;

    }

    (this->*handler)(event);

}

void TimelineTraceEventProcessor::sendTimelineRecord(PassRefPtr<InspectorObject> data, const String& recordType, double startTime, double endTime, const String& thread)

{

    ASSERT(isMainThread());

    InspectorTimelineAgent* timelineAgent = m_timelineAgent.get();

    if (!timelineAgent)

        return;

    timelineAgent->appendBackgroundThreadRecord(data, recordType, startTime, endTime, thread);

}

void TimelineTraceEventProcessor::processBackgroundEvents()

{

    ASSERT(isMainThread());

    Vector<TraceEvent> events;

    {

        MutexLocker locker(m_backgroundEventsMutex);

        events.reserveCapacity(m_backgroundEvents.capacity());

        m_backgroundEvents.swap(events);

    }

    for (size_t i = 0, size = events.size(); i < size; ++i) {

        const TraceEvent& event = events[i];

        processEvent(m_handlersByType.find(event.name())->value, event);

    }

}

} // namespace WebCore

#endif // ENABLE(INSPECTOR)

/*

* Copyright (C) 2012 Google Inc. All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are

* met:

*

*     * Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer.

*     * Redistributions in binary form must reproduce the above

* copyright notice, this list of conditions and the following disclaimer

* in the documentation and/or other materials provided with the

* distribution.

*     * Neither the name of Google Inc. nor the names of its

* contributors may be used to endorse or promote products derived from

* this software without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT

* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR

* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT

* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,

* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#ifndef TimelineTraceEventProcessor_h

#define TimelineTraceEventProcessor_h

#if ENABLE(INSPECTOR)

#include "InspectorValues.h"

#include <wtf/HashMap.h>

#include <wtf/HashSet.h>

#include <wtf/Noncopyable.h>

#include <wtf/Threading.h>

#include <wtf/Vector.h>

#include <wtf/WeakPtr.h>

#include <wtf/text/WTFString.h>

namespace WebCore {

class InspectorClient;

class InspectorTimelineAgent;

class Page;

class TimelineTraceEventProcessor : public ThreadSafeRefCounted<TimelineTraceEventProcessor> {

public:

    // FIXME: re-use definitions in TraceEvent.h once it's promoted to all platforms.

    enum TraceEventPhase {

        TracePhaseBegin = 'B',

        TracePhaseEnd = 'E',

        TracePhaseInstant = 'I'

    };

    TimelineTraceEventProcessor(WeakPtr<InspectorTimelineAgent>, InspectorClient*);

    ~TimelineTraceEventProcessor();

    void processEventOnAnyThread(TraceEventPhase, const char* name, unsigned long long id,

        int numArgs, const char* const* argNames, const unsigned char* argTypes, const unsigned long long* argValues,

        unsigned char flags);

private:

    // FIXME: use the definition in TraceEvent.h once we expose the latter to all plaforms.

    union TraceValueUnion {

        unsigned long long m_uint;

        long long m_int;

        double m_double;

        bool m_bool;

        const void* m_pointer;

        const char* m_string;

        TraceValueUnion() { }

    };

    enum TraceValueTypes {

        TypeBool = 1,

        TypeUInt = 2,

        TypeInt = 3,

        TypeDouble = 4,

        TypePointer = 5,

        TypeString = 6,

        TypeCopyString = 7

    };

    class TraceEvent {

    public:

        TraceEvent()

            : m_argumentCount(0)

        {

        }

        TraceEvent(double timestamp, TraceEventPhase phase, const char* name, ThreadIdentifier threadIdentifier,

            int argumentCount, const char* const* argumentNames, const unsigned char* argumentTypes, const unsigned long long* argumentValues)

            : m_timestamp(timestamp)

            , m_phase(phase)

            , m_name(name)

            , m_threadIdentifier(threadIdentifier)

            , m_argumentCount(argumentCount)

            , m_argumentNames(argumentNames)

            , m_argumentTypes(argumentTypes)

            , m_argumentValues(argumentValues)

        {

        }

        double timestamp() const { return m_timestamp; }

        TraceEventPhase phase() const { return m_phase; }

        const char* name() const { return m_name; }

        ThreadIdentifier threadIdentifier() const { return m_threadIdentifier; }

        int argumentCount() const { return m_argumentCount; }

        bool asBool(const char* name) const

        { 

            return parameter(name, TypeBool).m_bool;

        }

        long long asInt(const char* name) const

        { 

            return parameter(name, TypeInt).m_int;

        }

        unsigned long long asUInt(const char* name) const 

        { 

            return parameter(name, TypeUInt).m_uint;

        }

        double asDouble(const char* name) const

        { 

            return parameter(name, TypeDouble).m_double;

        }

        const char* asString(const char* name) const

        {

            return parameter(name, TypeString).m_string;

        }

    private:

        const TraceValueUnion& parameter(const char* name, TraceValueTypes expectedType) const;

        double m_timestamp;

        TraceEventPhase m_phase;

        const char* m_name;

        ThreadIdentifier m_threadIdentifier;

        int m_argumentCount;

        const char* const* m_argumentNames;

        const unsigned char* m_argumentTypes;

        const unsigned long long* m_argumentValues;

    };

    typedef void (TimelineTraceEventProcessor::*TraceEventHandler)(const TraceEvent&);

    struct EventTypeEntry {

        EventTypeEntry()

            : m_begin(0)

            , m_end(0)

            , m_instant(0)

        {

        }

        explicit EventTypeEntry(TraceEventHandler instant)

            : m_begin(0)

            , m_end(0)

            , m_instant(instant)

        {

        }

        EventTypeEntry(TraceEventHandler begin, TraceEventHandler end)

            : m_begin(begin)

            , m_end(end)

            , m_instant(0)

        {

        }

        TraceEventHandler m_begin;

        TraceEventHandler m_end;

        TraceEventHandler m_instant;

    };

    void processBackgroundEvents();

    void sendTimelineRecord(PassRefPtr<InspectorObject> data, const String& recordType, double startTime, double endTime, const String& thread);

    void processEvent(const EventTypeEntry&, const TraceEvent&);

    WeakPtr<InspectorTimelineAgent> m_timelineAgent;

    InspectorClient* m_inspectorClient;

    HashMap<String, EventTypeEntry> m_handlersByType;

    Mutex m_backgroundEventsMutex;

    Vector<TraceEvent> m_backgroundEvents;

    unsigned long long m_pageId;

};

} // namespace WebCore

#endif // ENABLE(INSPECTOR)

#endif // !defined(TimelineTraceEventProcessor_h)

    typedef void (*TraceEventCallback)(char phase, const unsigned char*, const char* name, unsigned long long id,

        int numArgs, const char* const* argNames, const unsigned char* argTypes, const unsigned long long* argValues,

        unsigned char flags);

    virtual void setTraceEventCallback(TraceEventCallback) { }

void InspectorClientImpl::setTraceEventCallback(TraceEventCallback callback)

{

    if (WebDevToolsAgentImpl* agent = devToolsAgent())

        agent->setTraceEventCallback(callback);

}

    virtual void setTraceEventCallback(TraceEventCallback);

void WebDevToolsAgentImpl::setTraceEventCallback(TraceEventCallback callback)

{

    m_client->setTraceEventCallback(callback);

}

    virtual void setTraceEventCallback(TraceEventCallback);