commit d0f116b619feede0cfdb647157ce5ab4d50a1c46
author Adam Lesinski <adamlesinski@google.com> Fri Jul 08 15:00:32 2016 -0700
committer Adam Lesinski <adamlesinski@google.com> Wed Jul 13 17:45:28 2016 -0700
tree 5b2a8663602ba2b267890ff85d3cf5618ac922b5
parent aaac91f4a00a9968ef107ea143e6f2f669f762f1

AAPT2: Remove usage of u16string

For legacy reasons, we kept around the use of UTF-16 internally
in AAPT2. We don't need this and this CL removes all instances of
std::u16string and StringPiece16. The only places still needed
are when interacting with the ResTable APIs that only operate in
UTF16.

Change-Id: I492475b84bb9014fa13bf992cff447ee7a5fe588

tools/aapt2/StringPool.cpp

diff --git a/tools/aapt2/StringPool.cpp b/tools/aapt2/StringPool.cpp
index aadb00b..fe4b967 100644
--- a/tools/aapt2/StringPool.cpp
+++ b/tools/aapt2/StringPool.cpp
@@ -59,11 +59,11 @@
     return *this;
 }
 
-const std::u16string* StringPool::Ref::operator->() const {
+const std::string* StringPool::Ref::operator->() const {
     return &mEntry->value;
 }
 
-const std::u16string& StringPool::Ref::operator*() const {
+const std::string& StringPool::Ref::operator*() const {
     return mEntry->value;
 }
 
@@ -124,15 +124,15 @@
     return mEntry->str.getContext();
 }
 
-StringPool::Ref StringPool::makeRef(const StringPiece16& str) {
+StringPool::Ref StringPool::makeRef(const StringPiece& str) {
     return makeRefImpl(str, Context{}, true);
 }
 
-StringPool::Ref StringPool::makeRef(const StringPiece16& str, const Context& context) {
+StringPool::Ref StringPool::makeRef(const StringPiece& str, const Context& context) {
     return makeRefImpl(str, context, true);
 }
 
-StringPool::Ref StringPool::makeRefImpl(const StringPiece16& str, const Context& context,
+StringPool::Ref StringPool::makeRefImpl(const StringPiece& str, const Context& context,
         bool unique) {
     if (unique) {
         auto iter = mIndexedStrings.find(str);
@@ -147,7 +147,7 @@
     entry->index = mStrings.size();
     entry->ref = 0;
     mStrings.emplace_back(entry);
-    mIndexedStrings.insert(std::make_pair(StringPiece16(entry->value), entry));
+    mIndexedStrings.insert(std::make_pair(StringPiece(entry->value), entry));
     return Ref(entry);
 }
 
@@ -162,13 +162,12 @@
     entry->index = mStrings.size();
     entry->ref = 0;
     mStrings.emplace_back(entry);
-    mIndexedStrings.insert(std::make_pair(StringPiece16(entry->value), entry));
+    mIndexedStrings.insert(std::make_pair(StringPiece(entry->value), entry));
 
     StyleEntry* styleEntry = new StyleEntry();
     styleEntry->str = Ref(entry);
     for (const aapt::Span& span : str.spans) {
-        styleEntry->spans.emplace_back(Span{makeRef(span.name),
-                span.firstChar, span.lastChar});
+        styleEntry->spans.emplace_back(Span{ makeRef(span.name), span.firstChar, span.lastChar });
     }
     styleEntry->ref = 0;
     mStyles.emplace_back(styleEntry);
@@ -182,7 +181,7 @@
     entry->index = mStrings.size();
     entry->ref = 0;
     mStrings.emplace_back(entry);
-    mIndexedStrings.insert(std::make_pair(StringPiece16(entry->value), entry));
+    mIndexedStrings.insert(std::make_pair(StringPiece(entry->value), entry));
 
     StyleEntry* styleEntry = new StyleEntry();
     styleEntry->str = Ref(entry);
@@ -320,33 +319,40 @@
         indices++;
 
         if (utf8) {
-            std::string encoded = util::utf16ToUtf8(entry->value);
+            const std::string& encoded = entry->value;
+            const ssize_t utf16Length = utf8_to_utf16_length(
+                    reinterpret_cast<const uint8_t*>(entry->value.data()), entry->value.size());
+            assert(utf16Length >= 0);
 
-            const size_t totalSize = encodedLengthUnits<char>(entry->value.size())
+            const size_t totalSize = encodedLengthUnits<char>(utf16Length)
                     + encodedLengthUnits<char>(encoded.length())
                     + encoded.size() + 1;
 
             char* data = out->nextBlock<char>(totalSize);
 
-            // First encode the actual UTF16 string length.
-            data = encodeLength(data, entry->value.size());
+            // First encode the UTF16 string length.
+            data = encodeLength(data, utf16Length);
 
-            // Now encode the size of the converted UTF8 string.
+            // Now encode the size of the real UTF8 string.
             data = encodeLength(data, encoded.length());
             strncpy(data, encoded.data(), encoded.size());
+
         } else {
-            const size_t totalSize = encodedLengthUnits<char16_t>(entry->value.size())
-                    + entry->value.size() + 1;
+            const std::u16string encoded = util::utf8ToUtf16(entry->value);
+            const ssize_t utf16Length = encoded.size();
+
+            // Total number of 16-bit words to write.
+            const size_t totalSize = encodedLengthUnits<char16_t>(utf16Length) + encoded.size() + 1;
 
             char16_t* data = out->nextBlock<char16_t>(totalSize);
 
             // Encode the actual UTF16 string length.
-            data = encodeLength(data, entry->value.size());
-            const size_t byteLength = entry->value.size() * sizeof(char16_t);
+            data = encodeLength(data, utf16Length);
+            const size_t byteLength = encoded.size() * sizeof(char16_t);
 
             // NOTE: For some reason, strncpy16(data, entry->value.data(), entry->value.size())
             // truncates the string.
-            memcpy(data, entry->value.data(), byteLength);
+            memcpy(data, encoded.data(), byteLength);
 
             // The null-terminating character is already here due to the block of data being set
             // to 0s on allocation.