Change TraceDataEndPoint::ReceiveTraceChunk() to accept unique_ptr<string>

content/browser/tracing/tracing_controller_impl_data_sinks.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 <utility>
 
 #include "base/bind.h"
 #include "base/files/file_util.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
@@ skipping 25 matching lines @@
     trace_.clear();
     scoped_refptr<base::RefCountedString> str =
         base::RefCountedString::TakeString(&tmp);
 
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         base::Bind(completion_callback_, base::Passed(std::move(metadata)),
                    base::RetainedRef(str)));
   }
 
-  void ReceiveTraceChunk(const std::string& chunk) override { trace_ << chunk; }
+  void ReceiveTraceChunk(std::unique_ptr<std::string> chunk) override {
+    trace_ << *chunk;
+  }
 
  private:
   ~StringTraceDataEndpoint() override {}
 
   CompletionCallback completion_callback_;
   std::ostringstream trace_;
 
   DISALLOW_COPY_AND_ASSIGN(StringTraceDataEndpoint);
 };
 
 class FileTraceDataEndpoint : public TraceDataEndpoint {
  public:
   explicit FileTraceDataEndpoint(const base::FilePath& trace_file_path,
                                  const base::Closure& callback)
       : file_path_(trace_file_path),
         completion_callback_(callback),
         file_(NULL) {}
 
-  void ReceiveTraceChunk(const std::string& chunk) override {
-    std::string tmp = chunk;
-    scoped_refptr<base::RefCountedString> chunk_ptr =
-        base::RefCountedString::TakeString(&tmp);
+  void ReceiveTraceChunk(std::unique_ptr<std::string> chunk) override {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&FileTraceDataEndpoint::ReceiveTraceChunkOnFileThread, this,
-                   chunk_ptr));
+                   base::Passed(std::move(chunk))));
   }
 
   void ReceiveTraceFinalContents(
       std::unique_ptr<const base::DictionaryValue>) override {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&FileTraceDataEndpoint::CloseOnFileThread, this));
   }
 
  private:
   ~FileTraceDataEndpoint() override { DCHECK(file_ == NULL); }
 
-  void ReceiveTraceChunkOnFileThread(
-      const scoped_refptr<base::RefCountedString> chunk) {
+  void ReceiveTraceChunkOnFileThread(std::unique_ptr<std::string> chunk) {
     if (!OpenFileIfNeededOnFileThread())
       return;
-    ignore_result(
-        fwrite(chunk->data().c_str(), chunk->data().size(), 1, file_));
+    ignore_result(fwrite(chunk->c_str(), chunk->size(), 1, file_));
   }
 
   bool OpenFileIfNeededOnFileThread() {
     if (file_ != NULL)
       return true;
     file_ = base::OpenFile(file_path_, "w");
     if (file_ == NULL) {
       LOG(ERROR) << "Failed to open " << file_path_.value();
       return false;
     }
@@ skipping 49 matching lines @@
 
   void AddTraceChunk(const std::string& chunk) override {
     std::string trace_string;
     if (had_received_first_chunk_)
       trace_string = ",";
     else
       trace_string = "{\"" + std::string(kChromeTraceLabel) + "\":[";
     trace_string += chunk;
     had_received_first_chunk_ = true;
 
-    endpoint_->ReceiveTraceChunk(trace_string);
+    endpoint_->ReceiveTraceChunk(base::MakeUnique<std::string>(trace_string));
   }
 
   void Close() override {
-    endpoint_->ReceiveTraceChunk("]");
+    endpoint_->ReceiveTraceChunk(base::MakeUnique<std::string>("]"));
 
     for (auto const &it : GetAgentTrace())
-      endpoint_->ReceiveTraceChunk(",\"" + it.first + "\": " + it.second);
+      endpoint_->ReceiveTraceChunk(
+          base::MakeUnique<std::string>(",\"" + it.first + "\": " + it.second));
 
     std::unique_ptr<base::DictionaryValue> metadata(TakeMetadata());
     std::string metadataJSON;
 
     if (base::JSONWriter::Write(*metadata, &metadataJSON) &&
         !metadataJSON.empty()) {
-      endpoint_->ReceiveTraceChunk(",\"" + std::string(kMetadataTraceLabel) +
-                                   "\": " + metadataJSON);
+      endpoint_->ReceiveTraceChunk(base::MakeUnique<std::string>(
+          ",\"" + std::string(kMetadataTraceLabel) + "\": " + metadataJSON));
     }
 
-    endpoint_->ReceiveTraceChunk("}");
+    endpoint_->ReceiveTraceChunk(base::MakeUnique<std::string>("}"));
     endpoint_->ReceiveTraceFinalContents(std::move(metadata));
   }
 
  private:
   ~JSONTraceDataSink() override {}
 
   scoped_refptr<TraceDataEndpoint> endpoint_;
   bool had_received_first_chunk_;
   DISALLOW_COPY_AND_ASSIGN(JSONTraceDataSink);
 };
 
 class CompressedTraceDataEndpoint : public TraceDataEndpoint {
  public:
   explicit CompressedTraceDataEndpoint(
       scoped_refptr<TraceDataEndpoint> endpoint)
       : endpoint_(endpoint), already_tried_open_(false) {}
 
-  void ReceiveTraceChunk(const std::string& chunk) override {
+  void ReceiveTraceChunk(std::unique_ptr<std::string> chunk) override {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&CompressedTraceDataEndpoint::CompressOnFileThread, this,
-                   base::Passed(base::MakeUnique<std::string>(chunk))));
+                   base::Passed(std::move(chunk))));
   }
 
   void ReceiveTraceFinalContents(
       std::unique_ptr<const base::DictionaryValue> metadata) override {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         base::Bind(&CompressedTraceDataEndpoint::CloseOnFileThread, this,
                    base::Passed(std::move(metadata))));
   }
 
