Change base::Value::ListStorage to std::vector<base::Value>

chrome/browser/chromeos/ownership/owner_settings_service_chromeos.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 "chrome/browser/chromeos/ownership/owner_settings_service_chromeos.h"
 
 #include <keyhi.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 443 matching lines @@
   } else if (path == kAccountsPrefDeviceLocalAccounts) {
     em::DeviceLocalAccountsProto* device_local_accounts =
         settings.mutable_device_local_accounts();
     device_local_accounts->clear_account();
     const base::ListValue* accounts_list = NULL;
     if (value.GetAsList(&accounts_list)) {
       for (base::ListValue::const_iterator entry(accounts_list->begin());
            entry != accounts_list->end();
            ++entry) {
         const base::DictionaryValue* entry_dict = NULL;
-        if ((*entry)->GetAsDictionary(&entry_dict)) {
+        if (entry->GetAsDictionary(&entry_dict)) {
           em::DeviceLocalAccountInfoProto* account =
               device_local_accounts->add_account();
           std::string account_id;
           if (entry_dict->GetStringWithoutPathExpansion(
                   kAccountsPrefDeviceLocalAccountsKeyId, &account_id)) {
             account->set_account_id(account_id);
           }
           int type;
           if (entry_dict->GetIntegerWithoutPathExpansion(
                   kAccountsPrefDeviceLocalAccountsKeyType, &type)) {
@@ skipping 77 matching lines @@
       NOTREACHED();
   } else if (path == kAccountsPrefUsers) {
     em::UserWhitelistProto* whitelist_proto = settings.mutable_user_whitelist();
     whitelist_proto->clear_user_whitelist();
     const base::ListValue* users;
     if (value.GetAsList(&users)) {
       for (base::ListValue::const_iterator i = users->begin();
            i != users->end();
            ++i) {
         std::string email;
-        if ((*i)->GetAsString(&email))
+        if (i->GetAsString(&email))
           whitelist_proto->add_user_whitelist(email);
       }
     }
   } else if (path == kAccountsPrefEphemeralUsersEnabled) {
     em::EphemeralUsersEnabledProto* ephemeral_users_enabled =
         settings.mutable_ephemeral_users_enabled();
     bool ephemeral_users_enabled_value = false;
     if (value.GetAsBoolean(&ephemeral_users_enabled_value)) {
       ephemeral_users_enabled->set_ephemeral_users_enabled(
           ephemeral_users_enabled_value);
@@ skipping 11 matching lines @@
     }
   } else if (path == kStartUpFlags) {
     em::StartUpFlagsProto* flags_proto = settings.mutable_start_up_flags();
     flags_proto->Clear();
     const base::ListValue* flags;
     if (value.GetAsList(&flags)) {
       for (base::ListValue::const_iterator i = flags->begin();
            i != flags->end();
            ++i) {
         std::string flag;
-        if ((*i)->GetAsString(&flag))
+        if (i->GetAsString(&flag))
           flags_proto->add_flags(flag);
       }
     }
   } else if (path == kSystemUse24HourClock) {
     em::SystemUse24HourClockProto* use_24hour_clock_proto =
         settings.mutable_use_24hour_clock();
     use_24hour_clock_proto->Clear();
     bool use_24hour_clock_value;
     if (value.GetAsBoolean(&use_24hour_clock_value)) {
       use_24hour_clock_proto->set_use_24hour_clock(use_24hour_clock_value);
@@ skipping 124 matching lines @@
 
 void OwnerSettingsServiceChromeOS::ReportStatusAndContinueStoring(
     bool success) {
   store_settings_factory_.InvalidateWeakPtrs();
   for (auto& observer : observers_)
     observer.OnSignedPolicyStored(success);
   StorePendingChanges();
 }
 
 }  // namespace chromeos