Tracing: re-use JSONTraceDataSink in DevTools' tracing handler...

content/browser/devtools/devtools_io_context.cc

 // 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.
 
 #include "content/browser/devtools/devtools_io_context.h"
 
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 44 matching lines @@
   }
   return true;
 }
 
 void Stream::Read(off_t position, size_t max_size, ReadCallback callback) {
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
       base::Bind(&Stream::ReadOnFileThread, this, position, max_size,
                  callback));
 }
 
-void Stream::Append(const scoped_refptr<base::RefCountedString>& data) {
+void Stream::Append(std::unique_ptr<std::string> data) {
   BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE,
-      base::Bind(&Stream::AppendOnFileThread, this, data));
+                          base::Bind(&Stream::AppendOnFileThread, this,
+                                     base::Passed(std::move(data))));
 }
 
 void Stream::ReadOnFileThread(off_t position, size_t max_size,
                               ReadCallback callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   Status status = StatusFailure;
   scoped_refptr<base::RefCountedString> data;
 
   if (file_.IsValid()) {
     std::string buffer;
@@ skipping 16 matching lines @@
       }
       data = base::RefCountedString::TakeString(&buffer);
       status = size_got ? StatusSuccess : StatusEOF;
       last_read_pos_ = position + size_got;
     }
   }
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(callback, data, status));
 }
 
-void Stream::AppendOnFileThread(
-    const scoped_refptr<base::RefCountedString>& data) {
+void Stream::AppendOnFileThread(std::unique_ptr<std::string> data) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   if (!InitOnFileThreadIfNeeded())
     return;
-  const std::string& buffer = data->data();
-  int size_written = file_.WriteAtCurrentPos(&*buffer.begin(), buffer.size());
-  if (size_written != static_cast<int>(buffer.size())) {
+  int size_written = file_.WriteAtCurrentPos(data->data(), data->size());
+  if (size_written != static_cast<int>(data->size())) {
     LOG(ERROR) << "Failed to write temporary file";
     had_errors_ = true;
     file_.Close();
   }
 }
 
 DevToolsIOContext::DevToolsIOContext() {}
 
 DevToolsIOContext::~DevToolsIOContext() {}
 
@@ skipping 14 matching lines @@
 bool DevToolsIOContext::Close(const std::string& handle) {
   return streams_.erase(handle) == 1;
 }
 
 void DevToolsIOContext::DiscardAllStreams() {
   return streams_.clear();
 }
 
 }  // namespace devtools
 }  // namespace content