Implement new task manager mocks on windows.

chrome/browser/task_manager/task_manager.cc

 // Copyright (c) 2010 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/task_manager/task_manager.h"
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/compiler_specific.h"
 #include "base/i18n/number_formatting.h"
@@ skipping 60 matching lines @@
 
 TaskManagerModel::TaskManagerModel(TaskManager* task_manager)
     : update_requests_(0),
       update_state_(IDLE),
       goat_salt_(rand()) {
 
   TaskManagerBrowserProcessResourceProvider* browser_provider =
       new TaskManagerBrowserProcessResourceProvider(task_manager);
   browser_provider->AddRef();
   providers_.push_back(browser_provider);
+  TaskManagerBackgroundContentsResourceProvider* bc_provider =
+      new TaskManagerBackgroundContentsResourceProvider(task_manager);
+  bc_provider->AddRef();
+  providers_.push_back(bc_provider);
   TaskManagerTabContentsResourceProvider* wc_provider =
       new TaskManagerTabContentsResourceProvider(task_manager);
   wc_provider->AddRef();
   providers_.push_back(wc_provider);
-  TaskManagerBackgroundContentsResourceProvider* bc_provider =
-      new TaskManagerBackgroundContentsResourceProvider(task_manager);
-  bc_provider->AddRef();
-  providers_.push_back(bc_provider);
   TaskManagerChildProcessResourceProvider* child_process_provider =
       new TaskManagerChildProcessResourceProvider(task_manager);
   child_process_provider->AddRef();
   providers_.push_back(child_process_provider);
   TaskManagerExtensionProcessResourceProvider* extension_process_provider =
       new TaskManagerExtensionProcessResourceProvider(task_manager);
   extension_process_provider->AddRef();
   providers_.push_back(extension_process_provider);
   TaskManagerNotificationResourceProvider* notification_provider =
       new TaskManagerNotificationResourceProvider(task_manager);
@@ skipping 14 matching lines @@
 
 void TaskManagerModel::AddObserver(TaskManagerModelObserver* observer) {
   observer_list_.AddObserver(observer);
 }
 
 void TaskManagerModel::RemoveObserver(TaskManagerModelObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 string16 TaskManagerModel::GetResourceTitle(int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   return WideToUTF16Hack(resources_[index]->GetTitle());
 }
 
 int64 TaskManagerModel::GetNetworkUsage(int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   return GetNetworkUsage(resources_[index]);
 }
 
 string16 TaskManagerModel::GetResourceNetworkUsage(int index) const {
   int64 net_usage = GetNetworkUsage(index);
   if (net_usage == -1)
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   if (net_usage == 0)
     return ASCIIToUTF16("0");
   string16 net_byte = FormatSpeed(net_usage, GetByteDisplayUnits(net_usage),
                                   true);
   // Force number string to have LTR directionality.
   return base::i18n::GetDisplayStringInLTRDirectionality(net_byte);
 }
 
 double TaskManagerModel::GetCPUUsage(int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   return GetCPUUsage(resources_[index]);
 }
 
 string16 TaskManagerModel::GetResourceCPUUsage(int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   return WideToUTF16Hack(StringPrintf(
 #if defined(OS_MACOSX)
       // Activity Monitor shows %cpu with one decimal digit -- be
       // consistent with that.
       L"%.1f",
 #else
       L"%.0f",
 #endif
       GetCPUUsage(resources_[index])));
 }
@@ skipping 12 matching lines @@
   return GetMemCellText(shared_mem);
 }
 
 string16 TaskManagerModel::GetResourcePhysicalMemory(int index) const {
   size_t phys_mem;
   GetPhysicalMemory(index, &phys_mem);
   return GetMemCellText(phys_mem);
 }
 
 int TaskManagerModel::GetProcessId(int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   return base::GetProcId(resources_[index]->GetProcess());
 }
 
 string16 TaskManagerModel::GetResourceProcessId(int index) const {
   return base::IntToString16(GetProcessId(index));
 }
 
 string16 TaskManagerModel::GetResourceGoatsTeleported(int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   return base::FormatNumber(GetGoatsTeleported(index));
 }
 
 string16 TaskManagerModel::GetResourceWebCoreImageCacheSize(
     int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   if (!resources_[index]->ReportsCacheStats())
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   const WebKit::WebCache::ResourceTypeStats stats(
       resources_[index]->GetWebCoreCacheStats());
   return FormatStatsSize(stats.images);
 }
 
 string16 TaskManagerModel::GetResourceWebCoreScriptsCacheSize(
     int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   if (!resources_[index]->ReportsCacheStats())
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   const WebKit::WebCache::ResourceTypeStats stats(
       resources_[index]->GetWebCoreCacheStats());
   return FormatStatsSize(stats.scripts);
 }
 
 string16 TaskManagerModel::GetResourceWebCoreCSSCacheSize(
     int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   if (!resources_[index]->ReportsCacheStats())
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   const WebKit::WebCache::ResourceTypeStats stats(
       resources_[index]->GetWebCoreCacheStats());
   return FormatStatsSize(stats.cssStyleSheets);
 }
 
 string16 TaskManagerModel::GetResourceSqliteMemoryUsed(int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   if (!resources_[index]->ReportsSqliteMemoryUsed())
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   return GetMemCellText(resources_[index]->SqliteMemoryUsedBytes());
 }
 
 string16 TaskManagerModel::GetResourceV8MemoryAllocatedSize(
     int index) const {
   if (!resources_[index]->ReportsV8MemoryStats())
     return l10n_util::GetStringUTF16(IDS_TASK_MANAGER_NA_CELL_TEXT);
   return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_CACHE_SIZE_CELL_TEXT,
       FormatBytes(resources_[index]->GetV8MemoryAllocated(),
                   DATA_UNITS_KIBIBYTE,
                   false),
       FormatBytes(resources_[index]->GetV8MemoryUsed(),
                   DATA_UNITS_KIBIBYTE,
                   false));
 }
 
 bool TaskManagerModel::IsResourceFirstInGroup(int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   TaskManager::Resource* resource = resources_[index];
   GroupMap::const_iterator iter = group_map_.find(resource->GetProcess());
   DCHECK(iter != group_map_.end());
   const ResourceList* group = iter->second;
   return ((*group)[0] == resource);
 }
 
