Extract WebCoreStringResouce out of V8StringResource

third_party/WebKit/Source/bindings/core/v8/StringResource.cpp

-/*
- * Copyright (C) 2009 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:
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. 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.
- *
- * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS 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 APPLE INC. OR ITS 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.
- */
+// Copyright 2017 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 "bindings/core/v8/V8StringResource.h"
+#include "bindings/core/v8/StringResource.h"
 
 #include "bindings/core/v8/V8Binding.h"
 
 namespace blink {
 
 template <class StringClass>
 struct StringTraits {
-  static const StringClass& FromStringResource(WebCoreStringResourceBase*);
+  static const StringClass& FromStringResource(StringResourceBase*);
   template <typename V8StringTrait>
   static StringClass FromV8String(v8::Local<v8::String>, int);
 };
 
 template <>
 struct StringTraits<String> {
-  static const String& FromStringResource(WebCoreStringResourceBase* resource) {
+  static const String& FromStringResource(StringResourceBase* resource) {
     return resource->WebcoreString();
   }
   template <typename V8StringTrait>
   static String FromV8String(v8::Local<v8::String>, int);
 };
 
 template <>
 struct StringTraits<AtomicString> {
-  static const AtomicString& FromStringResource(
-      WebCoreStringResourceBase* resource) {
+  static const AtomicString& FromStringResource(StringResourceBase* resource) {
     return resource->GetAtomicString();
   }
   template <typename V8StringTrait>
   static AtomicString FromV8String(v8::Local<v8::String>, int);
 };
 
 struct V8StringTwoBytesTrait {
   typedef UChar CharType;
   ALWAYS_INLINE static void Write(v8::Local<v8::String> v8_string,
                                   CharType* buffer,
                                   int length) {
     v8_string->Write(reinterpret_cast<uint16_t*>(buffer), 0, length);
   }
 };
 
 struct V8StringOneByteTrait {
   typedef LChar CharType;
   ALWAYS_INLINE static void Write(v8::Local<v8::String> v8_string,
                                   CharType* buffer,
                                   int length) {
     v8_string->WriteOneByte(buffer, 0, length);
   }
 };
 
 template <typename V8StringTrait>
 String StringTraits<String>::FromV8String(v8::Local<v8::String> v8_string,
                                           int length) {
-  DCHECK_EQ(v8_string->Length(), length);
+  DCHECK(v8_string->Length() == length);
   typename V8StringTrait::CharType* buffer;
   String result = String::CreateUninitialized(length, buffer);
   V8StringTrait::Write(v8_string, buffer, length);
   return result;
 }
 
 template <typename V8StringTrait>
 AtomicString StringTraits<AtomicString>::FromV8String(
     v8::Local<v8::String> v8_string,
     int length) {
-  DCHECK_EQ(v8_string->Length(), length);
+  DCHECK(v8_string->Length() == length);
   static const int kInlineBufferSize =
       32 / sizeof(typename V8StringTrait::CharType);
   if (length <= kInlineBufferSize) {
     typename V8StringTrait::CharType inline_buffer[kInlineBufferSize];
     V8StringTrait::Write(v8_string, inline_buffer, length);
     return AtomicString(inline_buffer, length);
   }
   typename V8StringTrait::CharType* buffer;
   String string = String::CreateUninitialized(length, buffer);
   V8StringTrait::Write(v8_string, buffer, length);
   return AtomicString(string);
 }
 
 template <typename StringType>
 StringType V8StringToWebCoreString(v8::Local<v8::String> v8_string,
                                    ExternalMode external) {
   {
     // This portion of this function is very hot in certain Dromeao benchmarks.
     v8::String::Encoding encoding;
     v8::String::ExternalStringResourceBase* resource =
         v8_string->GetExternalStringResourceBase(&encoding);
     if (LIKELY(!!resource)) {
-      WebCoreStringResourceBase* base;
+      StringResourceBase* base;
       if (encoding == v8::String::ONE_BYTE_ENCODING)
-        base = static_cast<WebCoreStringResource8*>(resource);
+        base = static_cast<StringResource8*>(resource);
       else
-        base = static_cast<WebCoreStringResource16*>(resource);
+        base = static_cast<StringResource16*>(resource);
       return StringTraits<StringType>::FromStringResource(base);
     }
   }
 
   int length = v8_string->Length();
   if (UNLIKELY(!length))
     return StringType("");
 
   bool one_byte = v8_string->ContainsOnlyOneByte();
   StringType result(one_byte ? StringTraits<StringType>::template FromV8String<
                                    V8StringOneByteTrait>(v8_string, length)
                              : StringTraits<StringType>::template FromV8String<
                                    V8StringTwoBytesTrait>(v8_string, length));
 
   if (external != kExternalize || !v8_string->CanMakeExternal())
     return result;
 
   if (result.Is8Bit()) {
-    WebCoreStringResource8* string_resource =
-        new WebCoreStringResource8(result);
+    StringResource8* string_resource = new StringResource8(result);
     if (UNLIKELY(!v8_string->MakeExternal(string_resource)))
       delete string_resource;
   } else {
-    WebCoreStringResource16* string_resource =
-        new WebCoreStringResource16(result);
+    StringResource16* string_resource = new StringResource16(result);
     if (UNLIKELY(!v8_string->MakeExternal(string_resource)))
       delete string_resource;
   }
   return result;
 }
 
 // Explicitly instantiate the above template with the expected
 // parameterizations, to ensure the compiler generates the code; otherwise link
 // errors can result in GCC 4.4.
 template String V8StringToWebCoreString<String>(v8::Local<v8::String>,
@@ skipping 28 matching lines @@
 
 String Int32ToWebCoreString(int value) {
   // If we are on the main thread (this should always true for non-workers),
   // call the faster one.
   if (IsMainThread())
     return Int32ToWebCoreStringFast(value);
   return String::Number(value);
 }
 
 }  // namespace blink