more changes

chrome/browser/ui/webui/task_manager_handler.cc

 // Copyright (c) 2011 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/ui/webui/task_manager_handler.h"
 
 #include <algorithm>
 #include <functional>
 #include "base/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "chrome/browser/ui/webui/web_ui_util.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "content/common/notification_service.h"
 #include "content/common/notification_source.h"
 #include "third_party/skia/include/core/SkBitmap.h"
 
 namespace {
 
 static Value* CreateColumnValue(const TaskManagerModel* tm,
                                 const std::string column_name,
                                 const int i) {
   if (column_name == "processId")
-    return Value::CreateStringValue(tm->GetResourceProcessId(i));
+    return base::StringValue::New(tm->GetResourceProcessId(i));
   if (column_name == "processIdValue")
-    return Value::CreateIntegerValue(tm->GetProcessId(i));
+    return base::NumberValue::New(tm->GetProcessId(i));
   if (column_name == "cpuUsage")
-    return Value::CreateStringValue(tm->GetResourceCPUUsage(i));
+    return base::StringValue::New(tm->GetResourceCPUUsage(i));
   if (column_name == "cpuUsageValue")
-    return Value::CreateDoubleValue(tm->GetCPUUsage(i));
+    return base::NumberValue::New(tm->GetCPUUsage(i));
   if (column_name == "privateMemory")
-    return Value::CreateStringValue(tm->GetResourcePrivateMemory(i));
+    return base::StringValue::New(tm->GetResourcePrivateMemory(i));
   if (column_name == "privateMemoryValue") {
     size_t private_memory;
     tm->GetPrivateMemory(i, &private_memory);
-    return Value::CreateDoubleValue(private_memory);
+    return base::NumberValue::New(static_cast<int>(private_memory));
   }
   if (column_name == "sharedMemory")
-    return Value::CreateStringValue(tm->GetResourceSharedMemory(i));
+    return base::StringValue::New(tm->GetResourceSharedMemory(i));
   if (column_name == "sharedMemoryValue") {
     size_t shared_memory;
     tm->GetSharedMemory(i, &shared_memory);
-    return Value::CreateDoubleValue(shared_memory);
+    return base::NumberValue::New(static_cast<int>(shared_memory));
   }
   if (column_name == "physicalMemory")
-    return Value::CreateStringValue(tm->GetResourcePhysicalMemory(i));
+    return base::StringValue::New(tm->GetResourcePhysicalMemory(i));
   if (column_name == "physicalMemoryValue") {
     size_t physical_memory;
     tm->GetPhysicalMemory(i, &physical_memory);
-    return Value::CreateDoubleValue(physical_memory);
+    return base::NumberValue::New(static_cast<int>(physical_memory));
   }
   if (column_name == "icon")
-    return Value::CreateStringValue(
+    return base::StringValue::New(
                web_ui_util::GetImageDataUrl(tm->GetResourceIcon(i)));
   if (column_name == "title")
-    return Value::CreateStringValue(tm->GetResourceTitle(i));
+    return base::StringValue::New(tm->GetResourceTitle(i));
   if (column_name == "networkUsage")
-    return Value::CreateStringValue(tm->GetResourceNetworkUsage(i));
+    return base::StringValue::New(tm->GetResourceNetworkUsage(i));
   if (column_name == "networkUsageValue")
-    return Value::CreateDoubleValue(tm->GetNetworkUsage(i));
+    return base::NumberValue::New(static_cast<int>(tm->GetNetworkUsage(i)));
   if (column_name == "webCoreImageCacheSize")
-    return Value::CreateStringValue(tm->GetResourceWebCoreImageCacheSize(i));
+    return base::StringValue::New(tm->GetResourceWebCoreImageCacheSize(i));
   if (column_name == "webCoreImageCacheSizeValue") {
     WebKit::WebCache::ResourceTypeStats resource_stats;
     tm->GetWebCoreCacheStats(i, &resource_stats);
-    return Value::CreateDoubleValue(resource_stats.images.size);
+    return base::NumberValue::New(static_cast<int>(resource_stats.images.size));
   }
   if (column_name == "webCoreScriptsCacheSize")
-    return Value::CreateStringValue(tm->GetResourceWebCoreScriptsCacheSize(i));
+    return base::StringValue::New(tm->GetResourceWebCoreScriptsCacheSize(i));
   if (column_name == "webCoreScriptsCacheSizeValue") {
     WebKit::WebCache::ResourceTypeStats resource_stats;
     tm->GetWebCoreCacheStats(i, &resource_stats);
-    return Value::CreateDoubleValue(resource_stats.scripts.size);
+    return base::NumberValue::New(
+        static_cast<int>(resource_stats.scripts.size));
   }
   if (column_name == "webCoreCSSCacheSize")
-    return Value::CreateStringValue(tm->GetResourceWebCoreCSSCacheSize(i));
+    return base::StringValue::New(tm->GetResourceWebCoreCSSCacheSize(i));
   if (column_name == "webCoreCSSCacheSizeValue") {
     WebKit::WebCache::ResourceTypeStats resource_stats;
     tm->GetWebCoreCacheStats(i, &resource_stats);
-    return Value::CreateDoubleValue(resource_stats.cssStyleSheets.size);
+    return base::NumberValue::New(
+        static_cast<int>(resource_stats.cssStyleSheets.size));
   }
   if (column_name == "fps")
-    return Value::CreateStringValue(tm->GetResourceFPS(i));
+    return base::StringValue::New(tm->GetResourceFPS(i));
   if (column_name == "fpsValue") {
     float fps;
     tm->GetFPS(i, &fps);
-    return Value::CreateDoubleValue(fps);
+    return base::NumberValue::New(fps);
   }
   if (column_name == "sqliteMemoryUsed")
-    return Value::CreateStringValue(tm->GetResourceSqliteMemoryUsed(i));
+    return base::StringValue::New(tm->GetResourceSqliteMemoryUsed(i));
   if (column_name == "sqliteMemoryUsedValue") {
     size_t sqlite_memory;
     tm->GetSqliteMemoryUsedBytes(i, &sqlite_memory);
-    return Value::CreateDoubleValue(sqlite_memory);
+    return base::NumberValue::New(static_cast<int>(sqlite_memory));
   }
   if (column_name == "goatsTeleported")
-    return Value::CreateStringValue(tm->GetResourceGoatsTeleported(i));
+    return base::StringValue::New(tm->GetResourceGoatsTeleported(i));
   if (column_name == "goatsTeleportedValue")
-    return Value::CreateIntegerValue(tm->GetGoatsTeleported(i));
+    return base::NumberValue::New(tm->GetGoatsTeleported(i));
   if (column_name == "v8MemoryAllocatedSize")
-    return Value::CreateStringValue(tm->GetResourceV8MemoryAllocatedSize(i));
+    return base::StringValue::New(tm->GetResourceV8MemoryAllocatedSize(i));
   if (column_name == "v8MemoryAllocatedSizeValue") {
     size_t v8_memory;
     tm->GetV8Memory(i, &v8_memory);
-    return Value::CreateDoubleValue(v8_memory);
+    return base::NumberValue::New(static_cast<int>(v8_memory));
   }
 
   NOTREACHED();
   return NULL;
 }
 
 static void CreateGroupColumnList(const TaskManagerModel* tm,
                                   const std::string column_name,
                                   const int index,
                                   const int length,
@@ skipping 72 matching lines @@
 
 TaskManagerHandler::~TaskManagerHandler() {
   DisableTaskManager(NULL);
 }
 
 // TaskManagerHandler, public: -----------------------------------------------
 
 void TaskManagerHandler::OnModelChanged() {
   const int count = model_->GroupCount();
 
-  base::FundamentalValue start_value(0);
-  base::FundamentalValue length_value(count);
+  base::NumberValue start_value(0);
+  base::NumberValue length_value(count);
   base::ListValue tasks_value;
   for (int i = 0; i < count; ++i)
     tasks_value.Append(CreateTaskGroupValue(model_, i));
 
   if (is_enabled_) {
     web_ui_->CallJavascriptFunction("taskChanged",
                                     start_value, length_value, tasks_value);
   }
 }
 
@@ skipping 154 matching lines @@
   resource_to_group_table_.insert(it, static_cast<size_t>(length), -1);
 
   for (int i = start; i < start + length; i++) {
     const int group_index = model_->GetGroupIndexForResource(i);
     resource_to_group_table_[i] = group_index;
   }
 }
 
 void TaskManagerHandler::OnGroupChanged(const int group_start,
                                         const int group_length) {
-  base::FundamentalValue start_value(group_start);
-  base::FundamentalValue length_value(group_length);
+  base::NumberValue start_value(group_start);
+  base::NumberValue length_value(group_length);
   base::ListValue tasks_value;
 
   for (int i = 0; i < group_length; ++i)
     tasks_value.Append(CreateTaskGroupValue(model_, group_start + i));
 
   if (is_enabled_) {
     web_ui_->CallJavascriptFunction("taskChanged",
                                     start_value, length_value, tasks_value);
   }
 }
 
 void TaskManagerHandler::OnGroupAdded(const int group_start,
                                       const int group_length) {
-  base::FundamentalValue start_value(group_start);
-  base::FundamentalValue length_value(group_length);
+  base::NumberValue start_value(group_start);
+  base::NumberValue length_value(group_length);
   base::ListValue tasks_value;
   for (int i = 0; i < group_length; ++i)
     tasks_value.Append(CreateTaskGroupValue(model_, group_start + i));
 
   if (is_enabled_) {
     web_ui_->CallJavascriptFunction("taskAdded",
                                     start_value, length_value, tasks_value);
   }
 }
 
 void TaskManagerHandler::OnGroupRemoved(const int group_start,
                                         const int group_length) {
-  base::FundamentalValue start_value(group_start);
-  base::FundamentalValue length_value(group_length);
+  base::NumberValue start_value(group_start);
+  base::NumberValue length_value(group_length);
   if (is_enabled_)
     web_ui_->CallJavascriptFunction("taskRemoved", start_value, length_value);
 }