Removed the `GetStringRef()` functions of `StringExtractor`

[zturner]

Summary

The motivation here was that operations which were using the const version of this function might as well be using Peek(), since it does essentially the same thing. And since Peek() was updated to return StringRef, it even provides a more useful interface than std::string.

On the other hand, operations which were using the non const version of the function won't work in an environment where StringExtractor stores a StringRef instead of a std::string, and on top of that they are unsafe since modifying the StringExtractor by exposing its internals breaks encapsulation and requires the user to remember to update the file pos lest the class enter an invalid state.

So I add a new SetString() method. Instead of calling GetStringRef() and then manipulating the result, you just manipulate a std::string you create yourself, and then call SetString().

Because calls to the const version of GetStringRef() are changed to using Peek(), certain functions that were reproducing functionality already built in to StringRef have been simplified quite a bit.

[zturner]

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

1677

Also, was this a bug? I fixed it because it certainly looks like a bug, but if this is intended behavior please let me know.

[zturner]

Actually fix the bug this time instead of making worse.

[labath]

Which revision is this patch against? It does not seem to apply cleanly to trunk for me. Could you try running the test suite on linux or mac as well, as the last StringRef change left things in a pretty broken state there (you are changing code which is pretty-much unused on windows)? If not I can give it a shot once it the merge issues are resolved.

Apart from that, I like the direction this is going in.

unittests/Utility/StringExtractorTest.cpp

76

This seems unnecessary.

[zturner]

Rebased after submitting all local changes. This should apply cleanly on top of LLDB r280139.

[zturner]

Fixed a few build errors on Linux. Test suite is running right now, but it's taking a long time so it may be hung (on the other hand, I actually don't remember the last time I had a successful test run on Linux, even without any of my patches).

[labath]

It is hung because one of your previous changes broke a very fundamental piece of functionality, which makes all tests fail. It is fixed now http://lab.llvm.org:8011/builders/lldb-x86_64-ubuntu-14.04-cmake and the tests are passing on our buildbot in a very stable manner.

I request that you stop making these changes, until we figure out how to make sure they can go in safely.

• first, I'd like to wait with the changes until after the reformat. The reason for this is that the reformat will make tracking breakages and/or reverting much more difficult. I'm not disputing the need for doing this, but I do believe it can wait one more week.
• second, I'd like to have these changes tested more before or immediately after they go in. The StringExtractor is much more heavily used on OSX/Linux than it is on windows, so I don't think running lldb windows host tests is enough. Now, there is nothing host-specific in the string extractor and in an ideal world we would have enough unit tests to make sure a refactor is not breaking things, but we are not there yet, and until we get there, I think you'll need to be more careful about refactoring random stuff.

You said the test suite was not working for you yesterday. Could you check it again today? It works fine on the buildbot now. Last time I remember we spoke about this, the problem was two tests being too slow. Both of these issues should be resolved now, and if there is still something wrong, I am ready to work with you to resolve them. This should enable you to have more confidence into the more risky changes. For the less risky ones, you should be able to rely on the buildbot to do post-submit verification. I'll get the buildbot set up to send out emails when tests break. I think it is very stable now, and I think I've been putting of that task for long enough. Please look out for emails from it and try to resolve problems it detects, particularly when making chained changes like yesterday. The turnaround time should be very fast now (12 minutes). I'd like to avoid situations where I have to scramble to put things back in a working state, like I had to for the past two mornings.

Again, I am not trying do stop you from doing this, as I agree that it needs to be done. I'd like to just make sure it is done in a sustainable manner.

[labath]

