base: Use std::move() instead of Pass() for real movable types.

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 <utility>
+
 #include "base/base64.h"
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/format_macros.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/string_escape.h"
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 202 matching lines @@
   global_tags_.insert(tag);
 }
 
 bool TestResultsTracker::SaveSummaryAsJSON(const FilePath& path) const {
   scoped_ptr<DictionaryValue> summary_root(new DictionaryValue);
 
   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());
+  summary_root->Set("global_tags", std::move(global_tags));
 
   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());
+  summary_root->Set("all_tests", std::move(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());
+  summary_root->Set("disabled_tests", std::move(disabled_tests));
 
   scoped_ptr<ListValue> per_iteration_data(new ListValue);
 
   for (int i = 0; i <= iteration_; i++) {
     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) {
@@ skipping 25 matching lines @@
         test_result_value->SetBoolean("losless_snippet", lossless_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());
+        test_results->Append(std::move(test_result_value));
       }
 
       current_iteration_data->SetWithoutPathExpansion(j->first,
-                                                      test_results.Pass());
+                                                      std::move(test_results));
     }
-    per_iteration_data->Append(current_iteration_data.Pass());
-    summary_root->Set("per_iteration_data", per_iteration_data.Pass());
+    per_iteration_data->Append(std::move(current_iteration_data));
+    summary_root->Set("per_iteration_data", std::move(per_iteration_data));
   }
 
   JSONFileValueSerializer serializer(path);
   return serializer.Serialize(*summary_root);
 }
 
 TestResultsTracker::TestStatusMap
     TestResultsTracker::GetTestStatusMapForCurrentIteration() const {
   TestStatusMap tests_by_status;
   GetTestStatusForIteration(iteration_, &tests_by_status);
@@ skipping 52 matching lines @@
 TestResultsTracker::AggregateTestResult::~AggregateTestResult() {
 }
 
 TestResultsTracker::PerIterationData::PerIterationData() {
 }
 
 TestResultsTracker::PerIterationData::~PerIterationData() {
 }
 
 }  // namespace base