+bool TaskManagerModel::IsBackgroundResource(int index) const {
+  CHECK_LT(index, ResourceCount());
+  return resources_[index]->IsBackground();
+}
+
 SkBitmap TaskManagerModel::GetResourceIcon(int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   SkBitmap icon = resources_[index]->GetIcon();
   if (!icon.isNull())
     return icon;
 
   static SkBitmap* default_icon = ResourceBundle::GetSharedInstance().
       GetBitmapNamed(IDR_DEFAULT_FAVICON);
   return *default_icon;
 }
 
 std::pair<int, int> TaskManagerModel::GetGroupRangeForResource(int index)
     const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   TaskManager::Resource* resource = resources_[index];
   GroupMap::const_iterator group_iter =
       group_map_.find(resource->GetProcess());
   DCHECK(group_iter != group_map_.end());
   ResourceList* group = group_iter->second;
   DCHECK(group);
   if (group->size() == 1) {
     return std::make_pair(index, 1);
   } else {
     for (int i = index; i >= 0; --i) {
@@ skipping 106 matching lines @@
     }
 
     default:
       NOTREACHED();
       return 0;
   }
 }
 
 base::ProcessHandle TaskManagerModel::GetResourceProcessHandle(int index)
     const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   return resources_[index]->GetProcess();
 }
 
 TaskManager::Resource::Type TaskManagerModel::GetResourceType(int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   return resources_[index]->GetType();
 }
 
 TabContents* TaskManagerModel::GetResourceTabContents(int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   return resources_[index]->GetTabContents();
 }
 
 const Extension* TaskManagerModel::GetResourceExtension(int index) const {
-  CHECK(index < ResourceCount());
+  CHECK_LT(index, ResourceCount());
   return resources_[index]->GetExtension();
 }
 
 int64 TaskManagerModel::GetNetworkUsage(TaskManager::Resource* resource)
     const {
   int64 net_usage = GetNetworkUsageForResource(resource);
   if (net_usage == 0 && !resource->SupportNetworkUsage())
     return -1;
   return net_usage;
 }
@@ skipping 183 matching lines @@
   } else {
     group_entries = group_iter->second;
     group_entries->push_back(resource);
 
     // Insert the new entry right after the last entry of its group.
     ResourceList::iterator iter =
         std::find(resources_.begin(),
                   resources_.end(),
                   (*group_entries)[group_entries->size() - 2]);
     DCHECK(iter != resources_.end());
-    new_entry_index = static_cast<int>(iter - resources_.begin());
+    new_entry_index = static_cast<int>(iter - resources_.begin()) + 1;
     resources_.insert(++iter, resource);
   }
 
   // Create the ProcessMetrics for this process if needed (not in map).
   if (metrics_map_.find(process) == metrics_map_.end()) {
     base::ProcessMetrics* pm =
 #if !defined(OS_MACOSX)
         base::ProcessMetrics::CreateProcessMetrics(process);
 #else
         base::ProcessMetrics::CreateProcessMetrics(process,
@@ skipping 83 matching lines @@
 
     // Clear the network maps.
     current_byte_count_map_.clear();
     displayed_network_usage_map_.clear();
 
     FOR_EACH_OBSERVER(TaskManagerModelObserver, observer_list_,
                       OnItemsRemoved(0, size));
   }
 }
 
+void TaskManagerModel::ModelChanged() {
+  // Notify the table that the contents have changed for it to redraw.
+  FOR_EACH_OBSERVER(TaskManagerModelObserver, observer_list_, OnModelChanged());
+}
+
 void TaskManagerModel::NotifyResourceTypeStats(
     base::ProcessId renderer_id,
     const WebKit::WebCache::ResourceTypeStats& stats) {
   for (ResourceList::iterator it = resources_.begin();
        it != resources_.end(); ++it) {
     if (base::GetProcId((*it)->GetProcess()) == renderer_id) {
       (*it)->NotifyResourceTypeStats(stats);
     }
   }
 }
@@ skipping 231 matching lines @@
 }
 
 void TaskManager::RemoveResource(Resource* resource) {
   model_->RemoveResource(resource);
 }
 
 void TaskManager::OnWindowClosed() {
   model_->StopUpdating();
 }
 
+void TaskManager::ModelChanged() {
+  model_->ModelChanged();
+}
+
 // static
 TaskManager* TaskManager::GetInstance() {
   return Singleton<TaskManager>::get();
 }
 
 void TaskManager::OpenAboutMemory() {
   Browser* browser = BrowserList::GetLastActive();
 
   if (!browser) {
     // On OS X, the task manager can be open without any open browser windows.
@@ skipping 31 matching lines @@
   MetricsMap::const_iterator iter = metrics_map_.find(handle);
   if (iter == metrics_map_.end())
     return false;
 
   if (!iter->second->GetMemoryBytes(&usage->first, &usage->second))
     return false;
 
   memory_usage_map_.insert(std::make_pair(handle, *usage));
   return true;
 }