The reformat is complete, and our main buildbot is (as I think you've already found out) in the non-experimental mode. As far as I am concerned, we can proceed with this. If you can't test on linux before hand, just look out for the emails and be ready to respond. If there's anything I can do to make this process easier (figure out why the linux test suite is not working on your side?), let me know.

include/lldb/Core/Event.h

 // Other libraries and framework includes
 // Project includes
 #include "lldb/lldb-private.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/StructuredData.h"
 #include "lldb/Host/Predicate.h"
 #include "lldb/Core/Broadcaster.h"
 
+#include "llvm/ADT/StringRef.h"
+
 namespace lldb_private {
 
 //----------------------------------------------------------------------
 // lldb::EventData
 //----------------------------------------------------------------------
 class EventData
 {
     friend class Event;

 class EventDataBytes : public EventData
 {
 public:
     //------------------------------------------------------------------
     // Constructors
     //------------------------------------------------------------------
     EventDataBytes ();
 
+    EventDataBytes::EventDataBytes(llvm::StringRef str);
+
     EventDataBytes (const char *cstr);
 
     EventDataBytes (const void *src, size_t src_len);
 
     ~EventDataBytes() override;
 
     //------------------------------------------------------------------
     // Member functions

include/lldb/Core/RegularExpression.h

 //===-- RegularExpression.h -------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_RegularExpression_h_
 #define liblldb_RegularExpression_h_
 
 #ifdef _WIN32
+// TODO: We should not be including LLDB private headers.
 #include "../lib/Support/regex_impl.h"
 
 typedef llvm_regmatch_t regmatch_t;
 typedef llvm_regex_t regex_t;
 
 inline int regcomp(llvm_regex_t * a, const char *b, int c)
 {
     return llvm_regcomp(a, b, c);

include/lldb/Utility/StringExtractor.h

public:
 
     //------------------------------------------------------------------
     // Operators
     //------------------------------------------------------------------
     const StringExtractor&
     operator=(const StringExtractor& rhs);
 
     void
+    Reset()
+    {
+        m_packet.clear();
+        m_index = 0;
+    }
+
+    void
     Reset(llvm::StringRef str)
     {
         m_packet = str;
         m_index = 0;
     }
 
     // Returns true if the file position is still valid for the data
     // contained in this string extractor object.
public:
     {
         m_packet.clear();
         m_index = 0;
     }
 
     void
     SkipSpaces ();
 
-    std::string &
-    GetStringRef ()
-    {
-        return m_packet;
-    }
-
-    const std::string &
-    GetStringRef () const
+    void
+    SetString(llvm::StringRef str)
     {
-        return m_packet;
+        m_packet = str;
+        m_index = 0;
     }
 
     bool
     Empty()
     {
         return m_packet.empty();
     }
 
     size_t
-    GetBytesLeft ()
+    GetTotalBytes() const
+    {
+        return m_packet.size();
+    }
+
+    size_t
+    GetBytesLeft() const
     {
         if (m_index < m_packet.size())
             return m_packet.size() - m_index;
         return 0;
     }
 
+    bool
+    Consume(llvm::StringRef Str);
+
     char
     GetChar (char fail_value = '\0');
 
     char
-    PeekChar (char fail_value = '\0')
+    PeekChar(char fail_value = '\0') const
     {
         llvm::StringRef str = Peek();
         if (str.empty())
             return fail_value;
         return str[0];
     }
 
     int
public:
     llvm::StringRef
     Peek() const
     {
         if (!IsGood())
             return llvm::StringRef();
         return llvm::StringRef(m_packet).drop_front(m_index);
     }
 
+    llvm::StringRef
+    PeekFullPacket() const
+    {
+        return m_packet;
+    }
+
 protected:
     bool
     fail()
     {
         m_index = UINT64_MAX;
         return false;
     }
     //------------------------------------------------------------------

source/Core/Event.cpp

 //------------------------------------------------------------------
 
 
 EventDataBytes::EventDataBytes () :
     m_bytes()
 {
 }
 
+EventDataBytes::EventDataBytes(llvm::StringRef str) : m_bytes()
+{
+    SetBytes(str.data(), str.size());
+}
+
 EventDataBytes::EventDataBytes (const char *cstr) :
     m_bytes()
 {
     SetBytesFromCString (cstr);
 }
 
 EventDataBytes::EventDataBytes (const void *src, size_t src_len) :
     m_bytes()

source/Plugins/Platform/gdb-server/PlatformRemoteGDBServer.cpp

PlatformRemoteGDBServer::GetRemoteUnixSignals()
     StringExtractorGDBRemote response;
     auto result = m_gdb_client.SendPacketAndWaitForResponse(
             packet, strlen(packet), response, false);
 
     if (result != decltype(result)::Success ||
             response.GetResponseType() != response.eResponse)
         return m_remote_signals_sp;
 
-    auto object_sp = StructuredData::ParseJSON(response.GetStringRef());
+    auto object_sp = StructuredData::ParseJSON(response.Peek());
     if (!object_sp || !object_sp->IsValid())
         return m_remote_signals_sp;
 
     auto array_sp = object_sp->GetAsArray();
     if (!array_sp || !array_sp->IsValid())
         return m_remote_signals_sp;
 
     auto remote_signals_sp = std::make_shared<lldb_private::GDBRemoteSignals>();

source/Plugins/Process/Utility/DynamicRegisterInfo.cpp

for (uint32_t i = 0; i < num_regs; ++i)
         std::string dwarf_opcode_string;
         if (reg_info_dict->GetValueForKeyAsString ("dynamic_size_dwarf_expr_bytes", dwarf_opcode_string))
         {
             reg_info.dynamic_size_dwarf_len = dwarf_opcode_string.length () / 2;
             assert (reg_info.dynamic_size_dwarf_len > 0);
 
             std::vector<uint8_t> dwarf_opcode_bytes(reg_info.dynamic_size_dwarf_len);
             uint32_t j;
-            StringExtractor opcode_extractor;
-            // Swap "dwarf_opcode_string" over into "opcode_extractor"
-            opcode_extractor.GetStringRef ().swap (dwarf_opcode_string);
+            StringExtractor opcode_extractor(dwarf_opcode_string);
             uint32_t ret_val = opcode_extractor.GetHexBytesAvail (dwarf_opcode_bytes);
             assert (ret_val == reg_info.dynamic_size_dwarf_len);
 
             for (j = 0; j < reg_info.dynamic_size_dwarf_len; ++j)
                 m_dynamic_reg_size_map[i].push_back(dwarf_opcode_bytes[j]);
 
             reg_info.dynamic_size_dwarf_expr_bytes = m_dynamic_reg_size_map[i].data ();
         }

source/Plugins/Process/gdb-remote/GDBRemoteClientBase.cpp

for (;;)
                     log->Printf("GDBRemoteClientBase::%s () ReadPacket(...) => false", __FUNCTION__);
                 return eStateInvalid;
         }
         if (response.Empty())
             return eStateInvalid;
 
         const char stop_type = response.GetChar();
         if (log)
-            log->Printf("GDBRemoteClientBase::%s () got packet: %s", __FUNCTION__, response.GetStringRef().c_str());
+            log->Printf("GDBRemoteClientBase::%s () got packet: %s", __FUNCTION__,
+                        response.PeekFullPacket().str().c_str());
 
         switch (stop_type)
         {
             case 'W':
             case 'X':
                 return eStateExited;
             case 'E':
                 // ERROR
                 return eStateInvalid;
             default:
                 if (log)
                     log->Printf("GDBRemoteClientBase::%s () unrecognized async packet", __FUNCTION__);
                 return eStateInvalid;
             case 'O':
             {
                 std::string inferior_stdout;
                 response.GetHexByteString(inferior_stdout);
                 delegate.HandleAsyncStdout(inferior_stdout);
                 break;
             }
             case 'A':
-                delegate.HandleAsyncMisc(llvm::StringRef(response.GetStringRef()).substr(1));
+                delegate.HandleAsyncMisc(response.Peek().drop_front());
                 break;
 
             case 'J':
+            {
                 // Asynchronous JSON packet, destined for a
                 // StructuredDataPlugin.
+
+                StructuredData::ObjectSP json_sp;
+                llvm::StringRef json_text;
+                // The 'J' was already consumed.
+                if (response.Consume("SON-async:"))
                 {
                     // Parse the content into a StructuredData instance.
-                auto payload_index = strlen("JSON-async:");
-                StructuredData::ObjectSP json_sp =
-                    StructuredData::ParseJSON(response.GetStringRef()
-                                              .substr(payload_index));
+                    json_sp = StructuredData::ParseJSON(json_text = response.Peek());
+                }
+
                 if (log)
                 {
                     if (json_sp)
-                        log->Printf(
-                                    "GDBRemoteCommmunicationClientBase::%s() "
+                        log->Printf("GDBRemoteCommmunicationClientBase::%s() "
                                     "received Async StructuredData packet: %s",
-                                    __FUNCTION__,
-                                    response.GetStringRef().
-                                    substr(payload_index).c_str());
+                                    __FUNCTION__, json_text.str().c_str());
                     else
                         log->Printf("GDBRemoteCommmunicationClientBase::%s"
                                     "() received StructuredData packet:"
                                     " parse failure", __FUNCTION__);
                 }
 
                 // Pass the data to the process to route to the
                 // appropriate plugin.  The plugin controls what happens
for (size_t i = 0; i < max_response_retries; ++i)
             return packet_result;
         // Make sure our response is valid for the payload that was sent
         if (response.ValidateResponse())
             return packet_result;
         // Response says it wasn't valid
         Log *log = ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PACKETS);
         if (log)
             log->Printf("error: packet with payload \"%.*s\" got invalid response \"%s\": %s", int(payload.size()),
-                        payload.data(), response.GetStringRef().c_str(),
+                        payload.data(), response.Peek().str().c_str(),
                         (i == (max_response_retries - 1)) ? "using invalid response and giving up"
                                                           : "ignoring response and waiting for another");
     }
     return packet_result;
 }
 
 bool
 GDBRemoteClientBase::SendvContPacket(llvm::StringRef payload, StringExtractorGDBRemote &response)

source/Plugins/Process/gdb-remote/GDBRemoteCommunication.cpp

while (IsConnected() && !timed_out)
                         uint32_t successful_responses = 0;
                         for (uint32_t i=0; i<max_retries; ++i)
                         {
                             StringExtractorGDBRemote echo_response;
                             echo_packet_result = WaitForPacketWithTimeoutMicroSecondsNoLock (echo_response, timeout_usec, false);
                             if (echo_packet_result == PacketResult::Success)
                             {
                                 ++successful_responses;
-                                if (response_regex.Execute(echo_response.GetStringRef().c_str()))
+                                if (response_regex.Execute(echo_response.Peek().str().c_str()))
                                 {
                                     sync_success = true;
                                     break;
                                 }
                                 else if (successful_responses == 1)
                                 {
                                     // We got something else back as the first successful response, it probably is
                                     // the  response to the packet we actually wanted, so copy it over if this
if (!m_bytes.empty())
 
             // We have a valid packet...
             assert (content_length <= m_bytes.size());
             assert (total_length <= m_bytes.size());
             assert (content_length <= total_length);
             size_t content_end = content_start + content_length;
 
             bool success = true;
-            std::string &packet_str = packet.GetStringRef();
             if (log)
             {
                 // If logging was just enabled and we have history, then dump out what
                 // we have to the log so we get the historical context. The Dump() call that
                 // logs all of the packet will set a boolean so that we don't dump this more
                 // than once
                 if (!m_history.DidDumpToLog ())
                     m_history.Dump (log);
if (!m_bytes.empty())
                         log->Printf("<%4" PRIu64 ":%" PRIu64 "> read packet: %.*s", (uint64_t) original_packet_size, (uint64_t)total_length, (int)(total_length), m_bytes.c_str());
                     else
                         log->Printf("<%4" PRIu64 "> read packet: %.*s", (uint64_t)total_length, (int)(total_length), m_bytes.c_str());
                 }
             }
 
             m_history.AddPacket (m_bytes.c_str(), total_length, History::ePacketTypeRecv, total_length);
 
-            // Clear packet_str in case there is some existing data in it.
-            packet_str.clear();
+            std::string packet_str;
             // Copy the packet from m_bytes to packet_str expanding the
             // run-length encoding in the process.
             // Reserve enough byte for the most common case (no RLE used)
             packet_str.reserve(m_bytes.length());
             for (std::string::const_iterator c = m_bytes.begin() + content_start; c != m_bytes.begin() + content_end; ++c)
             {
                 if (*c == '*')
                 {
if (!m_bytes.empty())
                 }
                 else
                 {
                     success = false;
                     if (log)
                         log->Printf ("error: invalid checksum in packet: '%s'\n", m_bytes.c_str());
                 }
             }
-            
             m_bytes.erase(0, total_length);
-            packet.SetFilePos(0);
+            packet.SetString(packet_str);
 
             if (isNotifyPacket)
                 return GDBRemoteCommunication::PacketType::Notify;
             else
                 return GDBRemoteCommunication::PacketType::Standard;
         }
     }
     packet.Clear();
while (true)
                 m_packet_queue.push(packet);
                 // Signal condition variable that we have a packet
                 m_condition_queue_not_empty.notify_one();
             }
         }
 
         if (type == PacketType::Notify)
         {
-            // put this packet into an event
-            const char *pdata = packet.GetStringRef().c_str();
-
             // as the communication class, we are a broadcaster and the
             // async thread is tuned to listen to us
-            BroadcastEvent(
-                eBroadcastBitGdbReadThreadGotNotify,
-                new EventDataBytes(pdata));
+            BroadcastEvent(eBroadcastBitGdbReadThreadGotNotify, new EventDataBytes(packet.Peek()));
         }
     }
 }

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.h

protected:
     GetCurrentProcessInfo (bool allow_lazy_pid = true);
 
     bool
     GetGDBServerVersion();
 
     // Given the list of compression types that the remote debug stub can support,
     // possibly enable compression if we find an encoding we can handle.
     void
-    MaybeEnableCompression (std::vector<std::string> supported_compressions);
+    MaybeEnableCompression(std::vector<llvm::StringRef> supported_compressions);
 
     bool
     DecodeProcessInfoResponse (StringExtractorGDBRemote &response, 
                                ProcessInstanceInfo &process_info);
 
     void
     OnRunPacketSent(bool first) override;
 

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationClient.cpp

 
 // Project includes
 #include "Utility/StringExtractorGDBRemote.h"
 #include "ProcessGDBRemote.h"
 #include "ProcessGDBRemoteLog.h"
 #include "lldb/Host/Config.h"
 
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/Support/raw_ostream.h"
 
 #if defined (HAVE_LIBCOMPRESSION)
 #include <compression.h>
 #endif
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::process_gdb_remote;
GDBRemoteCommunicationClient::GetRemoteQSupported ()
     packet.PutCString( "qSupported" );
     for ( uint32_t i = 0; i < features.size( ); ++i )
     {
         packet.PutCString( i==0 ? ":" : ";");
         packet.PutCString( features[i].c_str( ) );
     }
 
     StringExtractorGDBRemote response;
