Cleanup: Remove deprecated base::Value methods from contents. Use base::Value too.

content/browser/gpu/gpu_internals_ui.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 "content/browser/gpu/gpu_internals_ui.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 31 matching lines @@
 
 WebUIDataSource* CreateGpuHTMLSource() {
   WebUIDataSource* source = WebUIDataSource::Create(chrome::kChromeUIGpuHost);
 
   source->SetJsonPath("strings.js");
   source->AddResourcePath("gpu_internals.js", IDR_GPU_INTERNALS_JS);
   source->SetDefaultResource(IDR_GPU_INTERNALS_HTML);
   return source;
 }
 
-DictionaryValue* NewDescriptionValuePair(const std::string& desc,
+base::DictionaryValue* NewDescriptionValuePair(const std::string& desc,
     const std::string& value) {
-  DictionaryValue* dict = new DictionaryValue();
+  base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("description", desc);
   dict->SetString("value", value);
   return dict;
 }
 
-DictionaryValue* NewDescriptionValuePair(const std::string& desc,
+base::DictionaryValue* NewDescriptionValuePair(const std::string& desc,
     Value* value) {
-  DictionaryValue* dict = new DictionaryValue();
+  base::DictionaryValue* dict = new base::DictionaryValue();
   dict->SetString("description", desc);
   dict->Set("value", value);
   return dict;
 }
 
-Value* NewStatusValue(const char* name, const char* status) {
-  DictionaryValue* value = new DictionaryValue();
+base::Value* NewStatusValue(const char* name, const char* status) {
+  base::DictionaryValue* value = new base::DictionaryValue();
   value->SetString("name", name);
   value->SetString("status", status);
   return value;
 }
 
 #if defined(OS_WIN)
 // Output DxDiagNode tree as nested array of {description,value} pairs
-ListValue* DxDiagNodeToList(const DxDiagNode& node) {
-  ListValue* list = new ListValue();
+base::ListValue* DxDiagNodeToList(const DxDiagNode& node) {
+  base::ListValue* list = new ListValue();
   for (std::map<std::string, std::string>::const_iterator it =
       node.values.begin();
       it != node.values.end();
       ++it) {
     list->Append(NewDescriptionValuePair(it->first, it->second));
   }
 
   for (std::map<std::string, DxDiagNode>::const_iterator it =
       node.children.begin();
       it != node.children.end();
       ++it) {
-    ListValue* sublist = DxDiagNodeToList(it->second);
+    base::ListValue* sublist = DxDiagNodeToList(it->second);
     list->Append(NewDescriptionValuePair(it->first, sublist));
   }
   return list;
 }
 #endif
 
 std::string GPUDeviceToString(const GPUInfo::GPUDevice& gpu) {
   std::string vendor = base::StringPrintf("0x%04x", gpu.vendor_id);
   if (!gpu.vendor_string.empty())
     vendor += " [" + gpu.vendor_string + "]";
   std::string device = base::StringPrintf("0x%04x", gpu.device_id);
   if (!gpu.device_string.empty())
     device += " [" + gpu.device_string + "]";
   return base::StringPrintf(
       "VENDOR = %s, DEVICE= %s", vendor.c_str(), device.c_str());
 }
 
-DictionaryValue* GpuInfoAsDictionaryValue() {
+base::DictionaryValue* GpuInfoAsDictionaryValue() {
   GPUInfo gpu_info = GpuDataManagerImpl::GetInstance()->GetGPUInfo();
-  ListValue* basic_info = new ListValue();
+  base::ListValue* basic_info = new base::ListValue();
   basic_info->Append(NewDescriptionValuePair(
       "Initialization time",
       base::Int64ToString(gpu_info.initialization_time.InMilliseconds())));
   basic_info->Append(NewDescriptionValuePair(
-      "Sandboxed",
-      Value::CreateBooleanValue(gpu_info.sandboxed)));
+      "Sandboxed", new base::FundamentalValue(gpu_info.sandboxed)));
   basic_info->Append(NewDescriptionValuePair(
       "GPU0", GPUDeviceToString(gpu_info.gpu)));
   for (size_t i = 0; i < gpu_info.secondary_gpus.size(); ++i) {
     basic_info->Append(NewDescriptionValuePair(
         base::StringPrintf("GPU%d", static_cast<int>(i + 1)),
         GPUDeviceToString(gpu_info.secondary_gpus[i])));
   }
   basic_info->Append(NewDescriptionValuePair(
-      "Optimus", Value::CreateBooleanValue(gpu_info.optimus)));
+      "Optimus", new base::FundamentalValue(gpu_info.optimus)));
   basic_info->Append(NewDescriptionValuePair(
-      "AMD switchable", Value::CreateBooleanValue(gpu_info.amd_switchable)));
+      "AMD switchable", new base::FundamentalValue(gpu_info.amd_switchable)));
   basic_info->Append(NewDescriptionValuePair("Driver vendor",
                                              gpu_info.driver_vendor));
   basic_info->Append(NewDescriptionValuePair("Driver version",
                                              gpu_info.driver_version));
   basic_info->Append(NewDescriptionValuePair("Driver date",
                                              gpu_info.driver_date));
   basic_info->Append(NewDescriptionValuePair("Pixel shader version",
                                              gpu_info.pixel_shader_version));
   basic_info->Append(NewDescriptionValuePair("Vertex shader version",
                                              gpu_info.vertex_shader_version));
   basic_info->Append(NewDescriptionValuePair("Machine model",
                                              gpu_info.machine_model));
   basic_info->Append(NewDescriptionValuePair("GL version",
                                              gpu_info.gl_version));
   basic_info->Append(NewDescriptionValuePair("GL_VENDOR",
                                              gpu_info.gl_vendor));
   basic_info->Append(NewDescriptionValuePair("GL_RENDERER",
                                              gpu_info.gl_renderer));
   basic_info->Append(NewDescriptionValuePair("GL_VERSION",
                                              gpu_info.gl_version_string));
   basic_info->Append(NewDescriptionValuePair("GL_EXTENSIONS",
                                              gpu_info.gl_extensions));
 
