Kill URLRequestJobTracker.

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 "base/compiler_specific.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
 #include "base/process_util.h"
@@ skipping 16 matching lines @@
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/resource_dispatcher_host.h"
 #include "content/browser/tab_contents/tab_contents.h"
 #include "content/common/result_codes.h"
 #include "grit/app_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
-#include "net/url_request/url_request.h"
-#include "net/url_request/url_request_job.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "unicode/coll.h"
 
 #if defined(OS_MACOSX)
 #include "chrome/browser/mach_broker_mac.h"
 #endif
 
 namespace {
 
@@ skipping 444 matching lines @@
 
   // 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);
   // AddRef matched with Release in destructor.
   provider->AddRef();
   providers_.push_back(provider);
 }
 
-void TaskManagerModel::RegisterForJobDoneNotifications() {
-  net::g_url_request_job_tracker.AddObserver(this);
-}
-
-void TaskManagerModel::UnregisterForJobDoneNotifications() {
-  net::g_url_request_job_tracker.RemoveObserver(this);
-}
-
 void TaskManagerModel::AddResource(TaskManager::Resource* resource) {
   base::ProcessHandle process = resource->GetProcess();
 
   ResourceList* group_entries = NULL;
   GroupMap::const_iterator group_iter = group_map_.find(process);
   int new_entry_index = 0;
   if (group_iter == group_map_.end()) {
     group_entries = new ResourceList();
     group_map_[process] = group_entries;
     group_entries->push_back(resource);
@@ skipping 259 matching lines @@
 
   ResourceValueMap::const_iterator iter_res =
       current_byte_count_map_.find(resource);
   if (iter_res == current_byte_count_map_.end())
     current_byte_count_map_[resource] = param.byte_count;
   else
     current_byte_count_map_[resource] = iter_res->second + param.byte_count;
 }
 
 
-// In order to retrieve the network usage, we register for net::URLRequestJob
-// notifications. Every time we get notified some bytes were read we bump a
-// counter of read bytes for the associated resource. When the timer ticks,
-// we'll compute the actual network usage (see the Refresh method).
-void TaskManagerModel::OnJobAdded(net::URLRequestJob* job) {
-}
-
-void TaskManagerModel::OnJobRemoved(net::URLRequestJob* job) {
-}
-
-void TaskManagerModel::OnJobDone(net::URLRequestJob* job,
-                                 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) {
+void TaskManagerModel::NotifyBytesRead(const net::URLRequest& request,
+                                       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(),
+  ResourceDispatcherHost::RenderViewForRequest(&request,
                                                &render_process_host_child_id,
                                                &routing_id);
 
   // Get the origin PID of the request's originator.  This will only be set for
   // plugins - for renderer or browser initiated requests it will be zero.
-  int origin_pid =
-      chrome_browser_net::GetOriginPIDForRequest(job->request());
+  int origin_pid = chrome_browser_net::GetOriginPIDForRequest(&request);
 
   // This happens in the IO thread, post it to the UI thread.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       NewRunnableMethod(
           this,
           &TaskManagerModel::BytesRead,
           BytesReadParam(origin_pid,
-          render_process_host_child_id,
-          routing_id, byte_count)));
+                         render_process_host_child_id,
+                         routing_id, byte_count)));
 }
 
 bool TaskManagerModel::GetProcessMetricsForRow(
     int row, base::ProcessMetrics** proc_metrics) const {
   DCHECK(row < ResourceCount());
   *proc_metrics = NULL;
 
   MetricsMap::const_iterator iter =
       metrics_map_.find(resources_[row]->GetProcess());
   if (iter == metrics_map_.end())
@@ skipping 151 matching lines @@
     // Count the number of extensions with background pages (including
     // incognito).
     count += CountExtensionBackgroundPagesForProfile(profile);
     if (profile->HasOffTheRecordProfile()) {
       count += CountExtensionBackgroundPagesForProfile(
           profile->GetOffTheRecordProfile());
     }
   }
   return count;
 }