-    if (SendPacketAndWaitForResponse(packet.GetData(),
-                                     response,
+    if (SendPacketAndWaitForResponse(packet.GetData(), response,
                                      /*send_async=*/false) == PacketResult::Success)
     {
-        const char *response_cstr = response.GetStringRef().c_str();
+        llvm::StringRef response_str = response.Peek();
 
         // Hang on to the qSupported packet, so that platforms can do custom
         // configuration of the transport before attaching/launching the
         // process.
-        m_qSupported_response = response_cstr;
+        m_qSupported_response = response_str;
 
-        if (::strstr (response_cstr, "qXfer:auxv:read+"))
+        if (response_str.contains("qXfer:auxv:read+"))
             m_supports_qXfer_auxv_read = eLazyBoolYes;
-        if (::strstr (response_cstr, "qXfer:libraries-svr4:read+"))
+        if (response_str.contains("qXfer:libraries-svr4:read+"))
             m_supports_qXfer_libraries_svr4_read = eLazyBoolYes;
-        if (::strstr (response_cstr, "augmented-libraries-svr4-read"))
+        if (response_str.contains("augmented-libraries-svr4-read"))
         {
             m_supports_qXfer_libraries_svr4_read = eLazyBoolYes;  // implied
             m_supports_augmented_libraries_svr4_read = eLazyBoolYes;
         }
-        if (::strstr (response_cstr, "qXfer:libraries:read+"))
+        if (response_str.contains("qXfer:libraries:read+"))
             m_supports_qXfer_libraries_read = eLazyBoolYes;
-        if (::strstr (response_cstr, "qXfer:features:read+"))
+        if (response_str.contains("qXfer:features:read+"))
             m_supports_qXfer_features_read = eLazyBoolYes;
 
 
         // Look for a list of compressions in the features list e.g.
         // qXfer:features:read+;PacketSize=20000;qEcho+;SupportedCompressions=zlib-deflate,lzma
-        const char *features_list = ::strstr (response_cstr, "qXfer:features:");
-        if (features_list)
+        llvm::StringRef compressions =
+            response_str.scan_between("qXfer:features:", "").scan_between("SupportedCompressions=", ";");
+        std::vector<llvm::StringRef> supported_compressions;
+        while (!compressions.empty())
         {
-            const char *compressions = ::strstr (features_list, "SupportedCompressions=");
-            if (compressions)
-            {
-                std::vector<std::string> supported_compressions;
-                compressions += sizeof ("SupportedCompressions=") - 1;
-                const char *end_of_compressions = strchr (compressions, ';');
-                if (end_of_compressions == NULL)
-                {
-                    end_of_compressions = strchr (compressions, '\0');
-                }
-                const char *current_compression = compressions;
-                while (current_compression < end_of_compressions)
-                {
-                    const char *next_compression_name = strchr (current_compression, ',');
-                    const char *end_of_this_word = next_compression_name;
-                    if (next_compression_name == NULL || end_of_compressions < next_compression_name)
-                    {
-                        end_of_this_word = end_of_compressions;
-                    }
-
-                    if (end_of_this_word)
-                    {
-                        if (end_of_this_word == current_compression)
-                        {
-                            current_compression++;
-                        }
-                        else
-                        {
-                            std::string this_compression (current_compression, end_of_this_word - current_compression);
-                            supported_compressions.push_back (this_compression);
-                            current_compression = end_of_this_word + 1;
-                        }
-                    }
-                    else
-                    {
-                        supported_compressions.push_back (current_compression);
-                        current_compression = end_of_compressions;
-                    }
-                }
+            llvm::StringRef this_compression;
+            std::tie(this_compression, compressions) = compressions.split(',');
+            supported_compressions.push_back(this_compression);
 
-                if (supported_compressions.size() > 0)
-                {
-                    MaybeEnableCompression (supported_compressions);
-                }
-            }
-        }
+        if (!supported_compressions.empty())
+            MaybeEnableCompression(supported_compressions);
 
-        if (::strstr (response_cstr, "qEcho"))
+        if (response_str.contains("qEcho"))
             m_supports_qEcho = eLazyBoolYes;
         else
             m_supports_qEcho = eLazyBoolNo;
 
-        const char *packet_size_str = ::strstr (response_cstr, "PacketSize=");
-        if (packet_size_str)
+        llvm::StringRef packet_size_str = response_str.scan_between("PacketSize=", "");
+        if (!packet_size_str.empty())
         {
-            StringExtractorGDBRemote packet_response(packet_size_str + strlen("PacketSize="));
+            StringExtractorGDBRemote packet_response(packet_size_str);
             m_max_packet_size = packet_response.GetHexMaxU64(/*little_endian=*/false, UINT64_MAX);
             if (m_max_packet_size == 0)
             {
                 m_max_packet_size = UINT64_MAX;  // Must have been a garbled response
                 Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet (GDBR_LOG_PROCESS));
                 if (log)
                     log->Printf ("Garbled PacketSize spec in qSupported response");
             }
if (m_supports_vCont_c == eLazyBoolCalculate)
         m_supports_vCont_any = eLazyBoolNo;
         m_supports_vCont_all = eLazyBoolNo;
         m_supports_vCont_c = eLazyBoolNo;
         m_supports_vCont_C = eLazyBoolNo;
         m_supports_vCont_s = eLazyBoolNo;
         m_supports_vCont_S = eLazyBoolNo;
         if (SendPacketAndWaitForResponse("vCont?", response, false) == PacketResult::Success)
         {
-            const char *response_cstr = response.GetStringRef().c_str();
-            if (::strstr (response_cstr, ";c"))
+            llvm::StringRef response_str = response.Peek();
+            if (response_str.contains(";c"))
                 m_supports_vCont_c = eLazyBoolYes;
 
-            if (::strstr (response_cstr, ";C"))
+            if (response_str.contains(";C"))
                 m_supports_vCont_C = eLazyBoolYes;
 
-            if (::strstr (response_cstr, ";s"))
+            if (response_str.contains(";s"))
                 m_supports_vCont_s = eLazyBoolYes;
 
-            if (::strstr (response_cstr, ";S"))
+            if (response_str.contains(";S"))
                 m_supports_vCont_S = eLazyBoolYes;
 
             if (m_supports_vCont_c == eLazyBoolYes &&
                 m_supports_vCont_C == eLazyBoolYes &&
                 m_supports_vCont_s == eLazyBoolYes &&
                 m_supports_vCont_S == eLazyBoolYes)
             {
                 m_supports_vCont_all = eLazyBoolYes;
if (m_supports_jThreadsInfo)
         if (SendPacketAndWaitForResponse("jThreadsInfo", response, false) == PacketResult::Success)
         {
             if (response.IsUnsupportedResponse())
             {
                 m_supports_jThreadsInfo = false;
             }
             else if (!response.Empty())
             {
-                object_sp = StructuredData::ParseJSON (response.GetStringRef());
+                object_sp = StructuredData::ParseJSON(response.Peek());
             }
         }
     }
     return object_sp;
 }
 
 
 bool
for (unsigned int offset = 0; true; offset += response_size)
         StringExtractorGDBRemote this_response;
         // Construct payload
         char sizeDescriptor[128];
         snprintf(sizeDescriptor, sizeof(sizeDescriptor), "%x,%x", offset, response_size);
         PacketResult result = SendPacketAndWaitForResponse(payload_prefix_str + sizeDescriptor, this_response, lock);
         if (result != PacketResult::Success)
             return result;
 
-        const std::string &this_string = this_response.GetStringRef();
-
         // Check for m or l as first character; l seems to mean this is the last chunk
-        char first_char = *this_string.c_str();
+        char first_char = this_response.GetChar();
         if (first_char != 'm' && first_char != 'l')
-        {
             return PacketResult::ErrorReplyInvalid;
-        }
+
         // Concatenate the result so far (skipping 'm' or 'l')
-        response_string.append(this_string, 1, std::string::npos);
+        response_string.append(this_response.Peek());
         if (first_char == 'l')
             // We're done
             return PacketResult::Success;
     }
 }
 
 lldb::pid_t
 GDBRemoteCommunicationClient::GetCurrentProcessID (bool allow_lazy)
GDBRemoteCommunicationClient::GetLaunchSuccess (std::string &error_str)
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse("qLaunchSuccess", strlen("qLaunchSuccess"), response, false) == PacketResult::Success)
     {
         if (response.IsOKResponse())
             return true;
         if (response.GetChar() == 'E')
         {
             // A string the describes what failed when launching...
-            error_str = response.GetStringRef().substr(1);
+            error_str = response.Peek();
         }
         else
         {
             error_str.assign ("unknown error occurred launching process");
         }
     }
     else
     {
if (m_qGDBServerVersion_is_valid == eLazyBoolCalculate)
                     m_qGDBServerVersion_is_valid = eLazyBoolYes;
             }
         }
     }
     return m_qGDBServerVersion_is_valid == eLazyBoolYes;
 }
 
 void