@@ skipping 22 matching lines @@
                               Z_DEFAULT_STRATEGY);
     return result == 0;
   }
 
   void CompressOnFileThread(std::unique_ptr<std::string> chunk) {
     DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     if (!OpenZStreamOnFileThread())
       return;
 
     stream_->avail_in = chunk->size();
-    stream_->next_in = (unsigned char*)chunk->data();
+    stream_->next_in = reinterpret_cast<unsigned char*>(&*chunk->begin());

[oystein (OOO til 10th of July), 2016/07/15 16:56:26]

Just curious: What's the reason for &*chunk->begin() instead of *chunk->data()?

     DrainStreamOnFileThread(false);
   }
 
   void DrainStreamOnFileThread(bool finished) {
     DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
     int err;
     const int kChunkSize = 0x4000;
     char buffer[kChunkSize];
     do {
       stream_->avail_out = kChunkSize;
       stream_->next_out = (unsigned char*)buffer;
       err = deflate(stream_.get(), finished ? Z_FINISH : Z_NO_FLUSH);
       if (err != (finished ? Z_STREAM_END : Z_OK)) {
         stream_.reset();
         return;
       }
 
       int bytes = kChunkSize - stream_->avail_out;
       if (bytes) {
-        std::string compressed_chunk = std::string(buffer, bytes);
-        endpoint_->ReceiveTraceChunk(compressed_chunk);
+        std::string compressed(buffer, bytes);
+        endpoint_->ReceiveTraceChunk(base::MakeUnique<std::string>(compressed));
       }
     } while (stream_->avail_out == 0);
   }
 
   void CloseOnFileThread(
       std::unique_ptr<const base::DictionaryValue> metadata) {
     DCHECK_CURRENTLY_ON(BrowserThread::FILE);
     if (!OpenZStreamOnFileThread())
       return;
 
@@ skipping 56 matching lines @@
   return new JSONTraceDataSink(new CompressedTraceDataEndpoint(endpoint));
 }
 
 scoped_refptr<TraceDataEndpoint> TracingControllerImpl::CreateCallbackEndpoint(
     const base::Callback<void(std::unique_ptr<const base::DictionaryValue>,
                               base::RefCountedString*)>& callback) {
   return new StringTraceDataEndpoint(callback);
 }
 
 }  // namespace content