Expands the chrome.experimental.processes extension API. ...

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 52 matching lines @@
       FormatBytes(stat.liveSize, DATA_UNITS_KIBIBYTE, false));
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerModel class
 ////////////////////////////////////////////////////////////////////////////////
 
 TaskManagerModel::TaskManagerModel(TaskManager* task_manager)
-    : update_state_(IDLE),
+    : update_requests_(0),
+      update_state_(IDLE),
       goat_salt_(rand()) {
 
   TaskManagerBrowserProcessResourceProvider* browser_provider =
       new TaskManagerBrowserProcessResourceProvider(task_manager);
   browser_provider->AddRef();
   providers_.push_back(browser_provider);
   TaskManagerTabContentsResourceProvider* wc_provider =
       new TaskManagerTabContentsResourceProvider(task_manager);
   wc_provider->AddRef();
   providers_.push_back(wc_provider);
@@ skipping 24 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 {
-  DCHECK(index < ResourceCount());
+  CHECK(index < ResourceCount());
   return WideToUTF16Hack(resources_[index]->GetTitle());
 }
 
+int64 TaskManagerModel::GetNetworkUsage(int index) const {
+  CHECK(index < ResourceCount());
+  return GetNetworkUsage(resources_[index]);
+}
+
 string16 TaskManagerModel::GetResourceNetworkUsage(int index) const {
-  DCHECK(index < ResourceCount());
-  int64 net_usage = GetNetworkUsage(resources_[index]);
+  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());
+  return GetCPUUsage(resources_[index]);
+}
+
 string16 TaskManagerModel::GetResourceCPUUsage(int index) const {
-  DCHECK(index < ResourceCount());
+  CHECK(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 11 matching lines @@
     return ASCIIToUTF16("N/A");
   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());
+  return base::GetProcId(resources_[index]->GetProcess());
+}
+
 string16 TaskManagerModel::GetResourceProcessId(int index) const {
-  DCHECK(index < ResourceCount());
-  return base::IntToString16(base::GetProcId(resources_[index]->GetProcess()));
+  return base::IntToString16(GetProcessId(index));
 }
 
 string16 TaskManagerModel::GetResourceGoatsTeleported(int index) const {
-  DCHECK(index < ResourceCount());
+  CHECK(index < ResourceCount());
   return base::FormatNumber(GetGoatsTeleported(index));
 }
 
 string16 TaskManagerModel::GetResourceWebCoreImageCacheSize(
     int index) const {
-  DCHECK(index < ResourceCount());
+  CHECK(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 {
-  DCHECK(index < ResourceCount());
+  CHECK(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 {
-  DCHECK(index < ResourceCount());
+  CHECK(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 {
-  DCHECK(index < ResourceCount());
+  CHECK(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 {
-  DCHECK(index < ResourceCount());
+  CHECK(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);
 }
 
 SkBitmap TaskManagerModel::GetResourceIcon(int index) const {
-  DCHECK(index < ResourceCount());
+  CHECK(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 {
-  DCHECK(index < ResourceCount());
+  CHECK(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) {
       if (resources_[i] == (*group)[0])
         return std::make_pair(i, group->size());
     }
     NOTREACHED();
     return std::make_pair(-1, -1);
   }
 }
 
 int TaskManagerModel::CompareValues(int row1, int row2, int col_id) const {
-  DCHECK(row1 < ResourceCount() && row2 < ResourceCount());
+  CHECK(row1 < ResourceCount() && row2 < ResourceCount());
   switch (col_id) {
     case IDS_TASK_MANAGER_PAGE_COLUMN: {
       // Let's do the default, string compare on the resource title.
       static icu::Collator* collator = NULL;
       if (!collator) {
         UErrorCode create_status = U_ZERO_ERROR;
         collator = icu::Collator::createInstance(create_status);
         if (!U_SUCCESS(create_status)) {
           collator = NULL;
           NOTREACHED();
@@ skipping 86 matching lines @@
     }
 
     default:
       NOTREACHED();
       return 0;
   }
 }
 
 base::ProcessHandle TaskManagerModel::GetResourceProcessHandle(int index)
     const {
-  DCHECK(index < ResourceCount());
+  CHECK(index < ResourceCount());
   return resources_[index]->GetProcess();
 }
 
+TaskManager::Resource::Type TaskManagerModel::GetResourceType(int index) const {
+  CHECK(index < ResourceCount());
+  return resources_[index]->GetType();
+}
+
 TabContents* TaskManagerModel::GetResourceTabContents(int index) const {
-  DCHECK(index < ResourceCount());
+  CHECK(index < ResourceCount());
   return resources_[index]->GetTabContents();
 }
 
 const Extension* TaskManagerModel::GetResourceExtension(int index) const {
-  DCHECK(index < ResourceCount());
+  CHECK(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 77 matching lines @@
   base::i18n::AdjustStringForLocaleDirection(str, &str);
   return l10n_util::GetStringFUTF16(IDS_TASK_MANAGER_MEM_CELL_TEXT, str);
 #else
   // System expectation is to show "100 KB", "200 MB", etc.
   // TODO(thakis): Switch to metric units (as opposed to powers of two).
   return FormatBytes(number, GetByteDisplayUnits(number), /*show_units=*/true);
 #endif
 }
 
 void TaskManagerModel::StartUpdating() {
+  // Multiple StartUpdating requests may come in, and we only need to take
+  // action the first time.
+  update_requests_++;
+  if (update_requests_ > 1)
+    return;
+  DCHECK_EQ(1, update_requests_);
   DCHECK_NE(TASK_PENDING, update_state_);
 
   // If update_state_ is STOPPING, it means a task is still pending.  Setting
   // it to TASK_PENDING ensures the tasks keep being posted (by Refresh()).
   if (update_state_ == IDLE) {
       MessageLoop::current()->PostDelayedTask(FROM_HERE,
           NewRunnableMethod(this, &TaskManagerModel::Refresh),
           kUpdateTimeMs);
   }
   update_state_ = TASK_PENDING;
 
   // Register jobs notifications so we can compute network usage (it must be
   // done from the IO thread).
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
          this, &TaskManagerModel::RegisterForJobDoneNotifications));
 
   // Notify resource providers that we are updating.
   for (ResourceProviderList::iterator iter = providers_.begin();
        iter != providers_.end(); ++iter) {
     (*iter)->StartUpdating();
   }
 }
 
 void TaskManagerModel::StopUpdating() {
+  // Don't actually stop updating until we have heard as many calls as those
+  // to StartUpdating.
+  update_requests_--;
+  if (update_requests_ > 0)
+    return;
+  // Make sure that update_requests_ cannot go negative.
+  CHECK_EQ(0, update_requests_);
   DCHECK_EQ(TASK_PENDING, update_state_);
   update_state_ = STOPPING;
 
   // Notify resource providers that we are done updating.
   for (ResourceProviderList::const_iterator iter = providers_.begin();
        iter != providers_.end(); ++iter) {
     (*iter)->StopUpdating();
   }
 
   // Unregister jobs notification (must be done from the IO thread).
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           this, &TaskManagerModel::UnregisterForJobDoneNotifications));
+
+  // Must clear the resources before the next attempt to start updating.
+  Clear();
 }
 
 void TaskManagerModel::AddResourceProvider(
     TaskManager::ResourceProvider* provider) {
   DCHECK(provider);
   providers_.push_back(provider);
 }
 
 void TaskManagerModel::RemoveResourceProvider(
     TaskManager::ResourceProvider* provider) {
@@ skipping 383 matching lines @@
 void TaskManager::AddResource(Resource* resource) {
   model_->AddResource(resource);
 }
 
 void TaskManager::RemoveResource(Resource* resource) {
   model_->RemoveResource(resource);
 }
 
 void TaskManager::OnWindowClosed() {
   model_->StopUpdating();
-  model_->Clear();
 }
 
 // static
 TaskManager* TaskManager::GetInstance() {
   return Singleton<TaskManager>::get();
 }
 
 void TaskManager::OpenAboutMemory() {
   Browser* browser = BrowserList::GetLastActive();
 
@@ skipping 33 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;
 }