-GDBRemoteCommunicationClient::MaybeEnableCompression (std::vector<std::string> supported_compressions)
+GDBRemoteCommunicationClient::MaybeEnableCompression(std::vector<llvm::StringRef> supported_compressions)
 {
     CompressionType avail_type = CompressionType::None;
     std::string avail_name;
 
 #if defined (HAVE_LIBCOMPRESSION)
     // libcompression is weak linked so test if compression_decode_buffer() is available
     if (compression_decode_buffer != NULL && avail_type == CompressionType::None)
     {
if (m_supports_qfProcessInfo)
         if (SendPacketAndWaitForResponse (packet.GetData(), packet.GetSize(), response, false) == PacketResult::Success)
         {
             do
             {
                 ProcessInstanceInfo process_info;
                 if (!DecodeProcessInfoResponse (response, process_info))
                     break;
                 process_infos.Append(process_info);
-                response.GetStringRef().clear();
-                response.SetFilePos(0);
+                response.Reset();
             } while (SendPacketAndWaitForResponse ("qsProcessInfo", strlen ("qsProcessInfo"), response, false) == PacketResult::Success);
         }
         else
         {
             m_supports_qfProcessInfo = false;
             return 0;
         }
     }
if (m_supports_qUserName)
         StringExtractorGDBRemote response;
         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
         {
             if (response.IsNormalResponse())
             {
                 // Make sure we parsed the right number of characters. The response is
                 // the hex encoded user name and should make up the entire packet.
                 // If there are any non-hex ASCII bytes, the length won't match below..
-                if (response.GetHexByteString (name) * 2 == response.GetStringRef().size())
+                if (response.GetHexByteString(name) && !response.GetBytesLeft())
                     return true;
             }
         }
         else
         {
             m_supports_qUserName = false;
             return false;
         }        
     }
     return false;
 
 }
 
 bool
 GDBRemoteCommunicationClient::GetGroupName (uint32_t gid, std::string &name)
 {
     if (m_supports_qGroupName)
     {
         char packet[32];
         const int packet_len = ::snprintf (packet, sizeof (packet), "qGroupName:%i", gid);
         assert (packet_len < (int)sizeof(packet));
         StringExtractorGDBRemote response;
         if (SendPacketAndWaitForResponse (packet, packet_len, response, false) == PacketResult::Success)
         {
-            if (response.IsNormalResponse())
-            {
-                // Make sure we parsed the right number of characters. The response is
-                // the hex encoded group name and should make up the entire packet.
-                // If there are any non-hex ASCII bytes, the length won't match below..
-                if (response.GetHexByteString (name) * 2 == response.GetStringRef().size())
-                    return true;
-            }
-        }
+            if (!response.IsNormalResponse())
+                return false;
+
+            if (response.GetHexByteString(name) * 2 == response.GetTotalBytes())
         else
         {
             m_supports_qGroupName = false;
             return false;
         }
     }
     return false;
 }

 GDBRemoteCommunicationClient::QueryGDBServer (std::vector<std::pair<uint16_t, std::string>>& connection_urls)
 {
     connection_urls.clear();
 
     StringExtractorGDBRemote response;
     if (SendPacketAndWaitForResponse("qQueryGDBServer", response, false) != PacketResult::Success)
         return 0;
 
-    StructuredData::ObjectSP data = StructuredData::ParseJSON(response.GetStringRef());
+    StructuredData::ObjectSP data = StructuredData::ParseJSON(response.Peek());
     if (!data)
         return 0;
 
     StructuredData::Array* array = data->GetAsArray();
     if (!array)
         return 0;
 
     for (size_t i = 0, count = array->GetSize(); i < count; ++i)

 {
     StreamString payload;
     payload.Printf("p%x", reg);
     StringExtractorGDBRemote response;
     if (SendThreadSpecificPacketAndWaitForResponse(tid, std::move(payload), response, lock) != PacketResult::Success ||
         !response.IsNormalResponse())
         return nullptr;
 
-    DataBufferSP buffer_sp(new DataBufferHeap(response.GetStringRef().size() / 2, 0));
+    DataBufferSP buffer_sp(new DataBufferHeap(response.GetBytesLeft() / 2, 0));
     response.GetHexBytes(buffer_sp->GetData(), '\xcc');
     return buffer_sp;
 }
 
 DataBufferSP
 GDBRemoteCommunicationClient::ReadAllRegisters(lldb::tid_t tid, const Lock &lock)
 {
     StreamString payload;
     payload.PutChar('g');
     StringExtractorGDBRemote response;
     if (SendThreadSpecificPacketAndWaitForResponse(tid, std::move(payload), response, lock) != PacketResult::Success ||
         !response.IsNormalResponse())
         return nullptr;
 
-    DataBufferSP buffer_sp(new DataBufferHeap(response.GetStringRef().size() / 2, 0));
+    DataBufferSP buffer_sp(new DataBufferHeap(response.GetBytesLeft() / 2, 0));
     response.GetHexBytes(buffer_sp->GetData(), '\xcc');
     return buffer_sp;
 }
 
 bool
 GDBRemoteCommunicationClient::WriteRegister(lldb::tid_t tid, uint32_t reg_num, llvm::ArrayRef<uint8_t> data,
                                             const Lock &lock)
 {

 // return:  'true'  on success
 //          'false' on failure (err set)
 bool
 GDBRemoteCommunicationClient::ReadExtFeature (const lldb_private::ConstString object,
                                               const lldb_private::ConstString annex,
                                               std::string & out,
                                               lldb_private::Error & err) {
 
-    std::stringstream output;
+    llvm::raw_string_ostream output(out);
     StringExtractorGDBRemote chunk;
 
     uint64_t size = GetRemoteMaxPacketSize();
     if (size == 0)
         size = 0x1000;
     size = size - 1; // Leave space for the 'm' or 'l' character in the response
     int offset = 0;
     bool active = true;
while ( active ) {
                                           chunk,
                                           false );
 
         if ( res != GDBRemoteCommunication::PacketResult::Success ) {
             err.SetErrorString( "Error sending $qXfer packet" );
             return false;
         }
 
-        const std::string & str = chunk.GetStringRef( );
-        if ( str.length() == 0 ) {
+        if (chunk.GetBytesLeft() == 0)
+        {
             // should have some data in chunk
             err.SetErrorString( "Empty response from $qXfer packet" );
             return false;
         }
 
         // check packet code
-        switch ( str[0] ) {
+        switch (chunk.GetChar())
+        {
             // last chunk
         case ( 'l' ):
             active = false;
             LLVM_FALLTHROUGH;
 
             // more chunks
         case ( 'm' ) :
-            if ( str.length() > 1 )
-                output << &str[1];
+            output << chunk.Peek();
             offset += size;
             break;
 
             // unknown chunk
         default:
             err.SetErrorString( "Invalid continuation code from $qXfer packet" );
             return false;
         }
     }
 
-    out = output.str( );
+    output.flush();
     err.Success( );
     return true;
 }
 
 // Notify the target that gdb is prepared to serve symbol lookup requests.
 //  packet: "qSymbol::"
 //  reply:
 //  OK                  The target does not need to look up any (more) symbols.
if (m_supports_qSymbol && m_qSymbol_requests_done == false)
                 if (response.IsUnsupportedResponse())
                 {
                     // qSymbol is not supported by the current GDB server we are connected to
                     m_supports_qSymbol = false;
                     return;
                 }
                 else
                 {
-                    llvm::StringRef response_str(response.GetStringRef());
-                    if (response_str.startswith("qSymbol:"))
+                    if (response.Consume("qSymbol:"))
                     {
-                        response.SetFilePos(strlen("qSymbol:"));
                         std::string symbol_name;
                         if (response.GetHexByteString(symbol_name))
                         {
                             if (symbol_name.empty())
                                 return;
 
                             addr_t symbol_load_addr = LLDB_INVALID_ADDRESS;
                             lldb_private::SymbolContextList sc_list;
if (!m_supported_async_json_packets_is_valid)
             GDBR_LOG_PROCESS));
 
         // Poll it now.
         StringExtractorGDBRemote response;
         const bool send_async = false;
         if (SendPacketAndWaitForResponse("qStructuredDataPlugins", response,
                                          send_async) == PacketResult::Success)
         {
-            m_supported_async_json_packets_sp = StructuredData::ParseJSON(
-                response.GetStringRef());
+            m_supported_async_json_packets_sp = StructuredData::ParseJSON(response.Peek());
             if (m_supported_async_json_packets_sp &&
                 !m_supported_async_json_packets_sp->GetAsArray())
             {
                 // We were returned something other than a JSON array.  This
                 // is invalid.  Clear it out.
                 if (log)
                     log->Printf("GDBRemoteCommunicationClient::%s(): "
                                 "QSupportedAsyncJSONPackets returned invalid "
-                                "result: %s", __FUNCTION__,
-                                response.GetStringRef().c_str());
+                                "result: %s",
+                                __FUNCTION__, response.Peek().str().c_str());
                 m_supported_async_json_packets_sp.reset();
             }
         }
         else
         {
             if (log)
                 log->Printf("GDBRemoteCommunicationClient::%s(): "
                             "QSupportedAsyncJSONPackets unsupported",
GDBRemoteCommunicationClient::ConfigureRemoteStructuredData(
     // Send the packet.
     const bool send_async = false;
     StringExtractorGDBRemote response;
     auto result = SendPacketAndWaitForResponse(stream.GetString().c_str(),
                                                response, send_async);
     if (result == PacketResult::Success)
     {
         // We failed if the config result comes back other than OK.
-        if (strcmp(response.GetStringRef().c_str(), "OK") == 0)
+        if (response.Peek().equals("OK"))
         {
             // Okay!
             error.Clear();
         }
         else
         {
             error.SetErrorStringWithFormat("configuring StructuredData feature "
                                            "%s failed with error %s",
-                                           type_name.AsCString(),
-                                           response.GetStringRef().c_str());
+                                           type_name.AsCString(), response.Peek().str().c_str());
         }
     }
     else
     {
         // Can we get more data here on the failure?
         error.SetErrorStringWithFormat("configuring StructuredData feature %s "
                                        "failed when sending packet: "
                                        "PacketResult=%d", type_name.AsCString(),

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.h

public:
     bool
     HandshakeWithClient ();
 
 protected:
     std::map<StringExtractorGDBRemote::ServerPacketType, PacketHandler> m_packet_handlers;
     bool m_exit_now; // use in asynchronous handling to indicate process should exit.
 
     PacketResult
-    SendUnimplementedResponse (const char *packet);
+    SendUnimplementedResponse(llvm::StringRef packet);
 
     PacketResult
     SendErrorResponse (uint8_t error);
 
     PacketResult
     SendIllFormedResponse (const StringExtractorGDBRemote &packet, const char *error_message);
 
     PacketResult

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServer.cpp

if (packet_result == PacketResult::Success)
             break;
 
         case StringExtractorGDBRemote::eServerPacketType_invalid:
             error.SetErrorString("invalid packet");
             quit = true;
             break;
 
         case StringExtractorGDBRemote::eServerPacketType_unimplemented:
-            packet_result = SendUnimplementedResponse (packet.GetStringRef().c_str());
+            packet_result = SendUnimplementedResponse(packet.PeekFullPacket());
             break;
 
         default:
             auto handler_it = m_packet_handlers.find(packet_type);
             if (handler_it == m_packet_handlers.end())
-                packet_result = SendUnimplementedResponse (packet.GetStringRef().c_str());
+                packet_result = SendUnimplementedResponse(packet.PeekFullPacket());
             else
                 packet_result = handler_it->second (packet, error, interrupt, quit);
             break;
         }
     }
     else
     {
         if (!IsConnected())
GDBRemoteCommunicationServer::GetPacketAndSendResponse (uint32_t timeout_usec,
 
     // Check if anything occurred that would force us to want to exit.
     if (m_exit_now)
         quit = true;
 
     return packet_result;
 }
 
-GDBRemoteCommunication::PacketResult
-GDBRemoteCommunicationServer::SendUnimplementedResponse (const char *)
+GDBRemoteCommunication::PacketResult GDBRemoteCommunicationServer::SendUnimplementedResponse(llvm::StringRef)
 {
     // TODO: Log the packet we aren't handling...
     return SendPacketNoLock ("");
 }
 
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::SendErrorResponse (uint8_t err)
 {
     char packet[16];
     int packet_len = ::snprintf (packet, sizeof(packet), "E%2.2x", err);
     assert (packet_len < (int)sizeof(packet));
     return SendPacketNoLock (llvm::StringRef(packet, packet_len));
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::SendIllFormedResponse (const StringExtractorGDBRemote &failed_packet, const char *message)
 {
     Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PACKETS));
     if (log)
-        log->Printf ("GDBRemoteCommunicationServer::%s: ILLFORMED: '%s' (%s)", __FUNCTION__, failed_packet.GetStringRef ().c_str (), message ? message : "");
+        log->Printf("GDBRemoteCommunicationServer::%s: ILLFORMED: '%s' (%s)", __FUNCTION__,
+                    failed_packet.PeekFullPacket().str().c_str(), message ? message : "");
     return SendErrorResponse (0x03);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServer::SendOKResponse ()
 {
     return SendPacketNoLock ("OK");
 }
 
 bool
 GDBRemoteCommunicationServer::HandshakeWithClient()
 {
     return GetAck() == PacketResult::Success;
 }

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerCommon.cpp

GDBRemoteCommunicationServerCommon::Handle_A (StringExtractorGDBRemote &packet)
     }
     return SendErrorResponse (8);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_qEcho (StringExtractorGDBRemote &packet)
 {
     // Just echo back the exact same packet for qEcho...
-    return SendPacketNoLock(packet.GetStringRef());
+    return SendPacketNoLock(packet.PeekFullPacket());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerCommon::Handle_qModuleInfo (StringExtractorGDBRemote &packet)
 {
     packet.SetFilePos(::strlen ("qModuleInfo:"));
 
     std::string module_path;

source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

GDBRemoteCommunicationServerLLGS::Handle_C (StringExtractorGDBRemote &packet)
     if (signo == std::numeric_limits<uint32_t>::max ())
         return SendIllFormedResponse (packet, "failed to parse signal number");
 
     // Handle optional continue address.
     if (packet.GetBytesLeft () > 0)
     {
         // FIXME add continue at address support for $C{signo}[;{continue-address}].
         if (packet.PeekChar() == ';')
-            return SendUnimplementedResponse (packet.GetStringRef().c_str());
+            return SendUnimplementedResponse(packet.PeekFullPacket());
         else
             return SendIllFormedResponse (packet, "unexpected content after $C{signal-number}");
     }
 
     ResumeActionList resume_actions (StateType::eStateRunning, 0);
     Error error;
 
     // We have two branches: what to do if a continue thread is specified (in which case we target
GDBRemoteCommunicationServerLLGS::Handle_c (StringExtractorGDBRemote &packet)
     packet.SetFilePos (packet.GetFilePos() + ::strlen ("c"));
 
     // For now just support all continue.
     const bool has_continue_address = (packet.GetBytesLeft () > 0);
     if (has_continue_address)
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s not implemented for c{address} variant [%s remains]", __FUNCTION__, packet.Peek ());
-        return SendUnimplementedResponse (packet.GetStringRef().c_str());
+        return SendUnimplementedResponse(packet.PeekFullPacket());
     }
 
     // Ensure we have a native process.
     if (!m_debugged_process_sp)
     {
         if (log)
             log->Printf ("GDBRemoteCommunicationServerLLGS::%s no debugged process shared pointer", __FUNCTION__);
         return SendErrorResponse (0x36);
GDBRemoteCommunicationServerLLGS::Handle_p (StringExtractorGDBRemote &packet)
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
     // Parse out the register number from the request.
     packet.SetFilePos (strlen("p"));
     const uint32_t reg_index = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
     if (reg_index == std::numeric_limits<uint32_t>::max ())
     {
         if (log)
-            log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, could not parse register number from request \"%s\"", __FUNCTION__, packet.GetStringRef ().c_str ());
+            log->Printf(
+                "GDBRemoteCommunicationServerLLGS::%s failed, could not parse register number from request \"%s\"",
+                __FUNCTION__, packet.Peek().str().c_str());
         return SendErrorResponse (0x15);
     }
 
     // Get the thread to use.
     NativeThreadProtocolSP thread_sp = GetThreadFromSuffix (packet);
     if (!thread_sp)
     {
         if (log)
if (packet.GetBytesLeft () < 1)
         return SendIllFormedResponse (packet, "Empty P packet");
 
     // Parse out the register number from the request.
     packet.SetFilePos (strlen("P"));
     const uint32_t reg_index = packet.GetHexMaxU32 (false, std::numeric_limits<uint32_t>::max ());
     if (reg_index == std::numeric_limits<uint32_t>::max ())
     {
         if (log)
-            log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, could not parse register number from request \"%s\"", __FUNCTION__, packet.GetStringRef ().c_str ());
+            log->Printf(
+                "GDBRemoteCommunicationServerLLGS::%s failed, could not parse register number from request \"%s\"",
+                __FUNCTION__, packet.Peek().str().c_str());
         return SendErrorResponse (0x29);
     }
 
     // Note debugserver would send an E30 here.
     if ((packet.GetBytesLeft () < 1) || (packet.GetChar () != '='))
         return SendIllFormedResponse (packet, "P packet missing '=' char after register number");
 
     // Get process architecture.

 {
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
     packet.SetFilePos (strlen("qThreadStopInfo"));
     const lldb::tid_t tid = packet.GetHexMaxU32 (false, LLDB_INVALID_THREAD_ID);
     if (tid == LLDB_INVALID_THREAD_ID)
     {
         if (log)
-            log->Printf ("GDBRemoteCommunicationServerLLGS::%s failed, could not parse thread id from request \"%s\"", __FUNCTION__, packet.GetStringRef ().c_str ());
+            log->Printf("GDBRemoteCommunicationServerLLGS::%s failed, could not parse thread id from request \"%s\"",
+                        __FUNCTION__, packet.Peek().str().c_str());
         return SendErrorResponse (0x15);
     }
     return SendStopReplyPacketForThread (tid);
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_jThreadsInfo (StringExtractorGDBRemote &)
 {
GDBRemoteCommunicationServerLLGS::GetThreadFromSuffix (StringExtractorGDBRemote &packet)
     }
 
     Log *log (GetLogIfAnyCategoriesSet(LIBLLDB_LOG_THREAD));
 
     // Parse out the ';'.
     if (packet.GetBytesLeft () < 1 || packet.GetChar () != ';')
     {
         if (log)
-            log->Printf ("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse error: expected ';' prior to start of thread suffix: packet contents = '%s'", __FUNCTION__, packet.GetStringRef ().c_str ());
+            log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse error: expected ';' prior to start of "
+                        "thread suffix: packet contents = '%s'",
+                        __FUNCTION__, packet.Peek().str().c_str());
         return thread_sp;
     }
 
     if (!packet.GetBytesLeft ())
         return thread_sp;
 
     // Parse out thread: portion.
     if (packet.Peek().startswith("thread:"))
     {
         if (log)
-            log->Printf ("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse error: expected 'thread:' but not found, packet contents = '%s'", __FUNCTION__, packet.GetStringRef ().c_str ());
+            log->Printf("GDBRemoteCommunicationServerLLGS::%s gdb-remote parse error: expected 'thread:' but not "
+                        "found, packet contents = '%s'",
+                        __FUNCTION__, packet.Peek().str().c_str());
         return thread_sp;
     }
     packet.SetFilePos (packet.GetFilePos () + strlen("thread:"));
     const lldb::tid_t tid = packet.GetHexMaxU64(false, 0);
     if (tid != 0)
         return m_debugged_process_sp->GetThreadByID (tid);
 
     return thread_sp;

source/Plugins/Process/gdb-remote/ProcessGDBRemote.h

protected:
 
     void
     GetMaxMemorySize();
 
     bool
     CalculateThreadStopInfo (ThreadGDBRemote *thread);
 
     size_t
-    UpdateThreadPCsFromStopReplyThreadsValue (std::string &value);
+    UpdateThreadPCsFromStopReplyThreadsValue(llvm::StringRef value);
 
     size_t
-    UpdateThreadIDsFromStopReplyThreadsValue (std::string &value);
+    UpdateThreadIDsFromStopReplyThreadsValue(llvm::StringRef value);
 
     bool
     HandleNotifyPacket(StringExtractorGDBRemote &packet);
 
     bool
     StartAsyncThread ();
 
     void

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

 ProcessGDBRemote::ClearThreadIDList ()
 {
     std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
     m_thread_ids.clear();
     m_thread_pcs.clear();
 }
 
 size_t
-ProcessGDBRemote::UpdateThreadIDsFromStopReplyThreadsValue (std::string &value)
+ProcessGDBRemote::UpdateThreadIDsFromStopReplyThreadsValue(llvm::StringRef value)
 {
-    m_thread_ids.clear();
     m_thread_pcs.clear();
-    size_t comma_pos;
-    lldb::tid_t tid;
-    while ((comma_pos = value.find(',')) != std::string::npos)
+    lldb::addr_t tid;
+    llvm::StringRef tid_str;
+    while (!value.empty())
     {
-        value[comma_pos] = '\0';
-        // thread in big endian hex
-        tid = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16);
-        if (tid != LLDB_INVALID_THREAD_ID)
-            m_thread_ids.push_back (tid);
-        value.erase(0, comma_pos + 1);
+        std::tie(tid_str, value) = value.split(',');
+        if (!tid_str.getAsInteger(16, tid))
+            m_thread_ids.push_back(tid);
     }
-    tid = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_THREAD_ID, 16);
-    if (tid != LLDB_INVALID_THREAD_ID)
-        m_thread_ids.push_back (tid);
     return m_thread_ids.size();
 }
 
 size_t
-ProcessGDBRemote::UpdateThreadPCsFromStopReplyThreadsValue (std::string &value)
+ProcessGDBRemote::UpdateThreadPCsFromStopReplyThreadsValue(llvm::StringRef value)
 {
     m_thread_pcs.clear();
-    size_t comma_pos;
     lldb::addr_t pc;
-    while ((comma_pos = value.find(',')) != std::string::npos)
+    llvm::StringRef pc_str;
+    while (!value.empty())
     {
-        value[comma_pos] = '\0';
-        pc = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_ADDRESS, 16);
-        if (pc != LLDB_INVALID_ADDRESS)
+        std::tie(pc_str, value) = value.split(',');
+        if (!pc_str.getAsInteger(16, pc))
             m_thread_pcs.push_back (pc);
-        value.erase(0, comma_pos + 1);
     }
-    pc = StringConvert::ToUInt64 (value.c_str(), LLDB_INVALID_ADDRESS, 16);
-    if (pc != LLDB_INVALID_THREAD_ID)
-        m_thread_pcs.push_back (pc);
     return m_thread_pcs.size();
 }
 
 bool
 ProcessGDBRemote::UpdateThreadIDList ()
 {
     std::lock_guard<std::recursive_mutex> guard(m_thread_list_real.GetMutex());
 
else
         {
             // Get the number of stop packets on the stack
             int nItems = m_stop_packet_stack.size();
             // Iterate over them
             for (int i = 0; i < nItems; i++)
             {
                 // Get the thread stop info
                 StringExtractorGDBRemote &stop_info = m_stop_packet_stack[i];
-                const std::string &stop_info_str = stop_info.GetStringRef();
 
                 m_thread_pcs.clear();
-                const size_t thread_pcs_pos = stop_info_str.find(";thread-pcs:");
-                if (thread_pcs_pos != std::string::npos)
-                {
-                    const size_t start = thread_pcs_pos + strlen(";thread-pcs:");
-                    const size_t end = stop_info_str.find(';', start);
-                    if (end != std::string::npos)
-                    {
-                        std::string value = stop_info_str.substr(start, end - start);
-                        UpdateThreadPCsFromStopReplyThreadsValue(value);
-                    }
-                }
+                llvm::StringRef threads_value = stop_info.Peek().scan_between(";thread-pcs:", ";");
+                if (!threads_value.empty())
+                    UpdateThreadPCsFromStopReplyThreadsValue(threads_value);
 
-                const size_t threads_pos = stop_info_str.find(";threads:");
-                if (threads_pos != std::string::npos)
+                threads_value = stop_info.Peek().scan_between(";threads:", ";");
+                if (!threads_value.empty())
                 {
-                    const size_t start = threads_pos + strlen(";threads:");
-                    const size_t end = stop_info_str.find(';', start);
-                    if (end != std::string::npos)
-                    {
-                        std::string value = stop_info_str.substr(start, end - start);
-                        if (UpdateThreadIDsFromStopReplyThreadsValue(value))
-                            return true;
-                    }
-                }
-            }
-        }
-    }
+                    if (UpdateThreadIDsFromStopReplyThreadsValue(threads_value))
 
     bool sequence_mutex_unavailable = false;
     m_gdb_comm.GetCurrentThreadIDs (m_thread_ids, sequence_mutex_unavailable);
     if (sequence_mutex_unavailable)
     {
         return false; // We just didn't get the list
     }
     return true;
if (tid != LLDB_INVALID_THREAD_ID)
 
         if (thread_sp)
         {
             ThreadGDBRemote *gdb_thread = static_cast<ThreadGDBRemote *> (thread_sp.get());
             gdb_thread->GetRegisterContext()->InvalidateIfNeeded(true);
 
             for (const auto &pair : expedited_register_map)
             {
-                StringExtractor reg_value_extractor;
-                reg_value_extractor.GetStringRef() = pair.second;
-                DataBufferSP buffer_sp(new DataBufferHeap(reg_value_extractor.GetStringRef().size() / 2, 0));
+                StringExtractor reg_value_extractor(pair.second);
+                DataBufferSP buffer_sp(new DataBufferHeap(reg_value_extractor.GetBytesLeft() / 2, 0));
                 reg_value_extractor.GetHexBytes(buffer_sp->GetData(), '\xcc');
                 gdb_thread->PrivateSetRegisterValue(pair.first, buffer_sp->GetData());
             }
 
             thread_sp->SetName (thread_name.empty() ? NULL : thread_name.c_str());
 
             gdb_thread->SetThreadDispatchQAddr (thread_dispatch_qaddr);
             // Check if the GDB server was able to provide the queue name, kind and serial number
thread_dict->ForEach([this,
                     StructuredData::Dictionary *mem_cache_dict = object->GetAsDictionary();
                     if (mem_cache_dict)
                     {
                         lldb::addr_t mem_cache_addr = LLDB_INVALID_ADDRESS;
                         if (mem_cache_dict->GetValueForKeyAsInteger<lldb::addr_t>("address", mem_cache_addr))
                         {
                             if (mem_cache_addr != LLDB_INVALID_ADDRESS)
                             {
-                                StringExtractor bytes;
-                                if (mem_cache_dict->GetValueForKeyAsString("bytes", bytes.GetStringRef()))
+                                std::string bytes_str;
+                                if (mem_cache_dict->GetValueForKeyAsString("bytes", bytes_str))
                                 {
-                                    bytes.SetFilePos(0);
+                                    StringExtractor bytes(bytes_str);
 
-                                    const size_t byte_size = bytes.GetStringRef().size()/2;
+                                    const size_t byte_size = bytes_str.size() / 2;
                                     DataBufferSP data_buffer_sp(new DataBufferHeap(byte_size, 0));
                                     const size_t bytes_copied = bytes.GetHexBytes (data_buffer_sp->GetData(), 0);
                                     if (bytes_copied == byte_size)
                                         m_memory_cache.AddL1CacheData(mem_cache_addr, data_buffer_sp);
                                 }
                             }
                         }
                     }

 #endif
                     SetLastStopPacket (response);
                     ClearThreadIDList ();
                     exit_status = response.GetHexU8();
                 }
                 else
                 {
                     if (log)
-                        log->Printf ("ProcessGDBRemote::DoDestroy - got unexpected response to k packet: %s", response.GetStringRef().c_str());
+                        log->Printf("ProcessGDBRemote::DoDestroy - got unexpected response to k packet: %s",
+                                    response.PeekFullPacket().str().c_str());
                     exit_string.assign("got unexpected response to k packet: ");
-                    exit_string.append(response.GetStringRef());
+                    exit_string.append(response.PeekFullPacket().str());
                 }
             }
             else
             {
                 if (log)
                     log->Printf ("ProcessGDBRemote::DoDestroy - failed to send k packet");
                 exit_string.assign("failed to send the k packet");
             }
#endif
     StopAsyncThread ();
     KillDebugserverProcess ();
     return error;
 }
 
 void
 ProcessGDBRemote::SetLastStopPacket (const StringExtractorGDBRemote &response)
 {
-    const bool did_exec = response.GetStringRef().find(";reason:exec;") != std::string::npos;
+    const bool did_exec = response.Peek().find(";reason:exec;") != llvm::StringRef::npos;
     if (did_exec)
     {
         Log *log (ProcessGDBRemoteLog::GetLogIfAllCategoriesSet(GDBR_LOG_PROCESS));
         if (log)
             log->Printf ("ProcessGDBRemote::SetLastStopPacket () - detected exec");
 
         m_thread_list_real.Clear();
         m_thread_list.Clear();
if (m_gdb_comm.SendPacketAndWaitForResponse(packet, packet_len, response, true) == GDBRemoteCommunication::PacketResult::Success)
 
                 size_t data_received_size = response.GetBytesLeft();
                 if (data_received_size > size)
                 {
                     // Don't write past the end of BUF if the remote debug server gave us too
                     // much data for some reason.
                     data_received_size = size;
                 }
-                memcpy (buf, response.GetStringRef().data(), data_received_size);
+                memcpy(buf, response.Peek().data(), data_received_size);
                 return data_received_size;
             }
             else
             {
                 return response.GetHexBytes(llvm::MutableArrayRef<uint8_t>((uint8_t*)buf, size), '\xdd');
             }
         }
         else if (response.IsErrorResponse())
             error.SetErrorStringWithFormat("memory read failed for 0x%" PRIx64, addr);
         else if (response.IsUnsupportedResponse())
             error.SetErrorStringWithFormat("GDB server does not support reading memory");
         else
-            error.SetErrorStringWithFormat("unexpected response to GDB server memory read packet '%s': '%s'", packet, response.GetStringRef().c_str());
+            error.SetErrorStringWithFormat("unexpected response to GDB server memory read packet '%s': '%s'", packet,
+                                           response.PeekFullPacket().str().c_str());
     }
     else
     {
         error.SetErrorStringWithFormat("failed to send packet: '%s'", packet);
     }
     return 0;
 }
 
if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, true) == GDBRemoteCommunication::PacketResult::Success)
             error.Clear();
             return size;
         }
         else if (response.IsErrorResponse())
             error.SetErrorStringWithFormat("memory write failed for 0x%" PRIx64, addr);
         else if (response.IsUnsupportedResponse())
             error.SetErrorStringWithFormat("GDB server does not support writing memory");
         else