-  DictionaryValue* info = new DictionaryValue();
+  base::DictionaryValue* info = new base::DictionaryValue();
   info->Set("basic_info", basic_info);
 
 #if defined(OS_WIN)
-  ListValue* perf_info = new ListValue();
+  base::ListValue* perf_info = new base::ListValue();
   perf_info->Append(NewDescriptionValuePair(
       "Graphics",
       base::StringPrintf("%.1f", gpu_info.performance_stats.graphics)));
   perf_info->Append(NewDescriptionValuePair(
       "Gaming",
       base::StringPrintf("%.1f", gpu_info.performance_stats.gaming)));
   perf_info->Append(NewDescriptionValuePair(
       "Overall",
       base::StringPrintf("%.1f", gpu_info.performance_stats.overall)));
   info->Set("performance_info", perf_info);
 
-  Value* dx_info;
-  if (gpu_info.dx_diagnostics.children.size())
-    dx_info = DxDiagNodeToList(gpu_info.dx_diagnostics);
-  else
-    dx_info = Value::CreateNullValue();
+  base::Value* dx_info = gpu_info.dx_diagnostics.children.size() ?
+    DxDiagNodeToList(gpu_info.dx_diagnostics) :
+    base::Value::CreateNullValue();
   info->Set("diagnostics", dx_info);
 #endif
 
   return info;
 }
 
 // Determine if accelerated-2d-canvas is supported, which depends on whether
 // lose_context could happen and whether skia is the backend.
 bool SupportsAccelerated2dCanvas() {
   if (GpuDataManagerImpl::GetInstance()->GetGPUInfo().can_lose_context)
     return false;
 #if defined(USE_SKIA)
   return true;
 #else
   return false;
 #endif
 }
 
