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 28 matching lines @@
 
 void TaskManagerModel::RemoveObserver(TaskManagerModelObserver* observer) {
   observer_list_.RemoveObserver(observer);
 }
 
 string16 TaskManagerModel::GetResourceTitle(int index) const {
   DCHECK(index < ResourceCount());
   return WideToUTF16Hack(resources_[index]->GetTitle());
 }
 
+int64 TaskManagerModel::GetNetworkUsage(int index) const {
+  DCHECK(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 {
+  DCHECK(index < ResourceCount());
+  return GetCPUUsage(resources_[index]);
+}
+
 string16 TaskManagerModel::GetResourceCPUUsage(int index) const {
   DCHECK(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
@@ skipping 13 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 {
+  DCHECK(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());
   return base::FormatNumber(GetGoatsTeleported(index));
 }
 
 string16 TaskManagerModel::GetResourceWebCoreImageCacheSize(
     int index) const {
   DCHECK(index < ResourceCount());
@@ skipping 294 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).
   ChromeThread::PostTask(
       ChromeThread::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;
+  DCHECK_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).
   ChromeThread::PostTask(
       ChromeThread::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 32 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;
 }