-            error.SetErrorStringWithFormat("unexpected response to GDB server memory write packet '%s': '%s'", packet.GetString().c_str(), response.GetStringRef().c_str());
+            error.SetErrorStringWithFormat("unexpected response to GDB server memory write packet '%s': '%s'",
+                                           packet.GetString().c_str(), response.PeekFullPacket().str().c_str());
     }
     else
     {
         error.SetErrorStringWithFormat("failed to send packet: '%s'", packet.GetString().c_str());
     }
     return 0;
 }
 
ProcessGDBRemote::StopAsyncThread ()
     }
     else if (log)
         log->Printf("ProcessGDBRemote::%s () - Called when Async thread was not running.", __FUNCTION__);
 }
 
 bool
 ProcessGDBRemote::HandleNotifyPacket (StringExtractorGDBRemote &packet)
 {
-    // get the packet at a string
-    const std::string &pkt = packet.GetStringRef();
     // skip %stop:
-    StringExtractorGDBRemote stop_info(pkt.c_str() + 5);
+    StringExtractorGDBRemote stop_info(packet.Peek().drop_front(5));
 
     // pass as a thread stop info packet
     SetLastStopPacket(stop_info);
 
     // check for more stop reasons
     HandleStopReplySequence();
 
     // if the process is stopped then we need to fake a resume
if (m_gdb_comm.GetThreadExtendedInfoSupported())
         response.SetResponseValidatorToJSON();
         if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, false) == GDBRemoteCommunication::PacketResult::Success)
         {
             StringExtractorGDBRemote::ResponseType response_type = response.GetResponseType();
             if (response_type == StringExtractorGDBRemote::eResponse)
             {
                 if (!response.Empty())
                 {
-                    object_sp = StructuredData::ParseJSON (response.GetStringRef());
+                    object_sp = StructuredData::ParseJSON(response.Peek().str());
                 }
             }
         }
     }
     return object_sp;
 }
 
 StructuredData::ObjectSP
