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);
-}
+      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {}

[rvargas (doing something else), 2011/05/18 21:45:18]

nit: Could you move the closing bracket to the next line? I think we use that
pattern more often for methods that are not being declared at the same time. You
do the same at line 39, but line 36 has the more common pattern.

[willchan no longer on Chromium, 2011/05/18 23:55:55]

Done.

 
 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() {
   request_ = NULL;
@@ skipping 141 matching lines @@
 }
 
 int URLRequestJob::GetResponseCode() const {
   return -1;
 }
 
 HostPortPair URLRequestJob::GetSocketAddress() const {
   return HostPortPair();
 }
 
-URLRequestJob::~URLRequestJob() {
-  g_url_request_job_tracker.RemoveJob(this);
+void URLRequestJob::OnSuspend() {
+  Kill();
 }
 
+URLRequestJob::~URLRequestJob() {}
+
 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());
 
   // Initialize to the current time, and let the subclass optionally override
@@ skipping 135 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()->NotifyBytesRead(*request_, bytes_read);
 }
 
 bool URLRequestJob::FilterHasData() {
     return filter_.get() && filter_->stream_data_len();
 }
 
 void URLRequestJob::UpdatePacketReadTimes() {
 }
 
 }  // namespace net