1 /*

     2  * Copyright (C) 2008, 2009 Google Inc. All rights reserved.

     3  *

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

     5  * modification, are permitted provided that the following conditions are

     6  * met:

     7  *

     8  *     * Redistributions of source code must retain the above copyright

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

    10  *     * Redistributions in binary form must reproduce the above

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

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

    13  * distribution.

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

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

    16  * this software without specific prior written permission.

    17  * 

    18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS

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

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

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

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

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

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

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

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

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

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

    29  */

    30 

    31 #ifndef ScriptState_h

    32 #define ScriptState_h

    33 

    34 #include "DOMWrapperWorld.h"

    35 #include <v8.h>

    36 #include <wtf/Noncopyable.h>

    37 #include <wtf/RefCounted.h>

    38 

    39 namespace WebCore {

    40 class DOMWrapperWorld;

    41 class Frame;

    42 class Node;

    43 class Page;

    44 

    45 class ScriptState : public Noncopyable {

    46 public:

    47     bool hadException() { return !m_exception.IsEmpty(); }

    48     void setException(v8::Local<v8::Value> exception)

    49     {

    50         m_exception = exception;

    51     }

    52     v8::Local<v8::Value> exception() { return m_exception; }

    53 

    54     v8::Local<v8::Context> context() const

    55     {

    56         return v8::Local<v8::Context>::New(m_context);

    57     }

    58 

    59     static ScriptState* forContext(v8::Local<v8::Context>);

    60     static ScriptState* current();

    61 

    62 protected:

    63     ScriptState() { }

    64     ~ScriptState();

    65 

    66 private:

    67     friend ScriptState* mainWorldScriptState(Frame*);

    68     explicit ScriptState(v8::Handle<v8::Context>);

    69 

    70     static void weakReferenceCallback(v8::Persistent<v8::Value> object, void* parameter);

    71 

    72     v8::Local<v8::Value> m_exception;

    73     v8::Persistent<v8::Context> m_context;

    74 };

    75 

    76 class EmptyScriptState : public ScriptState {

    77 public:

    78     EmptyScriptState() : ScriptState() { }

    79     ~EmptyScriptState() { }

    80 };

    81 

    82 class ScriptStateProtectedPtr : public Noncopyable {

    83 public:

    84     ScriptStateProtectedPtr() : m_scriptState(0) { }

    85     ScriptStateProtectedPtr(ScriptState* scriptState) : m_scriptState(scriptState)

    86     {

    87         v8::HandleScope handleScope;

    88         // Keep the context from being GC'ed. ScriptState is guaranteed to be live while the context is live.

    89         m_context = v8::Persistent<v8::Context>::New(scriptState->context());

    90     }

    91     ~ScriptStateProtectedPtr()

    92     {

    93         if (!m_context.IsEmpty()) {

    94             m_context.Dispose();

    95             m_context.Clear();

    96         }

    97     }

    98     ScriptState* get() { return m_scriptState; }

    99 private:

   100     ScriptState* m_scriptState;

   101     v8::Persistent<v8::Context> m_context;

   102 };

   103 

   104 ScriptState* mainWorldScriptState(Frame*);

   105 

   106 ScriptState* scriptStateFromNode(DOMWrapperWorld*, Node*);

   107 ScriptState* scriptStateFromPage(DOMWrapperWorld*, Page*);

   108 

   109 inline DOMWrapperWorld* debuggerWorld() { return mainThreadNormalWorld(); }

   110 inline DOMWrapperWorld* pluginWorld() { return mainThreadNormalWorld(); }

   111 

   112 }

   113 

   114 #endif // ScriptState_h