Improving the process model extension API

chrome/browser/task_manager/task_manager.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 "chrome/browser/task_manager/task_manager.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
@@ skipping 65 matching lines @@
 }
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerModel class
 ////////////////////////////////////////////////////////////////////////////////
 
 TaskManagerModel::TaskManagerModel(TaskManager* task_manager)
     : update_requests_(0),
+      listen_requests_(0),
       update_state_(IDLE),
+      is_listening_(false),
       goat_salt_(base::RandUint64()),
       last_unique_id_(0) {
   AddResourceProvider(
       new TaskManagerBrowserProcessResourceProvider(task_manager));
   AddResourceProvider(
       new TaskManagerBackgroundContentsResourceProvider(task_manager));
   AddResourceProvider(new TaskManagerTabContentsResourceProvider(task_manager));
   AddResourceProvider(
       new TaskManagerChildProcessResourceProvider(task_manager));
   AddResourceProvider(
@@ skipping 104 matching lines @@
   size_t phys_mem;
   GetPhysicalMemory(index, &phys_mem);
   return GetMemCellText(phys_mem);
 }
 
 int TaskManagerModel::GetProcessId(int index) const {
   CHECK_LT(index, ResourceCount());
   return base::GetProcId(resources_[index]->GetProcess());
 }
 
+base::ProcessHandle TaskManagerModel::GetProcess(int index) const {
+  CHECK_LT(index, ResourceCount());
+  return resources_[index]->GetProcess();
+}
+
 string16 TaskManagerModel::GetResourceProcessId(int index) const {
   return base::IntToString16(GetProcessId(index));
 }
 
 string16 TaskManagerModel::GetResourceGoatsTeleported(int index) const {
   CHECK_LT(index, ResourceCount());
   return base::FormatNumber(GetGoatsTeleported(index));
 }
 
 string16 TaskManagerModel::GetResourceWebCoreImageCacheSize(
@@ skipping 358 matching lines @@
 
 bool TaskManagerModel::GetV8Memory(int index, size_t* result) const {
   *result = 0;
   if (!resources_[index]->ReportsV8MemoryStats())
     return false;
 
   *result = resources_[index]->GetV8MemoryAllocated();
   return true;
 }
 
+bool TaskManagerModel::GetV8MemoryUsed(int index, size_t* result) const {
+  *result = 0;
+  if (!resources_[index]->ReportsV8MemoryStats())
+    return false;
+
+  *result = resources_[index]->GetV8MemoryUsed();
+  return true;
+}
+
 bool TaskManagerModel::CanActivate(int index) const {
   CHECK_LT(index, ResourceCount());
   return GetResourceTabContents(index) != NULL;
 }
 
 bool TaskManagerModel::CanInspect(int index) const {
   CHECK_LT(index, ResourceCount());
   return resources_[index]->CanInspect();
 }
 
@@ skipping 14 matching lines @@
   // Adjust number string if necessary.
   base::i18n::AdjustStringForLocaleDirection(&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 ui::FormatBytes(number);
 #endif
 }
 
+void TaskManagerModel::StartListening() {
+  // Multiple StartListening requests may come in and we only need to take
+  // action the first time.
+  listen_requests_++;
+  if (listen_requests_ > 1)
+    return;
+  DCHECK_EQ(1, listen_requests_);
+  DCHECK(!is_listening_);
+
+  is_listening_ = true;
+
+  // Notify resource providers that we should start listening to events.
+  for (ResourceProviderList::iterator iter = providers_.begin();
+       iter != providers_.end(); ++iter) {
+    (*iter)->StartUpdating();
+  }
+}
+
+void TaskManagerModel::StopListening() {
+  // Don't actually stop listening until we have heard as many calls as those
+  // to StartListening.
+  listen_requests_--;
+  if (listen_requests_ > 0)
+    return;
+
+  DCHECK_EQ(0, listen_requests_);
+  DCHECK(is_listening_);
+  is_listening_ = false;
+
+  // Notify resource providers that we are done listening.
+  for (ResourceProviderList::const_iterator iter = providers_.begin();
+       iter != providers_.end(); ++iter) {
+    (*iter)->StopUpdating();
+  }
+
+  // Must clear the resources before the next attempt to start listening.
+  Clear();
+}
+
 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()->PostTask(
           FROM_HERE,
           base::Bind(&TaskManagerModel::Refresh, this));
   }
   update_state_ = TASK_PENDING;
 
   // Notify resource providers that we are updating.
-  for (ResourceProviderList::iterator iter = providers_.begin();
-       iter != providers_.end(); ++iter) {
-    (*iter)->StartUpdating();
-  }
+  StartListening();
 
   if (!resources_.empty()) {
     FOR_EACH_OBSERVER(TaskManagerModelObserver, observer_list_,
                       OnReadyPeriodicalUpdate());
   }
 }
 
 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();
