src/third_party/WebKit/Source/bindings/v8/V8StringResource.h

   1 /*
   2  * Copyright (C) 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
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
  14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
  17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  23  * THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #ifndef V8StringResource_h
  27 #define V8StringResource_h
  28
  29 #include <v8.h>
  30 #include "wtf/Threading.h"
  31 #include "wtf/text/AtomicString.h"
  32 #include "wtf/text/WTFString.h"
  33
  34 namespace WebCore {
  35
  36 class ExternalStringVisitor;
  37
  38 // WebCoreStringResource is a helper class for v8ExternalString. It is used
  39 // to manage the life-cycle of the underlying buffer of the external string.
  40 class WebCoreStringResourceBase {
  41 public:
  42     static WebCoreStringResourceBase* toWebCoreStringResourceBase(v8::Handle<v8::String>);
  43
  44     explicit WebCoreStringResourceBase(const String& string)
  45         : m_plainString(string)
  46     {
  47 #ifndef NDEBUG
  48         m_threadId = WTF::currentThread();
  49 #endif
  50         ASSERT(!string.isNull());
  51         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(memoryConsumption(string));
  52     }
  53
  54     explicit WebCoreStringResourceBase(const AtomicString& string)
  55         : m_plainString(string.string())
  56         , m_atomicString(string)
  57     {
  58 #ifndef NDEBUG
  59         m_threadId = WTF::currentThread();
  60 #endif
  61         ASSERT(!string.isNull());
  62         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(memoryConsumption(string));
  63     }
  64
  65     virtual ~WebCoreStringResourceBase()
  66     {
  67 #ifndef NDEBUG
  68         ASSERT(m_threadId == WTF::currentThread());
  69 #endif
  70         int reducedExternalMemory = -memoryConsumption(m_plainString);
  71         if (m_plainString.impl() != m_atomicString.impl() && !m_atomicString.isNull())
  72             reducedExternalMemory -= memoryConsumption(m_atomicString.string());
  73         v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(reducedExternalMemory);
  74     }
  75
  76     const String& webcoreString() { return m_plainString; }
  77
  78     const AtomicString& atomicString()
  79     {
  80 #ifndef NDEBUG
  81         ASSERT(m_threadId == WTF::currentThread());
  82 #endif
  83         if (m_atomicString.isNull()) {
  84             m_atomicString = AtomicString(m_plainString);
  85             ASSERT(!m_atomicString.isNull());
  86             if (m_plainString.impl() != m_atomicString.impl())
  87                 v8::Isolate::GetCurrent()->AdjustAmountOfExternalAllocatedMemory(memoryConsumption(m_atomicString.string()));
  88         }
  89         return m_atomicString;
  90     }
  91
  92     void visitStrings(ExternalStringVisitor*);
  93
  94 protected:
  95     // A shallow copy of the string. Keeps the string buffer alive until the V8 engine garbage collects it.
  96     String m_plainString;
  97     // If this string is atomic or has been made atomic earlier the
  98     // atomic string is held here. In the case where the string starts
  99     // off non-atomic and becomes atomic later it is necessary to keep
 100     // the original string alive because v8 may keep derived pointers
 101     // into that string.
 102     AtomicString m_atomicString;
 103
 104 private:
 105     static int memoryConsumption(const String& string)
 106     {
 107         return string.length() * (string.is8Bit() ? sizeof(LChar) : sizeof(UChar));
 108     }
 109 #ifndef NDEBUG
 110     WTF::ThreadIdentifier m_threadId;
 111 #endif
 112 };
 113
 114 class WebCoreStringResource16 FINAL : public WebCoreStringResourceBase, public v8::String::ExternalStringResource {
 115 public:
 116     explicit WebCoreStringResource16(const String& string)
 117         : WebCoreStringResourceBase(string)
 118     {
 119         ASSERT(!string.is8Bit());
 120     }
 121
 122     explicit WebCoreStringResource16(const AtomicString& string)
 123         : WebCoreStringResourceBase(string)
 124     {
 125         ASSERT(!string.is8Bit());
 126     }
 127
 128     virtual size_t length() const OVERRIDE { return m_plainString.impl()->length(); }
 129     virtual const uint16_t* data() const OVERRIDE
 130     {
 131         return reinterpret_cast<const uint16_t*>(m_plainString.impl()->characters16());
 132     }
 133 };
 134
 135 class WebCoreStringResource8 FINAL : public WebCoreStringResourceBase, public v8::String::ExternalAsciiStringResource {
 136 public:
 137     explicit WebCoreStringResource8(const String& string)
 138         : WebCoreStringResourceBase(string)
 139     {
 140         ASSERT(string.is8Bit());
 141     }
 142
 143     explicit WebCoreStringResource8(const AtomicString& string)
 144         : WebCoreStringResourceBase(string)
 145     {
 146         ASSERT(string.is8Bit());
 147     }
 148
 149     virtual size_t length() const OVERRIDE { return m_plainString.impl()->length(); }
 150     virtual const char* data() const OVERRIDE
 151     {
 152         return reinterpret_cast<const char*>(m_plainString.impl()->characters8());
 153     }
 154 };
 155
 156 enum ExternalMode {
 157     Externalize,
 158     DoNotExternalize
 159 };
 160
 161 template <typename StringType>
 162 StringType v8StringToWebCoreString(v8::Handle<v8::String>, ExternalMode);
 163 String int32ToWebCoreString(int value);
 164
 165 // V8StringResource is an adapter class that converts V8 values to Strings
 166 // or AtomicStrings as appropriate, using multiple typecast operators.
 167 enum V8StringResourceMode {
 168     DefaultMode,
 169     WithNullCheck,
 170     WithUndefinedOrNullCheck
 171 };
 172
 173 template <V8StringResourceMode Mode = DefaultMode>
 174 class V8StringResource {
 175 public:
 176     V8StringResource(v8::Handle<v8::Value> object)
 177         : m_v8Object(object)
 178         , m_mode(Externalize)
 179         , m_string()
 180     {
 181     }
 182
 183     bool prepare();
 184     operator String() const { return toString<String>(); }
 185     operator AtomicString() const { return toString<AtomicString>(); }
 186
 187 private:
 188     bool prepareBase()
 189     {
 190         if (m_v8Object.IsEmpty())
 191             return true;
 192
 193         if (LIKELY(m_v8Object->IsString()))
 194             return true;
 195
 196         if (LIKELY(m_v8Object->IsInt32())) {
 197             setString(int32ToWebCoreString(m_v8Object->Int32Value()));
 198             return true;
 199         }
 200
 201         m_mode = DoNotExternalize;
 202         v8::TryCatch block;
 203         m_v8Object = m_v8Object->ToString();
 204         // Handle the case where an exception is thrown as part of invoking toString on the object.
 205         if (block.HasCaught()) {
 206             block.ReThrow();
 207             return false;
 208         }
 209         return true;
 210     }
 211
 212     void setString(const String& string)
 213     {
 214         m_string = string;
 215         m_v8Object.Clear(); // To signal that String is ready.
 216     }
 217
 218     template <class StringType>
 219     StringType toString() const
 220     {
 221         if (LIKELY(!m_v8Object.IsEmpty()))
 222             return v8StringToWebCoreString<StringType>(const_cast<v8::Handle<v8::Value>*>(&m_v8Object)->As<v8::String>(), m_mode);
 223
 224         return StringType(m_string);
 225     }
 226
 227     v8::Handle<v8::Value> m_v8Object;
 228     ExternalMode m_mode;
 229     String m_string;
 230 };
 231
 232 template<> inline bool V8StringResource<DefaultMode>::prepare()
 233 {
 234     return prepareBase();
 235 }
 236
 237 template<> inline bool V8StringResource<WithNullCheck>::prepare()
 238 {
 239     if (m_v8Object.IsEmpty() || m_v8Object->IsNull()) {
 240         setString(String());
 241         return true;
 242     }
 243     return prepareBase();
 244 }
 245
 246 template<> inline bool V8StringResource<WithUndefinedOrNullCheck>::prepare()
 247 {
 248     if (m_v8Object.IsEmpty() || m_v8Object->IsNull() || m_v8Object->IsUndefined()) {
 249         setString(String());
 250         return true;
 251     }
 252     return prepareBase();
 253 }
 254
 255 } // namespace WebCore
 256
 257 #endif // V8StringResource_h