Global conversion of Pass()→std::move(): CrOS edition

chrome/browser/metrics/perf/perf_provider_chromeos_unittest.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 "chrome/browser/metrics/perf/perf_provider_chromeos.h"
 
 #include <stdint.h>
-
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/test/test_simple_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/metrics/perf/windowed_incognito_observer.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
 #include "chromeos/login/login_state.h"
@@ skipping 88 matching lines @@
 class TestIncognitoObserver : public WindowedIncognitoObserver {
  public:
   // Factory function to create a TestIncognitoObserver object contained in a
   // scoped_ptr<WindowedIncognitoObserver> object. |incognito_launched|
   // simulates the presence of an open incognito window, or the lack thereof.
   // Used for passing observers to ParseOutputProtoIfValid().
   static scoped_ptr<WindowedIncognitoObserver> CreateWithIncognitoLaunched(
       bool incognito_launched) {
     scoped_ptr<TestIncognitoObserver> observer(new TestIncognitoObserver);
     observer->set_incognito_launched(incognito_launched);
-    return observer.Pass();
+    return std::move(observer);
   }
 
  private:
   TestIncognitoObserver() {}
 
   DISALLOW_COPY_AND_ASSIGN(TestIncognitoObserver);
 };
 
 // Allows access to some private methods for testing.
 class TestPerfProvider : public PerfProvider {
@@ skipping 67 matching lines @@
       TestIncognitoObserver::CreateWithIncognitoLaunched(true)->
           incognito_launched());
 }
 
 TEST_F(PerfProviderTest, NoPerfData) {
   scoped_ptr<SampledProfile> sampled_profile(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::PERIODIC_COLLECTION);
 
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(false),
-      sampled_profile.Pass(),
-      kPerfSuccess,
-      std::vector<uint8_t>(),
+      std::move(sampled_profile), kPerfSuccess, std::vector<uint8_t>(),
       std::vector<uint8_t>());
 
   std::vector<SampledProfile> stored_profiles;
   EXPECT_FALSE(perf_provider_->GetSampledProfiles(&stored_profiles));
 }
 
 TEST_F(PerfProviderTest, PerfDataProtoOnly) {
   scoped_ptr<SampledProfile> sampled_profile(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::PERIODIC_COLLECTION);
 
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(false),
-      sampled_profile.Pass(),
-      kPerfSuccess,
-      SerializeMessageToVector(perf_data_proto_),
-      std::vector<uint8_t>());
+      std::move(sampled_profile), kPerfSuccess,
+      SerializeMessageToVector(perf_data_proto_), std::vector<uint8_t>());
 
   std::vector<SampledProfile> stored_profiles;
   EXPECT_TRUE(perf_provider_->GetSampledProfiles(&stored_profiles));
   ASSERT_EQ(1U, stored_profiles.size());
 
   const SampledProfile& profile = stored_profiles[0];
   EXPECT_EQ(SampledProfile::PERIODIC_COLLECTION, profile.trigger_event());
   EXPECT_TRUE(profile.has_ms_after_login());
 
   ASSERT_TRUE(profile.has_perf_data());
   EXPECT_FALSE(profile.has_perf_stat());
   EXPECT_EQ(SerializeMessageToVector(perf_data_proto_),
             SerializeMessageToVector(profile.perf_data()));
 }
 
 TEST_F(PerfProviderTest, PerfStatProtoOnly) {
   scoped_ptr<SampledProfile> sampled_profile(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::PERIODIC_COLLECTION);
 
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(false),
-      sampled_profile.Pass(),
-      kPerfSuccess,
-      std::vector<uint8_t>(),
+      std::move(sampled_profile), kPerfSuccess, std::vector<uint8_t>(),
       SerializeMessageToVector(perf_stat_proto_));
 
   std::vector<SampledProfile> stored_profiles;
   EXPECT_TRUE(perf_provider_->GetSampledProfiles(&stored_profiles));
   ASSERT_EQ(1U, stored_profiles.size());
 
   const SampledProfile& profile = stored_profiles[0];
   EXPECT_EQ(SampledProfile::PERIODIC_COLLECTION, profile.trigger_event());
   EXPECT_TRUE(profile.has_ms_after_login());
 
   EXPECT_FALSE(profile.has_perf_data());
   ASSERT_TRUE(profile.has_perf_stat());
   EXPECT_EQ(SerializeMessageToVector(perf_stat_proto_),
             SerializeMessageToVector(profile.perf_stat()));
 }
 
 TEST_F(PerfProviderTest, BothPerfDataProtoAndPerfStatProto) {
   scoped_ptr<SampledProfile> sampled_profile(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::PERIODIC_COLLECTION);
 
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(false),
-      sampled_profile.Pass(),
-      kPerfSuccess,
+      std::move(sampled_profile), kPerfSuccess,
       SerializeMessageToVector(perf_data_proto_),
       SerializeMessageToVector(perf_stat_proto_));
 
   std::vector<SampledProfile> stored_profiles;
   EXPECT_FALSE(perf_provider_->GetSampledProfiles(&stored_profiles));
   EXPECT_TRUE(stored_profiles.empty());
 }
 
 TEST_F(PerfProviderTest, InvalidPerfOutputResult) {
   scoped_ptr<SampledProfile> sampled_profile(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::PERIODIC_COLLECTION);
 
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(false),
-      sampled_profile.Pass(),
-      kPerfFailure,
-      SerializeMessageToVector(perf_data_proto_),
-      std::vector<uint8_t>());
+      std::move(sampled_profile), kPerfFailure,
+      SerializeMessageToVector(perf_data_proto_), std::vector<uint8_t>());
 
   // Should not have been stored.
   std::vector<SampledProfile> stored_profiles;
   EXPECT_FALSE(perf_provider_->GetSampledProfiles(&stored_profiles));
   EXPECT_TRUE(stored_profiles.empty());
 }
 
 // Change |sampled_profile| between calls to ParseOutputProtoIfValid().
 TEST_F(PerfProviderTest, MultipleCalls) {
   scoped_ptr<SampledProfile> sampled_profile(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::PERIODIC_COLLECTION);
 
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(false),
-      sampled_profile.Pass(),
-      kPerfSuccess,
-      SerializeMessageToVector(perf_data_proto_),
-      std::vector<uint8_t>());
+      std::move(sampled_profile), kPerfSuccess,
+      SerializeMessageToVector(perf_data_proto_), std::vector<uint8_t>());
 
   sampled_profile.reset(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::RESTORE_SESSION);
   sampled_profile->set_ms_after_restore(3000);
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(false),
-      sampled_profile.Pass(),
-      kPerfSuccess,
-      std::vector<uint8_t>(),
+      std::move(sampled_profile), kPerfSuccess, std::vector<uint8_t>(),
       SerializeMessageToVector(perf_stat_proto_));
 
   sampled_profile.reset(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::RESUME_FROM_SUSPEND);
   sampled_profile->set_suspend_duration_ms(60000);
   sampled_profile->set_ms_after_resume(1500);
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(false),
-      sampled_profile.Pass(),
-      kPerfSuccess,
-      SerializeMessageToVector(perf_data_proto_),
-      std::vector<uint8_t>());
+      std::move(sampled_profile), kPerfSuccess,
+      SerializeMessageToVector(perf_data_proto_), std::vector<uint8_t>());
 
   sampled_profile.reset(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::PERIODIC_COLLECTION);
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(false),
-      sampled_profile.Pass(),
-      kPerfSuccess,
-      std::vector<uint8_t>(),
+      std::move(sampled_profile), kPerfSuccess, std::vector<uint8_t>(),
       SerializeMessageToVector(perf_stat_proto_));
 
   std::vector<SampledProfile> stored_profiles;
   EXPECT_TRUE(perf_provider_->GetSampledProfiles(&stored_profiles));
   ASSERT_EQ(4U, stored_profiles.size());
 
   const SampledProfile& profile1 = stored_profiles[0];
   EXPECT_EQ(SampledProfile::PERIODIC_COLLECTION, profile1.trigger_event());
   EXPECT_TRUE(profile1.has_ms_after_login());
   ASSERT_TRUE(profile1.has_perf_data());
