Do not call callback->Run() until we are about to return from this

net/http/http_cache_unittest.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/http/http_cache.h"
 
 #include "base/hash_tables.h"
 #include "base/memory/scoped_vector.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "net/base/cache_type.h"
 #include "net/base/cert_status_flags.h"
 #include "net/base/host_port_pair.h"
 #include "net/base/load_flags.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/ssl_cert_request_info.h"
+#include "net/base/ssl_config_service.h"
 #include "net/disk_cache/disk_cache.h"
+#include "net/http/disk_cache_based_ssl_host_info.h"
 #include "net/http/http_byte_range.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_request_info.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_transaction.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/http/http_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ skipping 1001 matching lines @@
 
   int result;
   TestCompletionCallback callback;
   scoped_ptr<net::HttpTransaction> trans;
 };
 
 }  // namespace
 
 
 //-----------------------------------------------------------------------------
-// tests
+// HttpCache tests
 
 TEST(HttpCache, CreateThenDestroy) {
   MockHttpCache cache;
 
   scoped_ptr<net::HttpTransaction> trans;
   int rv = cache.http_cache()->CreateTransaction(&trans);
   EXPECT_EQ(net::OK, rv);
   ASSERT_TRUE(trans.get());
 }
 
@@ skipping 4121 matching lines @@
 
   // Verify that the entry is marked as incomplete.
   disk_cache::Entry* entry;
   ASSERT_TRUE(cache.OpenBackendEntry(kSimpleGET_Transaction.url, &entry));
   net::HttpResponseInfo response;
   bool truncated = false;
   EXPECT_TRUE(MockHttpCache::ReadResponseInfo(entry, &response, &truncated));
   EXPECT_TRUE(truncated);
   entry->Close();
 }
+
+//-----------------------------------------------------------------------------
+// DiskCacheBasedSSLHostInfo tests
+
+class DeleteSSLHostInfoCompletionCallback : public TestCompletionCallback {
+ public:
+  explicit DeleteSSLHostInfoCompletionCallback(net::SSLHostInfo* ssl_host_info)
+      : ssl_host_info_(ssl_host_info) {}
+
+  virtual void RunWithParams(const Tuple1<int>& params) {
+    delete ssl_host_info_;
+    TestCompletionCallback::RunWithParams(params);
+  }
+
+ private:
+  net::SSLHostInfo* ssl_host_info_;
+};
+
+// Tests that we can delete a DiskCacheBasedSSLHostInfo object in a
+// completion callback for DiskCacheBasedSSLHostInfo::WaitForDataReady.
+TEST(DiskCacheBasedSSLHostInfo, DeleteInCallback) {
+  net::CertVerifier cert_verifier;
+  // Use the blocking mock backend factory to force asynchronous completion
+  // of ssl_host_info->WaitForDataReady(), so that the callback will run.
+  MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
+  MockHttpCache cache(factory);
+  net::SSLConfig ssl_config;
+  net::SSLHostInfo* ssl_host_info =
+      new net::DiskCacheBasedSSLHostInfo("https://www.verisign.com", ssl_config,
+                                         &cert_verifier, cache.http_cache());
+  ssl_host_info->Start();
+  DeleteSSLHostInfoCompletionCallback callback(ssl_host_info);
+  int rv = ssl_host_info->WaitForDataReady(&callback);
+  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  // Now complete the backend creation and let the callback run.
+  factory->FinishCreation();
+  EXPECT_EQ(net::OK, callback.GetResult(rv));
+}