Add debug information for crbug.com/289715

net/url_request/url_request_http_job.cc

 // Copyright (c) 2012 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_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
+#include "base/debug/alias.h"
 #include "base/file_version_info.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/field_trial.h"
 #include "base/metrics/histogram.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/rand_util.h"
 #include "base/strings/string_util.h"
 #include "base/time/time.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
@@ skipping 178 matching lines @@
       done_(false),
       bytes_observed_in_packets_(0),
       request_time_snapshot_(),
       final_packet_time_(),
       filter_context_(new HttpFilterContext(this)),
       on_headers_received_callback_(
           base::Bind(&URLRequestHttpJob::OnHeadersReceivedCallback,
                      base::Unretained(this))),
       awaiting_callback_(false),
       http_user_agent_settings_(http_user_agent_settings),
+      destructor_was_called_(false),
+      transaction_state_(TRANSACTION_WAS_NOT_INITIALIZED),
       weak_factory_(this) {
   URLRequestThrottlerManager* manager = request->context()->throttler_manager();
   if (manager)
     throttling_entry_ = manager->RegisterRequestUrl(request->url());
 
   ResetTimer();
 }
 
 URLRequestHttpJob::~URLRequestHttpJob() {
   CHECK(!awaiting_callback_);
 
+  destructor_was_called_ = true;
+
   DCHECK(!sdch_test_control_ || !sdch_test_activated_);
   if (!is_cached_content_) {
     if (sdch_test_control_)
       RecordPacketStats(FilterContext::SDCH_EXPERIMENT_HOLDBACK);
     if (sdch_test_activated_)
       RecordPacketStats(FilterContext::SDCH_EXPERIMENT_DECODE);
   }
   // Make sure SDCH filters are told to emit histogram data while
   // filter_context_ is still alive.
   DestroyFilters();
@@ skipping 169 matching lines @@
 void URLRequestHttpJob::NotifyDone(const URLRequestStatus& status) {
   DoneWithRequest(FINISHED);
   URLRequestJob::NotifyDone(status);
 }
 
 void URLRequestHttpJob::DestroyTransaction() {
   DCHECK(transaction_.get());
 
   DoneWithRequest(ABORTED);
   transaction_.reset();
+  transaction_state_ = TRANSACTION_WAS_DESTROYED;
   response_info_ = NULL;
   receive_headers_end_ = base::TimeTicks();
 }
 
 void URLRequestHttpJob::StartTransaction() {
   if (network_delegate()) {
     OnCallToDelegate();
     int rv = network_delegate()->NotifyBeforeSendHeaders(
         request_, notify_before_headers_sent_callback_,
         &request_info_.extra_headers);
@@ skipping 41 matching lines @@
   }
 
   if (transaction_.get()) {
     rv = transaction_->RestartWithAuth(auth_credentials_, start_callback_);
     auth_credentials_ = AuthCredentials();
   } else {
     DCHECK(request_->context()->http_transaction_factory());
 
     rv = request_->context()->http_transaction_factory()->CreateTransaction(
         priority_, &transaction_);
+    if (rv == OK) {
+      transaction_state_ = TRANSACTION_WAS_INITIALIZED;
+    }
 
     if (rv == OK && request_info_.url.SchemeIsWSOrWSS()) {
       base::SupportsUserData::Data* data = request_->GetUserData(
           WebSocketHandshakeStreamBase::CreateHelper::DataKey());
       if (data) {
         transaction_->SetWebSocketHandshakeStreamCreateHelper(
             static_cast<WebSocketHandshakeStreamBase::CreateHelper*>(data));
       } else {
         rv = ERR_DISALLOWED_URL_SCHEME;
       }
@@ skipping 186 matching lines @@
   OnCallToDelegateComplete();
 
   if (result != net::OK) {
     std::string source("delegate");
     request_->net_log().AddEvent(NetLog::TYPE_CANCELLED,
                                  NetLog::StringCallback("source", &source));
     NotifyStartError(URLRequestStatus(URLRequestStatus::FAILED, result));
     return;
   }
 
-  DCHECK(transaction_.get());
+  // TODO(battre) crbug.com/289715
+  // Remove check for destructor_was_called_ and make CHECK(transaction_.get())
+  // a DCHECK again.
+  TransactionState state = transaction_state_;
+  base::debug::Alias(&state);
+  CHECK(!destructor_was_called_);

[mmenke, 2015/01/09 16:11:57]

If the destructor was already called, what are the odds of us actually getting
this far?  Also, shouldn't this be in OnHeadersReceivedCallback?

If we want to by more robust, my suggestion is to temporarily make
OnHeadersReceivedCallback static and add a weak ptr factory like this:

static URLRequestHttpJob
OnHeadersReceivedCallback(scoped:ptr<base::WeakPtr<URLRequestHttpJob>> job, int
result) {
  CHECK(**job);
  // Alias transaction_state_ here.
  CHECK((*job)->transaction_);
  // Current OnHeadersReceivedCallback code here, using **job.
}

[battre, 2015/01/09 16:46:14]

Done.

+  CHECK(transaction_.get());
 
   const HttpResponseInfo* response_info = transaction_->GetResponseInfo();
   DCHECK(response_info);
 
   response_cookies_.clear();
   response_cookies_save_index_ = 0;
 
   FetchResponseCookies(&response_cookies_);
 
   if (!GetResponseHeaders()->GetDateValue(&response_date_))
@@ skipping 886 matching lines @@
   return override_response_headers_.get() ?
              override_response_headers_.get() :
              transaction_->GetResponseInfo()->headers.get();
 }
 
 void URLRequestHttpJob::NotifyURLRequestDestroyed() {
   awaiting_callback_ = false;
 }
 
 }  // namespace net