Kill URLRequestJobTracker.

chrome/browser/task_manager/task_manager.h

 // 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.
 
 #ifndef CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_H_
 #define CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/singleton.h"
 #include "base/observer_list.h"
 #include "base/process_util.h"
 #include "base/string16.h"
 #include "base/timer.h"
 #include "chrome/browser/renderer_host/web_cache_manager.h"
-#include "net/url_request/url_request_job_tracker.h"
 #include "third_party/WebKit/Source/WebKit/chromium/public/WebCache.h"
 
 class Extension;
 class SkBitmap;
 class TabContentsWrapper;
 class TaskManagerModel;
 
 namespace base {
 class ProcessMetrics;
 }
+namespace net {
+class URLRequest;
+}
 
 // This class is a singleton.
 class TaskManager {
  public:
   // A resource represents one row in the task manager.
   // Resources from similar processes are grouped together by the task manager.
   class Resource {
    public:
     virtual ~Resource() {}
 
@@ skipping 163 matching lines @@
   virtual void OnItemsChanged(int start, int length) = 0;
 
   // Invoked when new items are added.
   virtual void OnItemsAdded(int start, int length) = 0;
 
   // Invoked when a range of items has been removed.
   virtual void OnItemsRemoved(int start, int length) = 0;
 };
 
 // The model that the TaskManager is using.
-class TaskManagerModel : public net::URLRequestJobTracker::JobObserver,
-                         public base::RefCountedThreadSafe<TaskManagerModel> {
+class TaskManagerModel : public base::RefCountedThreadSafe<TaskManagerModel> {
  public:
   explicit TaskManagerModel(TaskManager* task_manager);
 
   void AddObserver(TaskManagerModelObserver* observer);
   void RemoveObserver(TaskManagerModelObserver* observer);
 
   // Returns number of registered resources.
   int ResourceCount() const;
 
   // Methods to return raw resource information.
@@ skipping 61 matching lines @@
 
   // Returns the type of the given resource.
   TaskManager::Resource::Type GetResourceType(int index) const;
 
   // Returns TabContents of given resource or NULL if not applicable.
   TabContentsWrapper* GetResourceTabContents(int index) const;
 
   // Returns Extension of given resource or NULL if not applicable.
   const Extension* GetResourceExtension(int index) const;
 
-  // JobObserver methods:
-  virtual void OnJobAdded(net::URLRequestJob* job);
-  virtual void OnJobRemoved(net::URLRequestJob* job);
-  virtual void OnJobDone(net::URLRequestJob* job,
-                         const net::URLRequestStatus& status);
-  virtual void OnJobRedirect(net::URLRequestJob* job,
-                             const GURL& location,
-                             int status_code);
-  virtual void OnBytesRead(net::URLRequestJob* job,
-                           const char* buf,
-                           int byte_count);
-
   void AddResource(TaskManager::Resource* resource);
   void RemoveResource(TaskManager::Resource* resource);
 
   void StartUpdating();
   void StopUpdating();
 
   void Clear();  // Removes all items.
 
   // Sends OnModelChanged() to all observers to inform them of significant
   // changes to the model.
   void ModelChanged();
 
   void NotifyResourceTypeStats(
         base::ProcessId renderer_id,
         const WebKit::WebCache::ResourceTypeStats& stats);
 
   void NotifyV8HeapStats(base::ProcessId renderer_id,
                          size_t v8_memory_allocated,
                          size_t v8_memory_used);
 
+  void NotifyBytesRead(const net::URLRequest& request, int bytes_read);
+
  private:
   friend class base::RefCountedThreadSafe<TaskManagerModel>;
   FRIEND_TEST_ALL_PREFIXES(TaskManagerTest, RefreshCalled);
   FRIEND_TEST_ALL_PREFIXES(ExtensionApiTest, ProcessesVsTaskManager);
 
   ~TaskManagerModel();
 
   enum UpdateState {
     IDLE = 0,      // Currently not updating.
     TASK_PENDING,  // An update task is pending.
@@ skipping 30 matching lines @@
   typedef std::map<TaskManager::Resource*, int64> ResourceValueMap;
   typedef std::map<base::ProcessHandle,
                    std::pair<size_t, size_t> > MemoryUsageMap;
 
   // Updates the values for all rows.
   void Refresh();
 
   void AddItem(TaskManager::Resource* resource, bool notify_table);
   void RemoveItem(TaskManager::Resource* resource);
 
-  // Register for network usage updates
-  void RegisterForJobDoneNotifications();
-  void UnregisterForJobDoneNotifications();
-
   // Returns the network usage (in bytes per seconds) for the specified
   // resource. That's the value retrieved at the last timer's tick.
   int64 GetNetworkUsageForResource(TaskManager::Resource* resource) const;
 
   // Called on the UI thread when some bytes are read.
   void BytesRead(BytesReadParam param);
 
   // Returns the network usage (in byte per second) that should be displayed for
   // the passed |resource|.  -1 means the information is not available for that
   // resource.
@@ skipping 63 matching lines @@
   // Whether we are currently in the process of updating.
   UpdateState update_state_;
 
   // A salt lick for the goats.
   int goat_salt_;
 
   DISALLOW_COPY_AND_ASSIGN(TaskManagerModel);
 };
 
 #endif  // CHROME_BROWSER_TASK_MANAGER_TASK_MANAGER_H_