Use StringView for String::append and ::insert.

third_party/WebKit/Source/modules/fetch/DataConsumerHandleTestUtil.h

 // Copyright 2015 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 DataConsumerHandleTestUtil_h
 #define DataConsumerHandleTestUtil_h
 
 #include "bindings/core/v8/ScriptState.h"
 #include "core/testing/NullExecutionContext.h"
 #include "gin/public/isolate_holder.h"
@@ skipping 70 matching lines @@
         virtual ~ThreadingTestBase() { }
 
         class ThreadHolder;
 
         class Context : public ThreadSafeRefCounted<Context> {
         public:
             static PassRefPtr<Context> create() { return adoptRef(new Context); }
             void recordAttach(const String& handle)
             {
                 MutexLocker locker(m_loggingMutex);
-                m_result.append("A reader is attached to " + handle + " on " + currentThreadName() + ".\n");
+                m_result.append("A reader is attached to ");
+                m_result.append(handle);
+                m_result.append(" on ");
+                m_result.append(currentThreadName());
+                m_result.append(".\n");
             }
             void recordDetach(const String& handle)
             {
                 MutexLocker locker(m_loggingMutex);
-                m_result.append("A reader is detached from " + handle + " on " + currentThreadName() + ".\n");
+                m_result.append("A reader is detached from ");
+                m_result.append(handle);
+                m_result.append(" on ");
+                m_result.append(currentThreadName());
+                m_result.append(".\n");
             }
 
-            const String& result()
+            String result()
             {
                 MutexLocker locker(m_loggingMutex);
-                return m_result;
+                return m_result.toString();
             }
 
             void registerThreadHolder(ThreadHolder* holder)
             {
                 MutexLocker locker(m_holderMutex);
                 ASSERT(!m_holder);
                 m_holder = holder;
             }
             void unregisterThreadHolder()
             {
@@ skipping 24 matching lines @@
                     if (m_holder->readingThread()->isCurrentThread())
                         return "the reading thread";
                     if (m_holder->updatingThread()->isCurrentThread())
                         return "the updating thread";
                 }
                 return "an unknown thread";
             }
 
             // Protects |m_result|.
             Mutex m_loggingMutex;
-            String m_result;
+            StringBuilder m_result;
 
             // Protects |m_holder|.
             Mutex m_holderMutex;
             // Because Context outlives ThreadHolder, holding a raw pointer
             // here is safe.
             ThreadHolder* m_holder;
         };
 
         // The reading/updating threads are alive while ThreadHolder is alive.
         class ThreadHolder {
@@ skipping 51 matching lines @@
 
             std::unique_ptr<Reader> obtainReader(Client*) { return WTF::wrapUnique(new ReaderImpl(m_name, m_context)); }
             const char* debugName() const override { return "ThreadingTestBase::DataConsumerHandle"; }
 
             const String m_name;
             RefPtr<Context> m_context;
         };
 
         void resetReader() { m_reader = nullptr; }
         void signalDone() { m_waitableEvent->signal(); }
-        const String& result() { return m_context->result(); }
+        String result() { return m_context->result(); }
         void postTaskToReadingThread(const WebTraceLocation& location, std::unique_ptr<CrossThreadClosure> task)
         {
             m_context->postTaskToReadingThread(location,  std::move(task));
         }
         void postTaskToUpdatingThread(const WebTraceLocation& location, std::unique_ptr<CrossThreadClosure> task)
         {
             m_context->postTaskToUpdatingThread(location,  std::move(task));
         }
         void postTaskToReadingThreadAndWait(const WebTraceLocation& location, std::unique_ptr<CrossThreadClosure> task)
         {
@@ skipping 303 matching lines @@
         std::unique_ptr<HandleReadResult> m_result;
         bool m_isDone;
 
         std::unique_ptr<T> m_handleReader;
     };
 };
 
 } // namespace blink
 
 #endif // DataConsumerHandleTestUtil_h