-Value* GetFeatureStatus() {
+base::Value* GetFeatureStatus() {
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   bool gpu_access_blocked =
       !GpuDataManagerImpl::GetInstance()->GpuAccessAllowed();
 
   uint32 flags = GpuDataManagerImpl::GetInstance()->GetBlacklistedFeatures();
-  DictionaryValue* status = new DictionaryValue();
+  base::DictionaryValue* status = new base::DictionaryValue();
 
   const GpuFeatureInfo kGpuFeatureInfo[] = {
       {
           "2d_canvas",
           flags & GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS,
           command_line.HasSwitch(switches::kDisableAccelerated2dCanvas) ||
           !SupportsAccelerated2dCanvas(),
           "Accelerated 2D canvas is unavailable: either disabled at the command"
           " line or not supported by the current system.",
           true
@@ skipping 105 matching lines @@
           !(flags & GPU_FEATURE_TYPE_FORCE_COMPOSITING_MODE),
           "Force compositing mode is off, either disabled at the command"
           " line or not supported by the current system.",
           false
       }
   };
   const size_t kNumFeatures = sizeof(kGpuFeatureInfo) / sizeof(GpuFeatureInfo);
 
   // Build the feature_status field.
   {
-    ListValue* feature_status_list = new ListValue();
+    base::ListValue* feature_status_list = new base::ListValue();
 
     for (size_t i = 0; i < kNumFeatures; ++i) {
       // force_compositing_mode status is part of the compositing status.
       if (kGpuFeatureInfo[i].name == "force_compositing_mode")
         continue;
 
       std::string status;
       if (kGpuFeatureInfo[i].disabled) {
         status = "disabled";
         if (kGpuFeatureInfo[i].name == "css_animation") {
@@ skipping 56 matching lines @@
           break;
       }
       feature_status_list->Append(
           NewStatusValue("gpu_switching", gpu_switching.c_str()));
     }
     status->Set("featureStatus", feature_status_list);
   }
 
   // Build the problems list.
   {
-    ListValue* problem_list =
+    base::ListValue* problem_list =
         GpuDataManagerImpl::GetInstance()->GetBlacklistReasons();
 
     if (gpu_access_blocked) {
-      DictionaryValue* problem = new DictionaryValue();
+      base::DictionaryValue* problem = new base::DictionaryValue();
       problem->SetString("description",
           "GPU process was unable to boot. Access to GPU disallowed.");
-      problem->Set("crBugs", new ListValue());
-      problem->Set("webkitBugs", new ListValue());
+      problem->Set("crBugs", new base::ListValue());
+      problem->Set("webkitBugs", new base::ListValue());
       problem_list->Append(problem);
     }
 
     for (size_t i = 0; i < kNumFeatures; ++i) {
       if (kGpuFeatureInfo[i].disabled) {
-        DictionaryValue* problem = new DictionaryValue();
+        base::DictionaryValue* problem = new base::DictionaryValue();
         problem->SetString(
             "description", kGpuFeatureInfo[i].disabled_description);
-        problem->Set("crBugs", new ListValue());
-        problem->Set("webkitBugs", new ListValue());
+        problem->Set("crBugs", new base::ListValue());
+        problem->Set("webkitBugs", new base::ListValue());
         problem_list->Append(problem);
       }
     }
 
     status->Set("problems", problem_list);
   }
 
   return status;
 }
 
@@ skipping 10 matching lines @@
 
   // WebUIMessageHandler implementation.
   virtual void RegisterMessages() OVERRIDE;
 
   // GpuDataManagerObserver implementation.
   virtual void OnGpuInfoUpdate() OVERRIDE;
   virtual void OnVideoMemoryUsageStatsUpdate(
       const GPUVideoMemoryUsageStats& video_memory_usage_stats) OVERRIDE {}
 
   // Messages
-  void OnBrowserBridgeInitialized(const ListValue* list);
-  void OnCallAsync(const ListValue* list);
+  void OnBrowserBridgeInitialized(const base::ListValue* list);
+  void OnCallAsync(const base::ListValue* list);
 
   // Submessages dispatched from OnCallAsync
-  Value* OnRequestClientInfo(const ListValue* list);
-  Value* OnRequestLogMessages(const ListValue* list);
+  base::Value* OnRequestClientInfo(const base::ListValue* list);
+  base::Value* OnRequestLogMessages(const base::ListValue* list);
 
  private:
   // True if observing the GpuDataManager (re-attaching as observer would
   // DCHECK).
   bool observing_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuMessageHandler);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ skipping 15 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   web_ui()->RegisterMessageCallback("browserBridgeInitialized",
       base::Bind(&GpuMessageHandler::OnBrowserBridgeInitialized,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback("callAsync",
       base::Bind(&GpuMessageHandler::OnCallAsync,
                  base::Unretained(this)));
 }
 
-void GpuMessageHandler::OnCallAsync(const ListValue* args) {
+void GpuMessageHandler::OnCallAsync(const base::ListValue* args) {
   DCHECK_GE(args->GetSize(), static_cast<size_t>(2));
   // unpack args into requestId, submessage and submessageArgs
   bool ok;
-  const Value* requestId;
+  const base::Value* requestId;
   ok = args->Get(0, &requestId);
   DCHECK(ok);
 
   std::string submessage;
   ok = args->GetString(1, &submessage);
   DCHECK(ok);
 
-  ListValue* submessageArgs = new ListValue();
+  base::ListValue* submessageArgs = new base::ListValue();
   for (size_t i = 2; i < args->GetSize(); ++i) {
-    const Value* arg;
+    const base::Value* arg;
     ok = args->Get(i, &arg);
     DCHECK(ok);
 
-    Value* argCopy = arg->DeepCopy();
+    base::Value* argCopy = arg->DeepCopy();
     submessageArgs->Append(argCopy);
   }
 
   // call the submessage handler
-  Value* ret = NULL;
+  base::Value* ret = NULL;
   if (submessage == "requestClientInfo") {
     ret = OnRequestClientInfo(submessageArgs);
   } else if (submessage == "requestLogMessages") {
     ret = OnRequestLogMessages(submessageArgs);
   } else {  // unrecognized submessage
     NOTREACHED();
     delete submessageArgs;
     return;
   }
   delete submessageArgs;
 
   // call BrowserBridge.onCallAsyncReply with result
   if (ret) {
     web_ui()->CallJavascriptFunction("browserBridge.onCallAsyncReply",
         *requestId,
         *ret);
     delete ret;
   } else {
     web_ui()->CallJavascriptFunction("browserBridge.onCallAsyncReply",
         *requestId);
   }
 }
 
-void GpuMessageHandler::OnBrowserBridgeInitialized(const ListValue* args) {
+void GpuMessageHandler::OnBrowserBridgeInitialized(
+    const base::ListValue* args) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Watch for changes in GPUInfo
   if (!observing_)
     GpuDataManagerImpl::GetInstance()->AddObserver(this);
   observing_ = true;
 
   // Tell GpuDataManager it should have full GpuInfo. If the
   // Gpu process has not run yet, this will trigger its launch.
   GpuDataManagerImpl::GetInstance()->RequestCompleteGpuInfoIfNeeded();
 
   // Run callback immediately in case the info is ready and no update in the
   // future.
   OnGpuInfoUpdate();
 }
 
-Value* GpuMessageHandler::OnRequestClientInfo(const ListValue* list) {
+base::Value* GpuMessageHandler::OnRequestClientInfo(
+    const base::ListValue* list) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  DictionaryValue* dict = new DictionaryValue();
+  base::DictionaryValue* dict = new base::DictionaryValue();
 
   dict->SetString("version", GetContentClient()->GetProduct());
   dict->SetString("command_line",
       CommandLine::ForCurrentProcess()->GetCommandLineString());
   dict->SetString("operating_system",
                   base::SysInfo::OperatingSystemName() + " " +
                   base::SysInfo::OperatingSystemVersion());
   dict->SetString("angle_revision", base::UintToString(BUILD_REVISION));
 #if defined(USE_SKIA)
   dict->SetString("graphics_backend", "Skia");
 #else
   dict->SetString("graphics_backend", "Core Graphics");
 #endif
   dict->SetString("blacklist_version",
       GpuDataManagerImpl::GetInstance()->GetBlacklistVersion());
 
   return dict;
 }
 
-Value* GpuMessageHandler::OnRequestLogMessages(const ListValue*) {
+base::Value* GpuMessageHandler::OnRequestLogMessages(const base::ListValue*) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   return GpuDataManagerImpl::GetInstance()->GetLogMessages();
 }
 
 void GpuMessageHandler::OnGpuInfoUpdate() {
   // Get GPU Info.
-  scoped_ptr<base::DictionaryValue> gpu_info_val(
-      GpuInfoAsDictionaryValue());
+  scoped_ptr<base::DictionaryValue> gpu_info_val(GpuInfoAsDictionaryValue());
 
   // Add in blacklisting features
-  Value* feature_status = GetFeatureStatus();
+  base::Value* feature_status = GetFeatureStatus();
   if (feature_status)
     gpu_info_val->Set("featureStatus", feature_status);
 
   // Send GPU Info to javascript.
   web_ui()->CallJavascriptFunction("browserBridge.onGpuInfoUpdate",
       *(gpu_info_val.get()));
 }
 
 }  // namespace
 
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // GpuInternalsUI
 //
 ////////////////////////////////////////////////////////////////////////////////
 
 GpuInternalsUI::GpuInternalsUI(WebUI* web_ui)
     : WebUIController(web_ui) {
   web_ui->AddMessageHandler(new GpuMessageHandler());
 
   // Set up the chrome://gpu/ source.
   BrowserContext* browser_context =
       web_ui->GetWebContents()->GetBrowserContext();
   WebUIDataSource::Add(browser_context, CreateGpuHTMLSource());
 }
 
 }  // namespace content