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

extensions/browser/api/storage/storage_api.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 "extensions/browser/api/storage/storage_api.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 131 matching lines @@
 
 }  // namespace
 
 ExtensionFunction::ResponseValue StorageStorageAreaGetFunction::RunWithStorage(
     ValueStore* storage) {
   base::Value* input = NULL;
   if (!args_->Get(0, &input))
     return BadMessage();
 
   switch (input->GetType()) {
-    case base::Value::TYPE_NULL:
+    case base::Value::Type::NONE:
       return UseReadResult(storage->Get());
 
-    case base::Value::TYPE_STRING: {
+    case base::Value::Type::STRING: {
       std::string as_string;
       input->GetAsString(&as_string);
       return UseReadResult(storage->Get(as_string));
     }
 
-    case base::Value::TYPE_LIST: {
+    case base::Value::Type::LIST: {
       std::vector<std::string> as_string_list;
       AddAllStringValues(*static_cast<base::ListValue*>(input),
                          &as_string_list);
       return UseReadResult(storage->Get(as_string_list));
     }
 
-    case base::Value::TYPE_DICTIONARY: {
+    case base::Value::Type::DICTIONARY: {
       base::DictionaryValue* as_dict =
           static_cast<base::DictionaryValue*>(input);
       ValueStore::ReadResult result = storage->Get(GetKeys(*as_dict));
       if (!result->status().ok()) {
         return UseReadResult(std::move(result));
       }
 
       base::DictionaryValue* with_default_values = as_dict->DeepCopy();
       with_default_values->MergeDictionary(&result->settings());
       return UseReadResult(ValueStore::MakeReadResult(
           base::WrapUnique(with_default_values), result->status()));
     }
 
     default:
       return BadMessage();
   }
 }
 
 ExtensionFunction::ResponseValue
 StorageStorageAreaGetBytesInUseFunction::RunWithStorage(ValueStore* storage) {
   base::Value* input = NULL;
   if (!args_->Get(0, &input))
     return BadMessage();
 
   size_t bytes_in_use = 0;
 
   switch (input->GetType()) {
-    case base::Value::TYPE_NULL:
+    case base::Value::Type::NONE:
       bytes_in_use = storage->GetBytesInUse();
       break;
 
-    case base::Value::TYPE_STRING: {
+    case base::Value::Type::STRING: {
       std::string as_string;
       input->GetAsString(&as_string);
       bytes_in_use = storage->GetBytesInUse(as_string);
       break;
     }
 
-    case base::Value::TYPE_LIST: {
+    case base::Value::Type::LIST: {
       std::vector<std::string> as_string_list;
       AddAllStringValues(*static_cast<base::ListValue*>(input),
                          &as_string_list);
       bytes_in_use = storage->GetBytesInUse(as_string_list);
       break;
     }
 
     default:
       return BadMessage();
   }
@@ skipping 15 matching lines @@
   GetModificationQuotaLimitHeuristics(heuristics);
 }
 
 ExtensionFunction::ResponseValue
 StorageStorageAreaRemoveFunction::RunWithStorage(ValueStore* storage) {
   base::Value* input = NULL;
   if (!args_->Get(0, &input))
     return BadMessage();
 
   switch (input->GetType()) {
-    case base::Value::TYPE_STRING: {
+    case base::Value::Type::STRING: {
       std::string as_string;
       input->GetAsString(&as_string);
       return UseWriteResult(storage->Remove(as_string));
     }
 
-    case base::Value::TYPE_LIST: {
+    case base::Value::Type::LIST: {
       std::vector<std::string> as_string_list;
       AddAllStringValues(*static_cast<base::ListValue*>(input),
                          &as_string_list);
       return UseWriteResult(storage->Remove(as_string_list));
     }
 
     default:
       return BadMessage();
   }
 }
 
 void StorageStorageAreaRemoveFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
   GetModificationQuotaLimitHeuristics(heuristics);
 }
 
 ExtensionFunction::ResponseValue
 StorageStorageAreaClearFunction::RunWithStorage(ValueStore* storage) {
   return UseWriteResult(storage->Clear());
 }
 
 void StorageStorageAreaClearFunction::GetQuotaLimitHeuristics(
     QuotaLimitHeuristics* heuristics) const {
   GetModificationQuotaLimitHeuristics(heuristics);
 }
 
 }  // namespace extensions