Shortcut a couple of IPCs when the task manager is disabled.

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/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
 #include "base/prefs/pref_registry_simple.h"
@@ skipping 223 matching lines @@
 
 ////////////////////////////////////////////////////////////////////////////////
 // TaskManagerModel class
 ////////////////////////////////////////////////////////////////////////////////
 
 TaskManagerModel::TaskManagerModel(TaskManager* task_manager)
     : pending_video_memory_usage_stats_update_(false),
       update_requests_(0),
       listen_requests_(0),
       update_state_(IDLE),
+      is_updating_byte_count_(false),
       goat_salt_(base::RandUint64()) {
   AddResourceProvider(
       new task_manager::BrowserProcessResourceProvider(task_manager));
   AddResourceProvider(new task_manager::WebContentsResourceProvider(
       task_manager,
       scoped_ptr<WebContentsInformation>(
           new task_manager::BackgroundInformation())));
   AddResourceProvider(new task_manager::WebContentsResourceProvider(
       task_manager,
       scoped_ptr<WebContentsInformation>(
@@ skipping 794 matching lines @@
   }
   update_state_ = TASK_PENDING;
 
   // Notify resource providers that we are updating.
   StartListening();
 
   if (!resources_.empty()) {
     FOR_EACH_OBSERVER(TaskManagerModelObserver, observer_list_,
                       OnReadyPeriodicalUpdate());
   }
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&TaskManagerModel::SetUpdatingByteCount, this, true));
 }
 
 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.
   StopListening();
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&TaskManagerModel::SetUpdatingByteCount, this, false));
 }
 
 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_);
 
@@ skipping 154 matching lines @@
        it != resources_.end(); ++it) {
     if (base::GetProcId((*it)->GetProcess()) == renderer_id) {
       (*it)->NotifyV8HeapStats(v8_memory_allocated, v8_memory_used);
     }
   }
 }
 
 void TaskManagerModel::NotifyBytesRead(const net::URLRequest& request,
                                        int byte_count) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  if (!is_updating_byte_count_)
+    return;
 
   // Only net::URLRequestJob instances created by the ResourceDispatcherHost
   // have an associated ResourceRequestInfo and a render frame associated.
   // All other jobs will have -1 returned for the render process child and
   // routing ids - the jobs may still match a resource based on their origin id,
   // otherwise BytesRead() will attribute the activity to the Browser resource.
   const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(&request);
   int child_id = -1, route_id = -1;
   if (info)
     info->GetAssociatedRenderFrame(&child_id, &route_id);
@@ skipping 129 matching lines @@
 
   std::vector<BytesReadParam>* bytes_read_buffer =
       new std::vector<BytesReadParam>;
   bytes_read_buffer_.swap(*bytes_read_buffer);
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(&TaskManagerModel::MultipleBytesRead, this,
                  base::Owned(bytes_read_buffer)));
 }
 
+void TaskManagerModel::SetUpdatingByteCount(bool is_updating) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  is_updating_byte_count_ = is_updating;
+}
+
 int64 TaskManagerModel::GetNetworkUsage(Resource* resource) const {
   int64 net_usage = GetNetworkUsageForResource(resource);
   if (net_usage == 0 && !resource->SupportNetworkUsage())
     return -1;
   return net_usage;
 }
 
 double TaskManagerModel::GetCPUUsage(Resource* resource) const {
   const PerProcessValues& values(per_process_cache_[resource->GetProcess()]);
   // Returns 0 if not valid, which is fine.
@@ skipping 138 matching lines @@
   params.host_desktop_type = desktop_type;
   chrome::Navigate(&params);
 }
 
 TaskManager::TaskManager()
     : model_(new TaskManagerModel(this)) {
 }
 
 TaskManager::~TaskManager() {
 }