@@ skipping 30 matching lines @@
 }
 
 // Simulate opening and closing of incognito window in between calls to
 // ParseOutputProtoIfValid().
 TEST_F(PerfProviderTest, IncognitoWindowOpened) {
   scoped_ptr<SampledProfile> sampled_profile(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::PERIODIC_COLLECTION);
 
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(false),
-      sampled_profile.Pass(),
-      kPerfSuccess,
-      SerializeMessageToVector(perf_data_proto_),
-      std::vector<uint8_t>());
+      std::move(sampled_profile), kPerfSuccess,
+      SerializeMessageToVector(perf_data_proto_), std::vector<uint8_t>());
 
   std::vector<SampledProfile> stored_profiles1;
   EXPECT_TRUE(perf_provider_->GetSampledProfiles(&stored_profiles1));
   ASSERT_EQ(1U, stored_profiles1.size());
 
   const SampledProfile& profile1 = stored_profiles1[0];
   EXPECT_EQ(SampledProfile::PERIODIC_COLLECTION, profile1.trigger_event());
   EXPECT_TRUE(profile1.has_ms_after_login());
   ASSERT_TRUE(profile1.has_perf_data());
   EXPECT_FALSE(profile1.has_perf_stat());
   EXPECT_EQ(SerializeMessageToVector(perf_data_proto_),
             SerializeMessageToVector(profile1.perf_data()));
 
   sampled_profile.reset(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::RESTORE_SESSION);
   sampled_profile->set_ms_after_restore(3000);
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(false),
-      sampled_profile.Pass(),
-      kPerfSuccess,
-      std::vector<uint8_t>(),
+      std::move(sampled_profile), kPerfSuccess, std::vector<uint8_t>(),
       SerializeMessageToVector(perf_stat_proto_));
 
   std::vector<SampledProfile> stored_profiles2;
   EXPECT_TRUE(perf_provider_->GetSampledProfiles(&stored_profiles2));
   ASSERT_EQ(1U, stored_profiles2.size());
 
   const SampledProfile& profile2 = stored_profiles2[0];
   EXPECT_EQ(SampledProfile::RESTORE_SESSION, profile2.trigger_event());
   EXPECT_TRUE(profile2.has_ms_after_login());
   EXPECT_EQ(3000, profile2.ms_after_restore());
   EXPECT_FALSE(profile2.has_perf_data());
   ASSERT_TRUE(profile2.has_perf_stat());
   EXPECT_EQ(SerializeMessageToVector(perf_stat_proto_),
             SerializeMessageToVector(profile2.perf_stat()));
 
   sampled_profile.reset(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::RESUME_FROM_SUSPEND);
   // An incognito window opens.
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(true),
-      sampled_profile.Pass(),
-      kPerfSuccess,
-      SerializeMessageToVector(perf_data_proto_),
-      std::vector<uint8_t>());
+      std::move(sampled_profile), kPerfSuccess,
+      SerializeMessageToVector(perf_data_proto_), std::vector<uint8_t>());
 
   std::vector<SampledProfile> stored_profiles_empty;
   EXPECT_FALSE(perf_provider_->GetSampledProfiles(&stored_profiles_empty));
 
   sampled_profile.reset(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::PERIODIC_COLLECTION);
   // Incognito window is still open.
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(true),
-      sampled_profile.Pass(),
-      kPerfSuccess,
-      std::vector<uint8_t>(),
+      std::move(sampled_profile), kPerfSuccess, std::vector<uint8_t>(),
       SerializeMessageToVector(perf_stat_proto_));
 
   EXPECT_FALSE(perf_provider_->GetSampledProfiles(&stored_profiles_empty));
 
   sampled_profile.reset(new SampledProfile);
   sampled_profile->set_trigger_event(SampledProfile::RESUME_FROM_SUSPEND);
   sampled_profile->set_suspend_duration_ms(60000);
   sampled_profile->set_ms_after_resume(1500);
   // Incognito window closes.
   perf_provider_->ParseOutputProtoIfValid(
       TestIncognitoObserver::CreateWithIncognitoLaunched(false),
-      sampled_profile.Pass(),
-      kPerfSuccess,
-      SerializeMessageToVector(perf_data_proto_),
-      std::vector<uint8_t>());
+      std::move(sampled_profile), kPerfSuccess,
+      SerializeMessageToVector(perf_data_proto_), std::vector<uint8_t>());
 
   std::vector<SampledProfile> stored_profiles3;
   EXPECT_TRUE(perf_provider_->GetSampledProfiles(&stored_profiles3));
   ASSERT_EQ(1U, stored_profiles3.size());
 
   const SampledProfile& profile3 = stored_profiles3[0];
   EXPECT_EQ(SampledProfile::RESUME_FROM_SUSPEND, profile3.trigger_event());
   EXPECT_TRUE(profile3.has_ms_after_login());
   EXPECT_EQ(60000, profile3.suspend_duration_ms());
   EXPECT_EQ(1500, profile3.ms_after_resume());
@@ skipping 372 matching lines @@
             parsed_params.periodic_interval());
   EXPECT_EQ(1, parsed_params.resume_from_suspend().sampling_factor());
   EXPECT_EQ(base::TimeDelta::FromSeconds(10),
             parsed_params.resume_from_suspend().max_collection_delay());
   EXPECT_EQ(2, parsed_params.restore_session().sampling_factor());
   EXPECT_EQ(base::TimeDelta::FromSeconds(20),
             parsed_params.restore_session().max_collection_delay());
 }
 
 }  // namespace metrics