Remove ListValue::Append(raw ptr) on Win

content/browser/tracing/etw_tracing_agent_win.cc

 // Copyright 2014 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/tracing/etw_tracing_agent_win.h"
 
 #include <stdint.h>
 
+#include <utility>
+
 #include "base/base64.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/lazy_instance.h"
 #include "base/memory/singleton.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/stringprintf.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event_impl.h"
 #include "content/public/browser/browser_thread.h"

[jdoerrie, 2017/04/13 13:49:49]

#include "base/values.h"

[vabr (Chromium), 2017/04/13 16:06:48]

Done.

 
 namespace content {
 
 namespace {
 
 const char kETWTracingAgentName[] = "etw";
 const char kETWTraceLabel[] = "systemTraceEvents";
 
 const int kEtwBufferSizeInKBytes = 16;
 const int kEtwBufferFlushTimeoutInSeconds = 1;
@@ skipping 138 matching lines @@
   // Add fields to the event.
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
   value->Set("guid", new base::Value("ClockSync"));
   value->Set("walltime",
              new base::Value(base::StringPrintf(
                  "%08X%08X", walltime_in_us.HighPart, walltime_in_us.LowPart)));
   value->Set("tick", new base::Value(base::StringPrintf(
                          "%08X%08X", now_in_us.HighPart, now_in_us.LowPart)));
 
   // Append it to the events buffer.
-  events_->Append(value.release());
+  events_->Append(std::move(value));
 }
 
 void EtwTracingAgent::AppendEventToBuffer(EVENT_TRACE* event) {
   using base::Value;
 
   std::unique_ptr<base::DictionaryValue> value(new base::DictionaryValue());
 
   // Add header fields to the event.
   LARGE_INTEGER ts_us;
   ts_us.QuadPart = event->Header.TimeStamp.QuadPart / 10;
   value->Set("ts", new base::Value(base::StringPrintf(
                        "%08X%08X", ts_us.HighPart, ts_us.LowPart)));
 
   value->Set("guid", new base::Value(GuidToString(event->Header.Guid)));
 
   value->Set("op", new Value(event->Header.Class.Type));
   value->Set("ver", new Value(event->Header.Class.Version));
   value->Set("pid", new Value(static_cast<int>(event->Header.ProcessId)));
   value->Set("tid", new Value(static_cast<int>(event->Header.ThreadId)));
   value->Set("cpu", new Value(event->BufferContext.ProcessorNumber));
 
   // Base64 encode the payload bytes.
   base::StringPiece buffer(static_cast<const char*>(event->MofData),
                            event->MofLength);
   std::string payload;
   base::Base64Encode(buffer, &payload);
   value->Set("payload", new base::Value(payload));
 
   // Append it to the events buffer.
-  events_->Append(value.release());
+  events_->Append(std::move(value));
 }
 
 void EtwTracingAgent::TraceAndConsumeOnThread() {
   // Create the events buffer.
   events_.reset(new base::ListValue());
 
   // Output a clock sync event.
   AddSyncEventToBuffer();
 
   HRESULT hr = OpenRealtimeSession(KERNEL_LOGGER_NAME);
   if (FAILED(hr))
     return;
   Consume();
   Close();
 }
 
 void EtwTracingAgent::FlushOnThread(
     const StopAgentTracingCallback& callback) {
   // Add the header information to the stream.
   std::unique_ptr<base::DictionaryValue> header(new base::DictionaryValue());
   header->Set("name", new base::Value("ETW"));
 
   // Release and pass the events buffer.
-  header->Set("content", events_.release());
+  header->Set("content", std::move(events_));
 
   // Serialize the results as a JSon string.
   std::string output;
   JSONStringValueSerializer serializer(&output);
   serializer.Serialize(*header.get());
 
   // Pass the result to the UI Thread.
   scoped_refptr<base::RefCountedString> result =
       base::RefCountedString::TakeString(&output);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&EtwTracingAgent::OnStopSystemTracingDone,
                  base::Unretained(this),
                  callback,
                  result));
 }
 
 }  // namespace content