Revert 72095 - Attribute orphaned or anonymous network usage to the Browser r...

chrome/browser/task_manager/task_manager.cc

 // Copyright (c) 2011 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 "base/compiler_specific.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
@@ skipping 827 matching lines @@
   // linking a network notification back to the object that initiated it.
   TaskManager::Resource* resource = NULL;
   for (ResourceProviderList::iterator iter = providers_.begin();
        iter != providers_.end(); ++iter) {
     resource = (*iter)->GetResource(param.origin_child_id,
                                     param.render_process_host_child_id,
                                     param.routing_id);
     if (resource)
       break;
   }
-
   if (resource == NULL) {
-    // We can't match a resource to the notification.  That might mean the
-    // tab that started a download was closed, or the request may have had
-    // no originating resource associated with it in the first place.
-    // We attribute orphaned/unaccounted activity to the Browser process.
-    CHECK(param.origin_child_id != base::GetCurrentProcId());
-    param.origin_child_id = base::GetCurrentProcId();
-    param.render_process_host_child_id = param.routing_id = -1;
-    BytesRead(param);
+    // We may not have that resource anymore (example: close a tab while a
+    // a network resource is being retrieved), in which case we just ignore the
+    // notification.
     return;
   }
 
   // We do support network usage, mark the resource as such so it can report 0
   // instead of N/A.
   if (!resource->SupportNetworkUsage())
     resource->SetSupportNetworkUsage();
 
   ResourceValueMap::const_iterator iter_res =
       current_byte_count_map_.find(resource);
@@ skipping 18 matching lines @@
                                  const net::URLRequestStatus& status) {
 }
 
 void TaskManagerModel::OnJobRedirect(net::URLRequestJob* job,
                                      const GURL& location,
                                      int status_code) {
 }
 
 void TaskManagerModel::OnBytesRead(net::URLRequestJob* job, const char* buf,
                                    int byte_count) {
-  // Only net::URLRequestJob instances created by the ResourceDispatcherHost
-  // have a render view 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.
   int render_process_host_child_id = -1, routing_id = -1;
-  ResourceDispatcherHost::RenderViewForRequest(job->request(),
+  if (!ResourceDispatcherHost::RenderViewForRequest(job->request(),
                                                &render_process_host_child_id,
-                                               &routing_id);
+                                               &routing_id)) {
+    // Only net::URLRequestJob instances created by the ResourceDispatcherHost
+    // have a render view associated.  Jobs from components such as the
+    // SearchProvider for autocomplete, have no associated view, so we can't
+    // correctly attribute the bandwidth they consume.
+    // TODO(wez): All jobs' resources should ideally be accountable, even if
+    // only by contributing to the Browser process' stats.
+    return;
+  }
 
   // This happens in the IO thread, post it to the UI thread.
   int origin_child_id =
       chrome_browser_net::GetOriginProcessUniqueIDForRequest(job->request());
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           this,
           &TaskManagerModel::BytesRead,
           BytesReadParam(origin_child_id,
@@ skipping 122 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;
 }