if (m_gdb_comm.GetLoadedDynamicLibrariesInfosSupported())
         response.SetResponseValidatorToJSON();
         if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, false) == GDBRemoteCommunication::PacketResult::Success)
         {
             StringExtractorGDBRemote::ResponseType response_type = response.GetResponseType();
             if (response_type == StringExtractorGDBRemote::eResponse)
             {
                 if (!response.Empty())
                 {
-                    object_sp = StructuredData::ParseJSON (response.GetStringRef());
+                    object_sp = StructuredData::ParseJSON(response.Peek().str());
                 }
             }
         }
     }
     return object_sp;
 }
 
 
if (m_gdb_comm.GetSharedCacheInfoSupported())
         response.SetResponseValidatorToJSON();
         if (m_gdb_comm.SendPacketAndWaitForResponse(packet.GetData(), packet.GetSize(), response, false) == GDBRemoteCommunication::PacketResult::Success)
         {
             StringExtractorGDBRemote::ResponseType response_type = response.GetResponseType();
             if (response_type == StringExtractorGDBRemote::eResponse)
             {
                 if (!response.Empty())
                 {
-                    object_sp = StructuredData::ParseJSON (response.GetStringRef());
+                    object_sp = StructuredData::ParseJSON(response.Peek().str());
                 }
             }
         }
     }
     return object_sp;
 }
 
 Error
