Move files in wtf/ to platform/wtf/ (Part 9).

third_party/WebKit/Source/wtf/text/StringView.h

-// Copyright 2016 The Chromium Authors. All rights reserved.
+// 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.
 
-#ifndef WTF_StringView_h
-#define WTF_StringView_h
+#include "platform/wtf/text/StringView.h"
 
-#include "wtf/Allocator.h"
-#include "wtf/GetPtr.h"
-#if DCHECK_IS_ON()
-#include "wtf/RefPtr.h"
-#endif
-#include "wtf/text/StringImpl.h"
-#include "wtf/text/Unicode.h"
-#include <cstring>
-
-namespace WTF {
-
-class AtomicString;
-class String;
-
-// A string like object that wraps either an 8bit or 16bit byte sequence
-// and keeps track of the length and the type, it does NOT own the bytes.
-//
-// Since StringView does not own the bytes creating a StringView from a String,
-// then calling clear() on the String will result in a use-after-free. Asserts
-// in ~StringView attempt to enforce this for most common cases.
-//
-// See base/strings/string_piece.h for more details.
-class WTF_EXPORT StringView {
-  DISALLOW_NEW_EXCEPT_PLACEMENT_NEW();
-
- public:
-  // Null string.
-  StringView() { clear(); }
-
-  // From a StringView:
-  StringView(const StringView&, unsigned offset, unsigned length);
-  StringView(const StringView& view, unsigned offset)
-      : StringView(view, offset, view.m_length - offset) {}
-
-  // From a StringImpl:
-  StringView(const StringImpl*);
-  StringView(const StringImpl*, unsigned offset);
-  StringView(const StringImpl*, unsigned offset, unsigned length);
-
-  // From a non-null StringImpl.
-  StringView(const StringImpl& impl)
-      : m_impl(const_cast<StringImpl*>(&impl)),
-        m_bytes(impl.bytes()),
-        m_length(impl.length()) {}
-
-  // From a non-null StringImpl, avoids the null check.
-  StringView(StringImpl& impl)
-      : m_impl(&impl), m_bytes(impl.bytes()), m_length(impl.length()) {}
-  StringView(StringImpl&, unsigned offset);
-  StringView(StringImpl&, unsigned offset, unsigned length);
-
-  // From an String, implemented in String.h
-  inline StringView(const String&, unsigned offset, unsigned length);
-  inline StringView(const String&, unsigned offset);
-  inline StringView(const String&);
-
-  // From an AtomicString, implemented in AtomicString.h
-  inline StringView(const AtomicString&, unsigned offset, unsigned length);
-  inline StringView(const AtomicString&, unsigned offset);
-  inline StringView(const AtomicString&);
-
-  // From a literal string or LChar buffer:
-  StringView(const LChar* chars, unsigned length)
-      : m_impl(StringImpl::empty), m_characters8(chars), m_length(length) {}
-  StringView(const char* chars, unsigned length)
-      : StringView(reinterpret_cast<const LChar*>(chars), length) {}
-  StringView(const LChar* chars)
-      : StringView(chars,
-                   chars ? strlen(reinterpret_cast<const char*>(chars)) : 0) {}
-  StringView(const char* chars)
-      : StringView(reinterpret_cast<const LChar*>(chars)) {}
-
-  // From a wide literal string or UChar buffer.
-  StringView(const UChar* chars, unsigned length)
-      : m_impl(StringImpl::empty16Bit),
-        m_characters16(chars),
-        m_length(length) {}
-  StringView(const UChar* chars);
-  StringView(const char16_t* chars)
-      : StringView(reinterpret_cast<const UChar*>(chars)) {}
-
-#if DCHECK_IS_ON()
-  ~StringView();
-#endif
-
-  bool isNull() const { return !m_bytes; }
-  bool isEmpty() const { return !m_length; }
-
-  unsigned length() const { return m_length; }
-
-  bool is8Bit() const {
-    DCHECK(m_impl);
-    return m_impl->is8Bit();
-  }
-
-  void clear();
-
-  UChar operator[](unsigned i) const {
-    SECURITY_DCHECK(i < length());
-    if (is8Bit())
-      return characters8()[i];
-    return characters16()[i];
-  }
-
-  const LChar* characters8() const {
-    DCHECK(is8Bit());
-    return m_characters8;
-  }
-
-  const UChar* characters16() const {
-    DCHECK(!is8Bit());
-    return m_characters16;
-  }
-
-  const void* bytes() const { return m_bytes; }
-
-  // This is not named impl() like String because it has different semantics.
-  // String::impl() is never null if String::isNull() is false. For StringView
-  // sharedImpl() can be null if the StringView was created with a non-zero
-  // offset, or a length that made it shorter than the underlying impl.
-  StringImpl* sharedImpl() const {
-    // If this StringView is backed by a StringImpl, and was constructed
-    // with a zero offset and the same length we can just access the impl
-    // directly since this == StringView(m_impl).
-    if (m_impl->bytes() == bytes() && m_length == m_impl->length())
-      return getPtr(m_impl);
-    return nullptr;
-  }
-
-  String toString() const;
-  AtomicString toAtomicString() const;
-
-  template <bool isSpecialCharacter(UChar)>
-  bool isAllSpecialCharacters() const;
-
- private:
-  void set(const StringImpl&, unsigned offset, unsigned length);
-
-// We use the StringImpl to mark for 8bit or 16bit, even for strings where
-// we were constructed from a char pointer. So m_impl->bytes() might have
-// nothing to do with this view's bytes().
-#if DCHECK_IS_ON()
-  RefPtr<StringImpl> m_impl;
-#else
-  StringImpl* m_impl;
-#endif
-  union {
-    const LChar* m_characters8;
-    const UChar* m_characters16;
-    const void* m_bytes;
-  };
-  unsigned m_length;
-};
-
-inline StringView::StringView(const StringView& view,
-                              unsigned offset,
-                              unsigned length)
-    : m_impl(view.m_impl), m_length(length) {
-  SECURITY_DCHECK(offset + length <= view.length());
-  if (is8Bit())
-    m_characters8 = view.characters8() + offset;
-  else
-    m_characters16 = view.characters16() + offset;
-}
-
-inline StringView::StringView(const StringImpl* impl) {
-  if (!impl) {
-    clear();
-    return;
-  }
-  m_impl = const_cast<StringImpl*>(impl);
-  m_length = impl->length();
-  m_bytes = impl->bytes();
-}
-
-inline StringView::StringView(const StringImpl* impl, unsigned offset) {
-  impl ? set(*impl, offset, impl->length() - offset) : clear();
-}
-
-inline StringView::StringView(const StringImpl* impl,
-                              unsigned offset,
-                              unsigned length) {
-  impl ? set(*impl, offset, length) : clear();
-}
-
-inline StringView::StringView(StringImpl& impl, unsigned offset) {
-  set(impl, offset, impl.length() - offset);
-}
-
-inline StringView::StringView(StringImpl& impl,
-                              unsigned offset,
-                              unsigned length) {
-  set(impl, offset, length);
-}
-
-inline void StringView::clear() {
-  m_length = 0;
-  m_bytes = nullptr;
-  m_impl = StringImpl::empty;  // mark as 8 bit.
-}
-
-inline void StringView::set(const StringImpl& impl,
-                            unsigned offset,
-                            unsigned length) {
-  SECURITY_DCHECK(offset + length <= impl.length());
-  m_length = length;
-  m_impl = const_cast<StringImpl*>(&impl);
-  if (impl.is8Bit())
-    m_characters8 = impl.characters8() + offset;
-  else
-    m_characters16 = impl.characters16() + offset;
-}
-
-// Unicode aware case insensitive string matching. Non-ASCII characters might
-// match to ASCII characters. These functions are rarely used to implement web
-// platform features.
-WTF_EXPORT bool equalIgnoringCase(const StringView&, const StringView&);
-WTF_EXPORT bool equalIgnoringCaseAndNullity(const StringView&,
-                                            const StringView&);
-
-WTF_EXPORT bool equalIgnoringASCIICase(const StringView&, const StringView&);
-
-// TODO(esprehn): Can't make this an overload of WTF::equal since that makes
-// calls to equal() that pass literal strings ambiguous. Figure out if we can
-// replace all the callers with equalStringView and then rename it to equal().
-WTF_EXPORT bool equalStringView(const StringView&, const StringView&);
-
-inline bool operator==(const StringView& a, const StringView& b) {
-  return equalStringView(a, b);
-}
-
-inline bool operator!=(const StringView& a, const StringView& b) {
-  return !(a == b);
-}
-
-template <bool isSpecialCharacter(UChar), typename CharacterType>
-inline bool isAllSpecialCharacters(const CharacterType* characters,
-                                   size_t length) {
-  for (size_t i = 0; i < length; ++i) {
-    if (!isSpecialCharacter(characters[i]))
-      return false;
-  }
-  return true;
-}
-
-template <bool isSpecialCharacter(UChar)>
-inline bool StringView::isAllSpecialCharacters() const {
-  size_t len = length();
-  if (!len)
-    return true;
-
-  return is8Bit() ? WTF::isAllSpecialCharacters<isSpecialCharacter, LChar>(
-                        characters8(), len)
-                  : WTF::isAllSpecialCharacters<isSpecialCharacter, UChar>(
-                        characters16(), len);
-}
-
-}  // namespace WTF
-
-using WTF::StringView;
-using WTF::equalIgnoringASCIICase;
-using WTF::equalIgnoringCase;
-using WTF::isAllSpecialCharacters;
-
-#endif
+// The contents of this header was moved to platform/wtf as part of
+// WTF migration project. See the following post for details:
+// https://groups.google.com/a/chromium.org/d/msg/blink-dev/tLdAZCTlcAA/bYXVT8gYCAAJ