Kill URLRequestJobTracker.

net/url_request/url_request_job.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 "net/url_request/url_request_job.h"
 
 #include "base/compiler_specific.h"
 #include "base/message_loop.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "net/base/auth.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/io_buffer.h"
 #include "net/base/load_states.h"
 #include "net/base/net_errors.h"
 #include "net/base/network_delegate.h"
 #include "net/http/http_response_headers.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_context.h"
-#include "net/url_request/url_request_job_tracker.h"
 
 namespace net {
 
 URLRequestJob::URLRequestJob(URLRequest* request)
     : request_(request),
       done_(false),
       prefilter_bytes_read_(0),
       postfilter_bytes_read_(0),
       filter_input_byte_count_(0),
       filter_needs_more_output_space_(false),
       filtered_read_buffer_len_(0),
       has_handled_response_(false),
       expected_content_size_(-1),
       deferred_redirect_status_code_(-1),
       ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
-  g_url_request_job_tracker.AddNewJob(this);
+  base::SystemMonitor* system_monitor = base::SystemMonitor::Get();
+  if (system_monitor)
+    base::SystemMonitor::Get()->AddObserver(this);
 }
 
 void URLRequestJob::SetUpload(UploadData* upload) {
 }
 
-void URLRequestJob::SetExtraRequestHeaders(
-    const HttpRequestHeaders& headers) {
+void URLRequestJob::SetExtraRequestHeaders(const HttpRequestHeaders& headers) {
 }
 
 void URLRequestJob::Kill() {
   // Make sure the request is notified that we are done.  We assume that the
   // request took care of setting its error status before calling Kill.
   if (request_)
     NotifyCanceled();
 }
 
 void URLRequestJob::DetachRequest() {
@@ skipping 142 matching lines @@
 }
 
 int URLRequestJob::GetResponseCode() const {
   return -1;
 }
 
 HostPortPair URLRequestJob::GetSocketAddress() const {
   return HostPortPair();
 }
 
+void URLRequestJob::OnSuspend() {
+  Kill();
+}
+
 URLRequestJob::~URLRequestJob() {
-  g_url_request_job_tracker.RemoveJob(this);
+  base::SystemMonitor* system_monitor = base::SystemMonitor::Get();
+  if (system_monitor)
+    base::SystemMonitor::Get()->RemoveObserver(this);
 }
 
 void URLRequestJob::NotifyHeadersComplete() {
   if (!request_ || !request_->delegate())
     return;  // The request was destroyed, so there is no more work to do.
 
   if (has_handled_response_)
     return;
 
   DCHECK(!request_->status().is_io_pending());
@@ skipping 137 matching lines @@
     // With async IO, it's quite possible to have a few outstanding
     // requests.  We could receive a request to Cancel, followed shortly
     // by a successful IO.  For tracking the status(), once there is
     // an error, we do not change the status back to success.  To
     // enforce this, only set the status if the job is so far
     // successful.
     if (request_->status().is_success())
       request_->set_status(status);
   }
 
-  g_url_request_job_tracker.OnJobDone(this, status);
-
   if (request_ && request_->context() &&
       request_->context()->network_delegate()) {
     request_->context()->network_delegate()->NotifyCompleted(request_);
   }
 
   // Complete this notification later.  This prevents us from re-entering the
   // delegate if we're done because of a synchronous call.
   MessageLoop::current()->PostTask(
       FROM_HERE,
       method_factory_.NewRunnableMethod(&URLRequestJob::CompleteNotifyDone));
@@ skipping 194 matching lines @@
   if (!request_->status().is_io_pending()) {
     // If the read completes synchronously, either success or failure,
     // invoke the OnRawReadComplete callback so we can account for the
     // completed read.
     OnRawReadComplete(*bytes_read);
   }
   return rv;
 }
 
 void URLRequestJob::FollowRedirect(const GURL& location, int http_status_code) {
-  g_url_request_job_tracker.OnJobRedirect(this, location, http_status_code);
-
   int rv = request_->Redirect(location, http_status_code);
   if (rv != OK)
     NotifyDone(URLRequestStatus(URLRequestStatus::FAILED, rv));
 }
 
 void URLRequestJob::OnRawReadComplete(int bytes_read) {
   DCHECK(raw_read_buffer_);
   if (bytes_read > 0) {
     RecordBytesRead(bytes_read);
   }
   raw_read_buffer_ = NULL;
 }
 
 void URLRequestJob::RecordBytesRead(int bytes_read) {
   filter_input_byte_count_ += bytes_read;
   UpdatePacketReadTimes();  // Facilitate stats recording if it is active.
-  g_url_request_job_tracker.OnBytesRead(this, raw_read_buffer_->data(),
-                                        bytes_read);
+  const URLRequestContext* context = request_->context();
+  if (context && context->network_delegate())
+    context->network_delegate()->NotifyRawBytesRead(*request_, bytes_read);
 }
 
 bool URLRequestJob::FilterHasData() {
     return filter_.get() && filter_->stream_data_len();
 }
 
 void URLRequestJob::UpdatePacketReadTimes() {
 }
 
 }  // namespace net