feature_node.ForEachChildElementWithName("reg", [&target_info, &dyn_reg_info, &cur_reg_num, &reg_offset, &abi_sp](const XMLNode &reg_node) -> bool {
                 SplitCommaSeparatedRegisterNumberString(value, value_regs, 0);
             }
             else if (name == "invalidate_regnums")
             {
                 SplitCommaSeparatedRegisterNumberString(value, invalidate_regs, 0);
             }
             else if (name == "dynamic_size_dwarf_expr_bytes")
             {
-                StringExtractor opcode_extractor;
                 std::string opcode_string = value.str ();
                 size_t dwarf_opcode_len = opcode_string.length () / 2;
                 assert (dwarf_opcode_len > 0);
 
                 dwarf_opcode_bytes.resize (dwarf_opcode_len);
                 reg_info.dynamic_size_dwarf_len = dwarf_opcode_len;
-                opcode_extractor.GetStringRef ().swap (opcode_string);
+                StringExtractor opcode_extractor(opcode_string);
                 uint32_t ret_val = opcode_extractor.GetHexBytesAvail (dwarf_opcode_bytes);
                 assert (dwarf_opcode_len == ret_val);
 
                 reg_info.dynamic_size_dwarf_expr_bytes = dwarf_opcode_bytes.data ();
             }
             else
             {
                 printf("unhandled attribute %s = %s\n", name.data(), value.data());
DoExecute (Args& command, CommandReturnObject &result) override
             {
                 const char *packet_cstr = command.GetArgumentAtIndex(0);
                 bool send_async = true;
                 StringExtractorGDBRemote response;
                 process->GetGDBRemote().SendPacketAndWaitForResponse(packet_cstr, response, send_async);
                 result.SetStatus (eReturnStatusSuccessFinishResult);
                 Stream &output_strm = result.GetOutputStream();
                 output_strm.Printf ("  packet: %s\n", packet_cstr);
-                std::string &response_str = response.GetStringRef();
 
                 if (strstr(packet_cstr, "qGetProfileData") != NULL)
                 {
-                    response_str = process->HarmonizeThreadIdsForProfileData(response);
+                    response.SetString(process->HarmonizeThreadIdsForProfileData(response));
                 }
 
-                if (response_str.empty())
+                if (response.GetBytesLeft() == 0)
                     output_strm.PutCString ("response: \nerror: UNIMPLEMENTED\n");
                 else
-                    output_strm.Printf ("response: %s\n", response.GetStringRef().c_str());
+                    output_strm.Printf("response: %s\n", response.Peek().str().c_str());
             }
         }
         return true;
     }
 };
 
 class CommandObjectProcessGDBRemotePacketMonitor : public CommandObjectRaw
 {
DoExecute (const char *command, CommandReturnObject &result) override
         }
 
         ProcessGDBRemote *process = (ProcessGDBRemote *)m_interpreter.GetExecutionContext().GetProcessPtr();
         if (process)
         {
             StreamString packet;
             packet.PutCString("qRcmd,");
             packet.PutBytesAsRawHex8(command, strlen(command));
-            const char *packet_cstr = packet.GetString().c_str();
 
             bool send_async = true;
             StringExtractorGDBRemote response;
-            process->GetGDBRemote().SendPacketAndWaitForResponse(packet_cstr, response, send_async);
+            process->GetGDBRemote().SendPacketAndWaitForResponse(packet.GetString(), response, send_async);
             result.SetStatus (eReturnStatusSuccessFinishResult);
             Stream &output_strm = result.GetOutputStream();
-            output_strm.Printf ("  packet: %s\n", packet_cstr);
-            const std::string &response_str = response.GetStringRef();
+            output_strm.Printf("  packet: %s\n", packet.GetString().c_str());
 
-            if (response_str.empty())
+            if (response.GetBytesLeft() == 0)
                 output_strm.PutCString ("response: \nerror: UNIMPLEMENTED\n");
             else
-                output_strm.Printf ("response: %s\n", response.GetStringRef().c_str());
+                output_strm.Printf("response: %s\n", response.Peek().str().c_str());
         }
         return true;
     }
 };
 
 class CommandObjectProcessGDBRemotePacket : public CommandObjectMultiword
 {
 private:

source/Utility/StringExtractor.cpp

 {
     const int hi_nibble = xdigit_to_sint(ch1);
     const int lo_nibble = xdigit_to_sint(ch2);
     if (hi_nibble == -1 || lo_nibble == -1)
         return llvm::None;
     return (uint8_t)((hi_nibble << 4) + lo_nibble);
 }
 
+bool
+StringExtractor::Consume(llvm::StringRef str)
+{
+    if (!Peek().startswith(str))
+        return false;
+    m_index += str.size();
+    return true;
+}
+
 //----------------------------------------------------------------------
 // If a pair of valid hex digits exist at the head of the
 // StringExtractor they are decoded into an unsigned byte and returned
 // by this function
 //
 // If there is not a pair of valid hex digits at the head of the
 // StringExtractor, it is left unchanged and -1 is returned
 //----------------------------------------------------------------------

source/Utility/StringExtractorGDBRemote.cpp

switch (response.GetResponseType())
             break;
 
         case StringExtractorGDBRemote::eResponse:
             // JSON that is returned in from JSON query packets is currently always
             // either a dictionary which starts with a '{', or an array which
             // starts with a '['. This is a quick validator to just make sure the
             // response could be valid JSON without having to validate all of the
             // JSON content.
-            switch (response.GetStringRef()[0])
+            switch (response.PeekChar())
             {
                 case '{': return true;
                 case '[': return true;
                 default:
                     break;
             }
             break;
     }
