Ticket #2127: scriptinterface_performance+style.patch

File scriptinterface_performance+style.patch, 10.2 KB (added by Jonas Platte, 11 years ago)

  • source/contributors.txt

     
    4545# Other contributors:
    4646
    4747André Puel
     48Jonas Platte <jonasplatte@myopera.com>
    4849Lars Kemmann
    4950Nick Owens <digitalseraphim@gmail.com>
    5051Quentin Pradet <quentin.pradet@gmail.com>

  • source/scriptinterface/DebuggingServer.cpp

     
    3333void CDebuggingServer::GetAllCallstacks(std::stringstream& response)
    3434{
    3535    CScopeLock lock(m_Mutex);
    36     response.str("");
     36    response.str(std::string());
    3737    std::stringstream stream;
    3838    uint nbrCallstacksWritten = 0;
    3939    std::list<CThreadDebugger*>::iterator itr;
    … …  
    4444        {
    4545            if ((*itr)->GetIsInBreak())
    4646            {
    47                 stream.str("");
    48                 std::string str = stream.str();
     47                stream.str(std::string());
    4948                (*itr)->GetCallstack(stream);
    50                 str = stream.str();
    51                 if (stream.str() != "")
     49                if ((int)stream.tellp() != 0)
    5250                {
    5351                    if (nbrCallstacksWritten != 0)
    5452                        response << ",";
    55                     response << "{" << "\"ThreadDebuggerID\" : " << (*itr)->GetID() << ", \"CallStack\" : " <<  stream.str() << "}";
     53                    response << "{" << "\"ThreadDebuggerID\" : " << (*itr)->GetID() << ", \"CallStack\" : " << stream << "}";
    5654                    nbrCallstacksWritten++;
    5755                }
    5856
    … …  
    6563void CDebuggingServer::GetStackFrameData(std::stringstream& response, uint nestingLevel, uint threadDebuggerID, STACK_INFO stackInfoKind)
    6664{
    6765    CScopeLock lock(m_Mutex);
    68     response.str("");
     66    response.str(std::string());
    6967    std::stringstream stream;
    7068    std::list<CThreadDebugger*>::iterator itr;
    7169    for (itr = m_ThreadDebuggers.begin(); itr != m_ThreadDebuggers.end(); ++itr)
    7270    {
    73         if ( (*itr)->GetID() == threadDebuggerID && (*itr)->GetIsInBreak())
     71        if ((*itr)->GetID() == threadDebuggerID && (*itr)->GetIsInBreak())
    7472        {
    7573            (*itr)->GetStackFrameData(stream, nestingLevel, stackInfoKind);
    76             if (stream.str() != "")
     74            if ((int)stream.tellp() != 0)
    7775            {
    78                 response <<  stream.str();
     76                response << stream;
    7977            }
    8078        }
    8179    }
    … …  
    114112    std::list<CThreadDebugger*>::iterator itr;
    115113    for (itr = m_ThreadDebuggers.begin(); itr != m_ThreadDebuggers.end(); ++itr)
    116114    {
    117         if ( (*itr)->GetID() == threadDebuggerID || threadDebuggerID == 0)
     115        if ((*itr)->GetID() == threadDebuggerID || threadDebuggerID == 0)
    118116        {
    119117            if (DBG_CMD_NONE == (*itr)->GetNextDbgCmd() && (*itr)->GetIsInBreak())
    120118            {
    … …  
    188186{
    189187    VfsPath path = L"";
    190188    VfsPaths pathnames;
    191     response.str("");
     189    response.str(std::string());
    192190   
    193191    std::vector<std::string> templates;
    194192    vfs::ForEachFile(g_VFS, "", AddFileResponse, (uintptr_t)&templates, L"*.js", vfs::DIR_RECURSIVE);
    … …  
    438436    int len = mg_get_var(request_info->query_string, strlen(request_info->query_string), argName.c_str(), buf, ARRAY_SIZE(buf));
    439437    if (len < 0)
    440438    {
    441             mg_printf(conn, "%s (no '%s')", header400, argName.c_str());
    442             return false;
     439        mg_printf(conn, "%s (no '%s')", header400, argName.c_str());
     440        return false;
    443441    }
    444442    arg = atoi(buf);
    445443    return true;
    … …  
    492490void CDebuggingServer::GetThreadDebuggerStatus(std::stringstream& response)
    493491{
    494492    CScopeLock lock(m_Mutex);
    495     response.str("");
     493    response.str(std::string());
    496494    std::list<CThreadDebugger*>::iterator itr;
    497495
    498496    response << "[";
    … …  
    529527    // If the breakpoint isn't handled yet search the breakpoints registered in this class
    530528    std::list<CBreakPoint>* pBreakPoints = NULL;
    531529    double breakPointsLockID = AquireBreakPointAccess(&pBreakPoints);
    532     std::list<CBreakPoint>::iterator itr;
    533530
    534531    // If set, delete
    535532    bool deleted = false;
    536     for (itr = pBreakPoints->begin(); itr != pBreakPoints->end(); ++itr)
     533    for (std::list<CBreakPoint>::iterator itr = pBreakPoints->begin(); itr != pBreakPoints->end(); ++itr)
    537534    {
    538535        if ((*itr).m_Filename == filename && (*itr).m_UserLine == line)
    539536        {
    … …  
    560557{
    561558    int ret;
    562559    ret = SDL_SemWait(m_BreakPointsSem);
    563     ENSURE(0 == ret);
     560    ENSURE(ret == 0);
    564561    (*breakPoints) = &m_BreakPoints;
    565562    m_BreakPointsLockID = timer_Time();
    566563    return m_BreakPointsLockID;

  • source/scriptinterface/ScriptInterface.cpp

     
    10921092        JS_ClearPendingException(m->m_cx);
    10931093        LOGERROR(L"StringifyJSON failed");
    10941094        JS_ClearPendingException(m->m_cx);
    1095         return "";
     1095        return std::string();
    10961096    }
    10971097
    10981098    return str.stream.str();

  • source/scriptinterface/ThreadDebugger.cpp

     
    168168    uint m_ID;
    169169};
    170170
    171 ThreadDebugger_impl::ThreadDebugger_impl() :
    172     m_NextDbgCmd(DBG_CMD_NONE), m_IsInBreak(false), m_pLastBreakFrame(new JSStackFrame*)
    173 {
    174 }
     171ThreadDebugger_impl::ThreadDebugger_impl()
     172    : m_NextDbgCmd(DBG_CMD_NONE)
     173    , m_pScriptInterface(NULL)
     174    , m_pDebuggingServer(NULL)
     175    , m_pLastBreakFrame(new JSStackFrame*)
     176    , m_IsInBreak(false)
     177{ }
    175178
    176179ThreadDebugger_impl::~ThreadDebugger_impl()
    177180{
    … …  
    188191    {
    189192        if ((*itr)->m_ToRemove)
    190193        {
    191                 ClearTrap((*itr));
    192                 // Remove the breakpoint
    193                 delete (*itr);
    194                 itr = m->m_ActiveBreakPoints.erase(itr);
    195 
     194            ClearTrap((*itr));
     195            // Remove the breakpoint
     196            delete (*itr);
     197            itr = m->m_ActiveBreakPoints.erase(itr);
    196198        }
    197199        else
    198200            ++itr;
    … …  
    527529    SetAllNewTraps();
    528530    SetNextDbgCmd(DBG_CMD_NONE);
    529531    SetIsInBreak(false);
    530     SetBreakFileName("");
     532    SetBreakFileName(std::string());
    531533   
    532534    // All saved stack data becomes invalid
    533535    {
    … …  
    542544{
    543545    uint scriptExtent = JS_GetScriptLineExtent (cx, script);
    544546    std::string stringFileName(filename);
    545     if (stringFileName == "")
     547    if (stringFileName.empty())
    546548        return;
    547549
    548550    for (uint line = lineno; line < scriptExtent + lineno; ++line)
    … …  
    648650   
    649651    JSStackFrame *fp;
    650652    JSStackFrame *iter = 0;
    651     std::string functionName;
    652653    jsint counter = 0;
    653654   
    654655    JSObject* jsArray;
    … …  
    676677        counter++;
    677678    }
    678679   
    679     m->m_Callstack = "";
     680    m->m_Callstack.clear();
    680681    m->m_Callstack = m->m_pScriptInterface->StringifyJSON(OBJECT_TO_JSVAL(jsArray), false).c_str();
    681682}
    682683
    … …  
    699700   
    700701    CScopeLock lock(m->m_Mutex);
    701702    {
    702         response.str("");
     703        response.str(std::string());
    703704        response << m->m_StackFrameData[stackInfoKind][nestingLevel];
    704705    }
    705706}
    … …  
    718719    ENSURE(GetIsInBreak());
    719720   
    720721    CScopeLock lock(m->m_Mutex);
    721     JSStackFrame *fp;
    722722    JSStackFrame *iter = 0;
    723723    uint counter = 0;
    724724    jsval val;
    … …  
    731731    }
    732732    else
    733733    {
    734         fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
     734        JSStackFrame *fp = JS_FrameIterator(m->m_pScriptInterface->GetContext(), &iter);
    735735        while (fp)
    736736        {
    737737            if (counter == nestingLevel)
    … …  
    766766 * Unfortunately this seems to require writing (or embedding) a new serializer to JSON or something similar.
    767767 *
    768768 * Some things about the implementation which aren't optimal:
    769  * 1. It uses globabl variables (they are limited to a namespace though)
     769 * 1. It uses global variables (they are limited to a namespace though).
    770770 * 2. It has to work around a bug in Spidermonkey.
    771771 * 3. It copies code from CScriptInterface. I did this to separate it cleanly because the debugger should not affect
    772772 *    the rest of the game and because this part of code should be replaced anyway in the future.
    773773 */
    774774 
    775  namespace CyclicRefWorkaround
    776  {
     775namespace CyclicRefWorkaround
     776{
    777777    std::set<JSObject*> g_ProcessedObjects;
    778778    jsval g_LastKey;
    779779    jsval g_LastValue;
    780780    bool g_RecursionDetectedInPrevReplacer = false;
    781781    uint g_countSameKeys = 0;
    782 
     782   
    783783    struct Stringifier
    784784    {
    785785        static JSBool callback(const jschar* buf, uint32 len, void* data)
    … …  
    794794
    795795        std::stringstream stream;
    796796    };
    797      
     797   
    798798    JSBool replacer(JSContext* cx, uintN UNUSED(argc), jsval* vp)
    799799    {
    800800        jsval value = JS_ARGV(cx, vp)[1];
    … …  
    830830        JS_SET_RVAL(cx, vp, JS_ARGV(cx, vp)[1]);
    831831        return JS_TRUE;
    832832    }
    833  }
    834  
     833}
     834
    835835std::string CThreadDebugger::StringifyCyclicJSON(jsval obj, bool indent)
    836836{
    837837    CyclicRefWorkaround::Stringifier str;
    … …  
    861861           
    862862        }           
    863863        JS_ClearPendingException(m->m_pScriptInterface->GetContext());
    864         return "";
     864        return std::string();
    865865    }
    866866
    867867    return str.stream.str();
    868868}
    869869
    870870
    871 bool CThreadDebugger::CompareScriptInterfacePtr(ScriptInterface* pScriptInterface)
     871bool CThreadDebugger::CompareScriptInterfacePtr(ScriptInterface* pScriptInterface) const
    872872{
    873873    return (pScriptInterface == m->m_pScriptInterface);
    874874}

  • source/scriptinterface/ThreadDebugger.h

     
    2727class CBreakPoint
    2828{
    2929public:
    30     CBreakPoint() { m_UserLine = 0; m_Filename = ""; }
     30    CBreakPoint() : m_UserLine(0) { }
     31   
    3132    uint m_UserLine;
    3233    std::string m_Filename;
    3334};
    … …  
    3637class CActiveBreakPoint : public CBreakPoint
    3738{
    3839public:
    39     CActiveBreakPoint() :
    40         CBreakPoint()
    41     {
    42         Initialize();
    43     }
     40    CActiveBreakPoint()
     41        : m_ActualLine(m_UserLine)
     42        , m_Script(NULL)
     43        , m_Pc(NULL)
     44        , m_ToRemove(false)
     45    { }
    4446
    4547    CActiveBreakPoint(CBreakPoint breakPoint)
    46     {
    47         m_Filename = breakPoint.m_Filename;
    48         m_UserLine = breakPoint.m_UserLine;
    49         Initialize();
    50     }
    51 
    52     void Initialize()
    53     {
    54         m_ToRemove = false;
    55         m_Script = NULL;
    56         m_Pc = NULL;
    57         m_ActualLine = m_UserLine;
    58     }
     48        : CBreakPoint(breakPoint) // using default copy constructor
     49        , m_ActualLine(m_UserLine)
     50        , m_Script(NULL)
     51        , m_Pc(NULL)
     52        , m_ToRemove(false)
     53    { }
    5954   
    6055    uint m_ActualLine;
    6156    JSScript* m_Script;
    … …  
    151146    /** @brief Compares the object's associated scriptinterface with the pointer passed as parameter.
    152147     * @return true if equal
    153148     */
    154     bool CompareScriptInterfacePtr(ScriptInterface* pScriptInterface);
     149    bool CompareScriptInterfacePtr(ScriptInterface* pScriptInterface) const;
    155150   
    156151    // Getter/Setters for members that need to be threadsafe
    157152    std::string GetBreakFileName();