Update from https://crrev.com/329939

base/test/launcher/test_results_tracker.cc

 // Copyright 2013 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 "base/test/launcher/test_results_tracker.h"
 
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 221 matching lines @@
   fflush(stdout);
 }
 
 void TestResultsTracker::AddGlobalTag(const std::string& tag) {
   global_tags_.insert(tag);
 }
 
 bool TestResultsTracker::SaveSummaryAsJSON(const FilePath& path) const {
   scoped_ptr<DictionaryValue> summary_root(new DictionaryValue);
 
-  ListValue* global_tags = new ListValue;
-  summary_root->Set("global_tags", global_tags);
+  scoped_ptr<ListValue> global_tags(new ListValue);
+  for (const auto& global_tag : global_tags_) {
+    global_tags->AppendString(global_tag);
+  }
+  summary_root->Set("global_tags", global_tags.Pass());
 
-  for (std::set<std::string>::const_iterator i = global_tags_.begin();
-       i != global_tags_.end();
-       ++i) {
-    global_tags->AppendString(*i);
+  scoped_ptr<ListValue> all_tests(new ListValue);
+  for (const auto& test : all_tests_) {
+    all_tests->AppendString(test);
   }
+  summary_root->Set("all_tests", all_tests.Pass());
 
-  ListValue* all_tests = new ListValue;
-  summary_root->Set("all_tests", all_tests);
+  scoped_ptr<ListValue> disabled_tests(new ListValue);
+  for (const auto& disabled_test : disabled_tests_) {
+    disabled_tests->AppendString(disabled_test);
+  }
+  summary_root->Set("disabled_tests", disabled_tests.Pass());
 
-  for (std::set<std::string>::const_iterator i = all_tests_.begin();
-       i != all_tests_.end();
-       ++i) {
-    all_tests->AppendString(*i);
-  }
-
-  ListValue* disabled_tests = new ListValue;
-  summary_root->Set("disabled_tests", disabled_tests);
-
-  for (std::set<std::string>::const_iterator i = disabled_tests_.begin();
-       i != disabled_tests_.end();
-       ++i) {
-    disabled_tests->AppendString(*i);
-  }
-
-  ListValue* per_iteration_data = new ListValue;
-  summary_root->Set("per_iteration_data", per_iteration_data);
+  scoped_ptr<ListValue> per_iteration_data(new ListValue);
 
   for (int i = 0; i <= iteration_; i++) {
-    DictionaryValue* current_iteration_data = new DictionaryValue;
-    per_iteration_data->Append(current_iteration_data);
+    scoped_ptr<DictionaryValue> current_iteration_data(new DictionaryValue);
 
     for (PerIterationData::ResultsMap::const_iterator j =
              per_iteration_data_[i].results.begin();
          j != per_iteration_data_[i].results.end();
          ++j) {
-      ListValue* test_results = new ListValue;
-      current_iteration_data->SetWithoutPathExpansion(j->first, test_results);
+      scoped_ptr<ListValue> test_results(new ListValue);
 
       for (size_t k = 0; k < j->second.test_results.size(); k++) {
         const TestResult& test_result = j->second.test_results[k];
 
-        DictionaryValue* test_result_value = new DictionaryValue;
-        test_results->Append(test_result_value);
+        scoped_ptr<DictionaryValue> test_result_value(new DictionaryValue);
 
         test_result_value->SetString("status", test_result.StatusAsString());
         test_result_value->SetInteger(
             "elapsed_time_ms",
             static_cast<int>(test_result.elapsed_time.InMilliseconds()));
 
         // There are no guarantees about character encoding of the output
         // snippet. Escape it and record whether it was losless.
         // It's useful to have the output snippet as string in the summary
         // for easy viewing.
         std::string escaped_output_snippet;
         bool losless_snippet = EscapeJSONString(
             test_result.output_snippet, false, &escaped_output_snippet);
         test_result_value->SetString("output_snippet",
                                      escaped_output_snippet);
         test_result_value->SetBoolean("losless_snippet", losless_snippet);
 
         // Also include the raw version (base64-encoded so that it can be safely
         // JSON-serialized - there are no guarantees about character encoding
         // of the snippet). This can be very useful piece of information when
         // debugging a test failure related to character encoding.
         std::string base64_output_snippet;
         Base64Encode(test_result.output_snippet, &base64_output_snippet);
         test_result_value->SetString("output_snippet_base64",
                                      base64_output_snippet);
+        test_results->Append(test_result_value.Pass());
       }
+
+      current_iteration_data->SetWithoutPathExpansion(j->first,
+                                                      test_results.Pass());
     }
+    per_iteration_data->Append(current_iteration_data.Pass());
+    summary_root->Set("per_iteration_data", per_iteration_data.Pass());
   }
 
   JSONFileValueSerializer serializer(path);
   return serializer.Serialize(*summary_root);
 }
 
 TestResultsTracker::TestStatusMap
     TestResultsTracker::GetTestStatusMapForCurrentIteration() const {
   TestStatusMap tests_by_status;
   GetTestStatusForIteration(iteration_, &tests_by_status);
@@ skipping 26 matching lines @@
 TestResultsTracker::AggregateTestResult::~AggregateTestResult() {
 }
 
 TestResultsTracker::PerIterationData::PerIterationData() {
 }
 
 TestResultsTracker::PerIterationData::~PerIterationData() {
 }
 
 }  // namespace base