-  }
-
-  // Must clear the resources before the next attempt to start updating.
-  Clear();
+  StopListening();
 }
 
 void TaskManagerModel::AddResourceProvider(
     TaskManager::ResourceProvider* provider) {
   DCHECK(provider);
   providers_.push_back(provider);
 }
 
 void TaskManagerModel::AddResource(TaskManager::Resource* resource) {
   resource->unique_id_ = ++last_unique_id_;
@@ skipping 69 matching lines @@
     if (pm_iter != metrics_map_.end()) {
       delete pm_iter->second;
       metrics_map_.erase(process);
     }
     // And we don't need the CPU usage anymore either.
     CPUUsageMap::iterator cpu_iter = cpu_usage_map_.find(process);
     if (cpu_iter != cpu_usage_map_.end())
       cpu_usage_map_.erase(cpu_iter);
   }
 
-  // Remove the entry from the model list.
+  // Prepare to remove the entry from the model list.
   iter = std::find(resources_.begin(), resources_.end(), resource);
   DCHECK(iter != resources_.end());
   int index = static_cast<int>(iter - resources_.begin());
+
+  // Notify the observers that the contents will change.
+  FOR_EACH_OBSERVER(TaskManagerModelObserver, observer_list_,
+                    OnItemsToBeRemoved(index, 1));
+
+  // Now actually remove the entry from the model list.
   resources_.erase(iter);
 
   // Remove the entry from the network maps.
   ResourceValueMap::iterator net_iter =
       current_byte_count_map_.find(resource);
   if (net_iter != current_byte_count_map_.end())
     current_byte_count_map_.erase(net_iter);
   net_iter = displayed_network_usage_map_.find(resource);
   if (net_iter != displayed_network_usage_map_.end())
     displayed_network_usage_map_.erase(net_iter);
@@ skipping 143 matching lines @@
 int64 TaskManagerModel::GetNetworkUsageForResource(
     TaskManager::Resource* resource) const {
   ResourceValueMap::const_iterator iter =
       displayed_network_usage_map_.find(resource);
   if (iter == displayed_network_usage_map_.end())
     return 0;
   return iter->second;
 }
 
 void TaskManagerModel::BytesRead(BytesReadParam param) {
-  if (update_state_ != TASK_PENDING) {
+  if (update_state_ != TASK_PENDING || !is_listening_) {

[yoshiki, 2012/05/08 19:31:07]

We can use "listen_requests_ == 0" instead of "!is_listening_", right? If so,
the property |is_listening_| can be removed from the class.

[nasko, 2012/05/09 00:21:54]

Done.

     // A notification sneaked in while we were stopping the updating, just
     // ignore it.
     return;
   }
 
   if (param.byte_count == 0) {
     // Nothing to do if no bytes were actually read.
     return;
   }
 
@@ skipping 226 matching lines @@
     // Count the number of extensions with background pages (including
     // incognito).
     count += CountExtensionBackgroundPagesForProfile(profile);
     if (profile->HasOffTheRecordProfile()) {
       count += CountExtensionBackgroundPagesForProfile(
           profile->GetOffTheRecordProfile());
     }
   }
   return count;
 }