Correct const accessors in base/values.(h|cc), Part II (ListValue)

chrome/browser/gpu_blacklist.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 "chrome/browser/gpu_blacklist.h"
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
@@ skipping 297 matching lines @@
           (value2_ <= value && value <= value_));
 }
 
 bool GpuBlacklist::FloatInfo::IsValid() const {
   return op_ != kUnknown;
 }
 
 // static
 GpuBlacklist::ScopedGpuBlacklistEntry
 GpuBlacklist::GpuBlacklistEntry::GetGpuBlacklistEntryFromValue(
-    DictionaryValue* value, bool top_level) {
+    const DictionaryValue* value, bool top_level) {
   DCHECK(value);
   ScopedGpuBlacklistEntry entry(new GpuBlacklistEntry());
 
   size_t dictionary_entry_count = 0;
 
   if (top_level) {
     uint32 id;
     if (!value->GetInteger("id", reinterpret_cast<int*>(&id)) ||
         !entry->SetId(id)) {
       LOG(WARNING) << "Malformed id entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
 
     bool disabled;
     if (value->GetBoolean("disabled", &disabled)) {
       entry->SetDisabled(disabled);
       dictionary_entry_count++;
     }
   }
 
   std::string description;
   if (value->GetString("description", &description)) {
     entry->description_ = description;
     dictionary_entry_count++;
   } else {
     entry->description_ = "The GPU is unavailable for an unexplained reason.";
   }
 
-  ListValue* cr_bugs;
+  const ListValue* cr_bugs;
   if (value->GetList("cr_bugs", &cr_bugs)) {
     for (size_t i = 0; i < cr_bugs->GetSize(); ++i) {
       int bug_id;
       if (cr_bugs->GetInteger(i, &bug_id)) {
         entry->cr_bugs_.push_back(bug_id);
       } else {
         LOG(WARNING) << "Malformed cr_bugs entry " << entry->id();
         return NULL;
       }
     }
     dictionary_entry_count++;
   }
 
-  ListValue* webkit_bugs;
+  const ListValue* webkit_bugs;
   if (value->GetList("webkit_bugs", &webkit_bugs)) {
     for (size_t i = 0; i < webkit_bugs->GetSize(); ++i) {
       int bug_id;
       if (webkit_bugs->GetInteger(i, &bug_id)) {
         entry->webkit_bugs_.push_back(bug_id);
       } else {
         LOG(WARNING) << "Malformed webkit_bugs entry " << entry->id();
         return NULL;
       }
     }
     dictionary_entry_count++;
   }
 
-  DictionaryValue* os_value = NULL;
+  const DictionaryValue* os_value = NULL;
   if (value->GetDictionary("os", &os_value)) {
     std::string os_type;
     std::string os_version_op = "any";
     std::string os_version_string;
     std::string os_version_string2;
     os_value->GetString("type", &os_type);
-    DictionaryValue* os_version_value = NULL;
+    const DictionaryValue* os_version_value = NULL;
     if (os_value->GetDictionary("version", &os_version_value)) {
       os_version_value->GetString("op", &os_version_op);
       os_version_value->GetString("number", &os_version_string);
       os_version_value->GetString("number2", &os_version_string2);
     }
     if (!entry->SetOsInfo(os_type, os_version_op, os_version_string,
                           os_version_string2)) {
       LOG(WARNING) << "Malformed os entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
   std::string vendor_id;
   if (value->GetString("vendor_id", &vendor_id)) {
     if (!entry->SetVendorId(vendor_id)) {
       LOG(WARNING) << "Malformed vendor_id entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  ListValue* device_id_list;
+  const ListValue* device_id_list;
   if (value->GetList("device_id", &device_id_list)) {
     for (size_t i = 0; i < device_id_list->GetSize(); ++i) {
         std::string device_id;
       if (!device_id_list->GetString(i, &device_id) ||
           !entry->AddDeviceId(device_id)) {
         LOG(WARNING) << "Malformed device_id entry " << entry->id();
         return NULL;
       }
     }
     dictionary_entry_count++;
@@ skipping 10 matching lines @@
 
   std::string multi_gpu_category;
   if (value->GetString("multi_gpu_category", &multi_gpu_category)) {
     if (!entry->SetMultiGpuCategory(multi_gpu_category)) {
       LOG(WARNING) << "Malformed multi_gpu_category entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  DictionaryValue* driver_vendor_value = NULL;
+  const DictionaryValue* driver_vendor_value = NULL;
   if (value->GetDictionary("driver_vendor", &driver_vendor_value)) {
     std::string vendor_op;
     std::string vendor_value;
     driver_vendor_value->GetString("op", &vendor_op);
     driver_vendor_value->GetString("value", &vendor_value);
     if (!entry->SetDriverVendorInfo(vendor_op, vendor_value)) {
       LOG(WARNING) << "Malformed driver_vendor entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  DictionaryValue* driver_version_value = NULL;
+  const DictionaryValue* driver_version_value = NULL;
   if (value->GetDictionary("driver_version", &driver_version_value)) {
     std::string driver_version_op = "any";
     std::string driver_version_style;
     std::string driver_version_string;
     std::string driver_version_string2;
     driver_version_value->GetString("op", &driver_version_op);
     driver_version_value->GetString("style", &driver_version_style);
     driver_version_value->GetString("number", &driver_version_string);
     driver_version_value->GetString("number2", &driver_version_string2);
     if (!entry->SetDriverVersionInfo(driver_version_op,
                                      driver_version_style,
                                      driver_version_string,
                                      driver_version_string2)) {
       LOG(WARNING) << "Malformed driver_version entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  DictionaryValue* driver_date_value = NULL;
+  const DictionaryValue* driver_date_value = NULL;
   if (value->GetDictionary("driver_date", &driver_date_value)) {
     std::string driver_date_op = "any";
     std::string driver_date_string;
     std::string driver_date_string2;
     driver_date_value->GetString("op", &driver_date_op);
     driver_date_value->GetString("number", &driver_date_string);
     driver_date_value->GetString("number2", &driver_date_string2);
     if (!entry->SetDriverDateInfo(driver_date_op, driver_date_string,
                                   driver_date_string2)) {
       LOG(WARNING) << "Malformed driver_date entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  DictionaryValue* gl_vendor_value = NULL;
+  const DictionaryValue* gl_vendor_value = NULL;
   if (value->GetDictionary("gl_vendor", &gl_vendor_value)) {
     std::string vendor_op;
     std::string vendor_value;
     gl_vendor_value->GetString("op", &vendor_op);
     gl_vendor_value->GetString("value", &vendor_value);
     if (!entry->SetGLVendorInfo(vendor_op, vendor_value)) {
       LOG(WARNING) << "Malformed gl_vendor entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  DictionaryValue* gl_renderer_value = NULL;
+  const DictionaryValue* gl_renderer_value = NULL;
   if (value->GetDictionary("gl_renderer", &gl_renderer_value)) {
     std::string renderer_op;
     std::string renderer_value;
     gl_renderer_value->GetString("op", &renderer_op);
     gl_renderer_value->GetString("value", &renderer_value);
     if (!entry->SetGLRendererInfo(renderer_op, renderer_value)) {
       LOG(WARNING) << "Malformed gl_renderer entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  DictionaryValue* perf_graphics_value = NULL;
+  const DictionaryValue* perf_graphics_value = NULL;
   if (value->GetDictionary("perf_graphics", &perf_graphics_value)) {
     std::string op;
     std::string float_value;
     std::string float_value2;
     perf_graphics_value->GetString("op", &op);
     perf_graphics_value->GetString("value", &float_value);
     perf_graphics_value->GetString("value2", &float_value2);
     if (!entry->SetPerfGraphicsInfo(op, float_value, float_value2)) {
       LOG(WARNING) << "Malformed perf_graphics entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  DictionaryValue* perf_gaming_value = NULL;
+  const DictionaryValue* perf_gaming_value = NULL;
   if (value->GetDictionary("perf_gaming", &perf_gaming_value)) {
     std::string op;
     std::string float_value;
     std::string float_value2;
     perf_gaming_value->GetString("op", &op);
     perf_gaming_value->GetString("value", &float_value);
     perf_gaming_value->GetString("value2", &float_value2);
     if (!entry->SetPerfGamingInfo(op, float_value, float_value2)) {
       LOG(WARNING) << "Malformed perf_gaming entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  DictionaryValue* perf_overall_value = NULL;
+  const DictionaryValue* perf_overall_value = NULL;
   if (value->GetDictionary("perf_overall", &perf_overall_value)) {
     std::string op;
     std::string float_value;
     std::string float_value2;
     perf_overall_value->GetString("op", &op);
     perf_overall_value->GetString("value", &float_value);
     perf_overall_value->GetString("value2", &float_value2);
     if (!entry->SetPerfOverallInfo(op, float_value, float_value2)) {
       LOG(WARNING) << "Malformed perf_overall entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
   if (top_level) {
-    ListValue* blacklist_value = NULL;
+    const ListValue* blacklist_value = NULL;
     if (!value->GetList("blacklist", &blacklist_value)) {
       LOG(WARNING) << "Malformed blacklist entry " << entry->id();
       return NULL;
     }
     std::vector<std::string> blacklist;
     for (size_t i = 0; i < blacklist_value->GetSize(); ++i) {
       std::string feature;
       if (blacklist_value->GetString(i, &feature)) {
         blacklist.push_back(feature);
       } else {
         LOG(WARNING) << "Malformed blacklist entry " << entry->id();
         return NULL;
       }
     }
     if (!entry->SetBlacklistedFeatures(blacklist)) {
       LOG(WARNING) << "Malformed blacklist entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
   if (top_level) {
-    ListValue* exception_list_value = NULL;
+    const ListValue* exception_list_value = NULL;
     if (value->GetList("exceptions", &exception_list_value)) {
       for (size_t i = 0; i < exception_list_value->GetSize(); ++i) {
-        DictionaryValue* exception_value = NULL;
+        const DictionaryValue* exception_value = NULL;
         if (!exception_list_value->GetDictionary(i, &exception_value)) {
           LOG(WARNING) << "Malformed exceptions entry " << entry->id();
           return NULL;
         }
         ScopedGpuBlacklistEntry exception(
             GetGpuBlacklistEntryFromValue(exception_value, false));
         if (exception == NULL) {
           LOG(WARNING) << "Malformed exceptions entry " << entry->id();
           return NULL;
         }
         if (exception->contains_unknown_fields_) {
           LOG(WARNING) << "Exception with unknown fields " << entry->id();
           entry->contains_unknown_fields_ = true;
         } else {
           entry->AddException(exception);
         }
       }
       dictionary_entry_count++;
     }
 
-    DictionaryValue* browser_version_value = NULL;
+    const DictionaryValue* browser_version_value = NULL;
     // browser_version is processed in LoadGpuBlacklist().
     if (value->GetDictionary("browser_version", &browser_version_value))
       dictionary_entry_count++;
   }
 
   if (value->size() != dictionary_entry_count) {
     LOG(WARNING) << "Entry with unknown fields " << entry->id();
     entry->contains_unknown_fields_ = true;
   }
   return entry;
@@ skipping 352 matching lines @@
   if (!version_->IsValid())
     return false;
 
   const ListValue* list = NULL;
   if (!parsed_json.GetList("entries", &list))
     return false;
 
   uint32 max_entry_id = 0;
   bool contains_unknown_fields = false;
   for (size_t i = 0; i < list->GetSize(); ++i) {
-    DictionaryValue* list_item = NULL;
+    const DictionaryValue* list_item = NULL;
     bool valid = list->GetDictionary(i, &list_item);
     if (!valid || list_item == NULL)
       return false;
     // Check browser version compatibility: if the entry is not for the
     // current browser version, don't process it.
     BrowserVersionSupport browser_version_support =
         IsEntrySupportedByCurrentBrowserVersion(list_item);
     if (browser_version_support == kMalformed)
       return false;
     if (browser_version_support == kUnsupported)
@@ skipping 142 matching lines @@
 
 void GpuBlacklist::Clear() {
   blacklist_.clear();
   active_entries_.clear();
   max_entry_id_ = 0;
   contains_unknown_fields_ = false;
 }
 
 GpuBlacklist::BrowserVersionSupport
 GpuBlacklist::IsEntrySupportedByCurrentBrowserVersion(
-    DictionaryValue* value) {
+    const DictionaryValue* value) {
   DCHECK(value);
-  DictionaryValue* browser_version_value = NULL;
+  const DictionaryValue* browser_version_value = NULL;
   if (value->GetDictionary("browser_version", &browser_version_value)) {
     std::string version_op = "any";
     std::string version_string;
     std::string version_string2;
     browser_version_value->GetString("op", &version_op);
     browser_version_value->GetString("number", &version_string);
     browser_version_value->GetString("number2", &version_string2);
     scoped_ptr<VersionInfo> browser_version_info;
     browser_version_info.reset(
         new VersionInfo(version_op, "", version_string, version_string2));
@@ skipping 22 matching lines @@
   if (op == ">")
     return kGT;
   if (op == ">=")
     return kGE;
   if (op == "any")
     return kAny;
   if (op == "between")
     return kBetween;
   return kUnknown;
 }