switch (response.GetResponseType())
         case StringExtractorGDBRemote::eOK:
         case StringExtractorGDBRemote::eAck:
         case StringExtractorGDBRemote::eNack:
             break;
 
         case StringExtractorGDBRemote::eResponse:
             {
                 uint32_t valid_count = 0;
-                for (const char ch : response.GetStringRef())
+                for (const char ch : response.PeekFullPacket())
                 {
                     if (!isxdigit(ch))
                     {
                         return false;
                     }
                     if (++valid_count >= 16)
                         break; // Don't validate all the characters in case the packet is very large
                 }

unittests/Process/gdb-remote/GDBRemoteCommunicationClientTest.cpp

struct TestClient : public GDBRemoteCommunicationClient
     TestClient() { m_send_acks = false; }
 };
 
 void
 Handle_QThreadSuffixSupported(MockServer &server, bool supported)
 {
     StringExtractorGDBRemote request;
     ASSERT_EQ(PacketResult::Success, server.GetPacket(request));
-    ASSERT_EQ("QThreadSuffixSupported", request.GetStringRef());
+    ASSERT_EQ("QThreadSuffixSupported", request.Peek());
     if (supported)
         ASSERT_EQ(PacketResult::Success, server.SendOKResponse());
     else
         ASSERT_EQ(PacketResult::Success, server.SendUnimplementedResponse(nullptr));
 }
 
 void
 HandlePacket(MockServer &server, llvm::StringRef expected, llvm::StringRef response)
 {
     StringExtractorGDBRemote request;
     ASSERT_EQ(PacketResult::Success, server.GetPacket(request));
-    ASSERT_EQ(expected, request.GetStringRef());
+    ASSERT_EQ(expected, request.Peek());
     ASSERT_EQ(PacketResult::Success, server.SendPacket(response));
 }
 
 uint8_t all_registers[] = {'@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O'};
 std::string all_registers_hex = "404142434445464748494a4b4c4d4e4f";
 uint8_t one_register[] = {'A', 'B', 'C', 'D'};
 std::string one_register_hex = "41424344";
 

unittests/Utility/StringExtractorTest.cpp

 
 TEST_F (StringExtractorTest, InitEmpty)
 {
     const char kEmptyString[] = "";
     StringExtractor ex (kEmptyString);
 
     ASSERT_EQ (true, ex.IsGood());
     ASSERT_EQ (0u, ex.GetFilePos());
-    ASSERT_STREQ (kEmptyString, ex.GetStringRef().c_str());
+    ASSERT_EQ(kEmptyString, ex.Peek());
     ASSERT_EQ (true, ex.Empty());
     ASSERT_EQ (0u, ex.GetBytesLeft());
 }
 
 TEST_F (StringExtractorTest, InitMisc)
 {
     const char kInitMiscString[] = "Hello, StringExtractor!";
     StringExtractor ex (kInitMiscString);
 
     ASSERT_EQ (true, ex.IsGood());
     ASSERT_EQ (0u, ex.GetFilePos());
-    ASSERT_STREQ (kInitMiscString, ex.GetStringRef().c_str());
+    ASSERT_EQ(kInitMiscString, ex.Peek());
     ASSERT_EQ (false, ex.Empty());
     ASSERT_EQ (sizeof(kInitMiscString)-1, ex.GetBytesLeft());
     ASSERT_EQ(kInitMiscString[0], ex.PeekChar());
 }
 
+TEST_F(StringExtractorTest, PeekAndGetSize)
+{
+    llvm::StringRef Str("StringExtractorTest::Size()");
+    StringExtractor ex(Str);
+
+    EXPECT_EQ(true, ex.IsGood());
+    EXPECT_EQ(0u, ex.GetFilePos());
+    EXPECT_EQ(Str.size(), ex.GetTotalBytes());
+    EXPECT_EQ(Str.size(), ex.GetBytesLeft());
+
+    EXPECT_EQ('S', ex.PeekChar());
+    EXPECT_EQ(Str.size(), ex.GetTotalBytes());
+    EXPECT_EQ(Str.size(), ex.GetBytesLeft());
+    EXPECT_EQ(Str, ex.Peek());
+
+    EXPECT_EQ('S', ex.GetChar());
+    EXPECT_EQ(Str.size(), ex.GetTotalBytes());
+    EXPECT_EQ(Str.size() - 1, ex.GetBytesLeft());
+    EXPECT_EQ(Str.drop_front(1), ex.Peek());
+}
+
+TEST_F(StringExtractorTest, Consume)
+{
+    llvm::StringRef Str("StringExtractorTest::Consume()");
+    llvm::StringRef ConsumeStr("String");
+    StringExtractor ex(Str);
+
+    ASSERT_TRUE(ex.IsGood());
+    ASSERT_EQ(0u, ex.GetFilePos());
+
+    EXPECT_EQ(Str.size(), ex.GetBytesLeft());
+    EXPECT_FALSE(ex.Consume("Blah"));
+    EXPECT_EQ(Str.size(), ex.GetBytesLeft());
+    EXPECT_EQ(Str, ex.Peek());
+
+    EXPECT_TRUE(ex.Consume(ConsumeStr));
+    EXPECT_EQ(Str.size() - ConsumeStr.size(), ex.GetBytesLeft());
+    EXPECT_EQ("ExtractorTest::Consume()", ex.Peek());
+    ;
+}
+
 TEST_F (StringExtractorTest, DecodeHexU8_Underflow)
 {
     const char kEmptyString[] = "";
     StringExtractor ex (kEmptyString);
 
     ASSERT_EQ (-1, ex.DecodeHexU8());
     ASSERT_EQ (true, ex.IsGood());
     ASSERT_EQ (0u, ex.GetFilePos());