Make base::Value::TYPE a scoped enum.

components/sync_preferences/pref_model_associator.cc

 // Copyright (c) 2012 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 "components/sync_preferences/pref_model_associator.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/json/json_reader.h"
@@ skipping 83 matching lines @@
 
     if (user_pref_value) {
       DVLOG(1) << "Found user pref value for " << pref_name;
       // We have both server and local values. Merge them.
       std::unique_ptr<base::Value> new_value(
           MergePreference(pref_name, *user_pref_value, *sync_value));
 
       // Update the local preference based on what we got from the
       // sync server. Note: this only updates the user value store, which is
       // ignored if the preference is policy controlled.
-      if (new_value->IsType(base::Value::TYPE_NULL)) {
+      if (new_value->IsType(base::Value::Type::NONE)) {
         LOG(WARNING) << "Sync has null value for pref " << pref_name.c_str();
         pref_service_->ClearPref(pref_name.c_str());
       } else if (!new_value->IsType(user_pref_value->GetType())) {
         LOG(WARNING) << "Synced value for " << preference.name()
                      << " is of type " << new_value->GetType()
                      << " which doesn't match pref type "
                      << user_pref_value->GetType();
       } else if (!user_pref_value->Equals(new_value.get())) {
         pref_service_->Set(pref_name.c_str(), *new_value);
       }
 
       // If the merge resulted in an updated value, inform the syncer.
       if (!sync_value->Equals(new_value.get())) {
         syncer::SyncData sync_data;
         if (!CreatePrefSyncData(pref_name, *new_value, &sync_data)) {
           LOG(ERROR) << "Failed to update preference.";
           return;
         }
 
         sync_changes->push_back(syncer::SyncChange(
             FROM_HERE, syncer::SyncChange::ACTION_UPDATE, sync_data));
       }
-    } else if (!sync_value->IsType(base::Value::TYPE_NULL)) {
+    } else if (!sync_value->IsType(base::Value::Type::NONE)) {
       // Only a server value exists. Just set the local user value.
       pref_service_->Set(pref_name.c_str(), *sync_value);
     } else {
       LOG(WARNING) << "Sync has null value for pref " << pref_name.c_str();
     }
     synced_preferences_.insert(preference.name());
   } else if (user_pref_value) {
     // The server does not know about this preference and should be added
     // to the syncer's database.
     syncer::SyncData sync_data;
@@ skipping 106 matching lines @@
   }
 
   // If this is not a specially handled preference, server wins.
   return base::WrapUnique(server_value.DeepCopy());
 }
 
 bool PrefModelAssociator::CreatePrefSyncData(
     const std::string& name,
     const base::Value& value,
     syncer::SyncData* sync_data) const {
-  if (value.IsType(base::Value::TYPE_NULL)) {
+  if (value.IsType(base::Value::Type::NONE)) {
     LOG(ERROR) << "Attempting to sync a null pref value for " << name;
     return false;
   }
 
   std::string serialized;
   // TODO(zea): consider JSONWriter::Write since you don't have to check
   // failures to deserialize.
   JSONStringValueSerializer json(&serialized);
   if (!json.Serialize(value)) {
     LOG(ERROR) << "Failed to serialize preference value.";
     return false;
   }
 
   sync_pb::EntitySpecifics specifics;
   sync_pb::PreferenceSpecifics* pref_specifics =
       GetMutableSpecifics(type_, &specifics);
 
   pref_specifics->set_name(name);
   pref_specifics->set_value(serialized);
   *sync_data = syncer::SyncData::CreateLocalData(name, name, specifics);
   return true;
 }
 
 base::Value* PrefModelAssociator::MergeListValues(const base::Value& from_value,
                                                   const base::Value& to_value) {
-  if (from_value.GetType() == base::Value::TYPE_NULL)
+  if (from_value.GetType() == base::Value::Type::NONE)
     return to_value.DeepCopy();
-  if (to_value.GetType() == base::Value::TYPE_NULL)
+  if (to_value.GetType() == base::Value::Type::NONE)
     return from_value.DeepCopy();
 
-  DCHECK(from_value.GetType() == base::Value::TYPE_LIST);
-  DCHECK(to_value.GetType() == base::Value::TYPE_LIST);
+  DCHECK(from_value.GetType() == base::Value::Type::LIST);
+  DCHECK(to_value.GetType() == base::Value::Type::LIST);
   const base::ListValue& from_list_value =
       static_cast<const base::ListValue&>(from_value);
   const base::ListValue& to_list_value =
       static_cast<const base::ListValue&>(to_value);
   base::ListValue* result = to_list_value.DeepCopy();
 
   for (const auto& value : from_list_value) {
     result->AppendIfNotPresent(value->CreateDeepCopy());
   }
   return result;
 }
 
 base::Value* PrefModelAssociator::MergeDictionaryValues(
     const base::Value& from_value,
     const base::Value& to_value) {
-  if (from_value.GetType() == base::Value::TYPE_NULL)
+  if (from_value.GetType() == base::Value::Type::NONE)
     return to_value.DeepCopy();
-  if (to_value.GetType() == base::Value::TYPE_NULL)
+  if (to_value.GetType() == base::Value::Type::NONE)
     return from_value.DeepCopy();
 
-  DCHECK_EQ(from_value.GetType(), base::Value::TYPE_DICTIONARY);
-  DCHECK_EQ(to_value.GetType(), base::Value::TYPE_DICTIONARY);
+  DCHECK_EQ(from_value.GetType(), base::Value::Type::DICTIONARY);
+  DCHECK_EQ(to_value.GetType(), base::Value::Type::DICTIONARY);
   const base::DictionaryValue& from_dict_value =
       static_cast<const base::DictionaryValue&>(from_value);
   const base::DictionaryValue& to_dict_value =
       static_cast<const base::DictionaryValue&>(to_value);
   base::DictionaryValue* result = to_dict_value.DeepCopy();
 
   for (base::DictionaryValue::Iterator it(from_dict_value); !it.IsAtEnd();
        it.Advance()) {
     const base::Value* from_key_value = &it.value();
     base::Value* to_key_value;
     if (result->GetWithoutPathExpansion(it.key(), &to_key_value)) {
-      if (from_key_value->GetType() == base::Value::TYPE_DICTIONARY &&
-          to_key_value->GetType() == base::Value::TYPE_DICTIONARY) {
+      if (from_key_value->GetType() == base::Value::Type::DICTIONARY &&
+          to_key_value->GetType() == base::Value::Type::DICTIONARY) {
         base::Value* merged_value =
             MergeDictionaryValues(*from_key_value, *to_key_value);
         result->SetWithoutPathExpansion(it.key(), merged_value);
       }
       // Note that for all other types we want to preserve the "to"
       // values so we do nothing here.
     } else {
       result->SetWithoutPathExpansion(it.key(), from_key_value->DeepCopy());
     }
   }
@@ skipping 193 matching lines @@
                                                     bool from_sync) const {
   auto observer_iter = synced_pref_observers_.find(path);
   if (observer_iter == synced_pref_observers_.end())
     return;
   SyncedPrefObserverList* observers = observer_iter->second.get();
   for (auto& observer : *observers)
     observer.OnSyncedPrefChanged(path, from_sync);
 }
 
 }  // namespace sync_preferences