summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--android_webview/browser/net/aw_url_request_context_getter.cc4
-rw-r--r--blimp/engine/browser/blimp_url_request_context_getter.cc6
-rw-r--r--chrome/browser/profiles/off_the_record_profile_io_data.cc11
-rw-r--r--chrome/browser/profiles/profile_impl_io_data.cc18
-rw-r--r--chrome/browser/profiles/profile_io_data.cc23
-rw-r--r--chrome/browser/profiles/profile_io_data.h4
-rw-r--r--content/shell/browser/shell_url_request_context_getter.cc7
-rw-r--r--net/http/disk_cache_based_quic_server_info_unittest.cc8
-rw-r--r--net/http/http_cache.cc52
-rw-r--r--net/http/http_cache.h18
-rw-r--r--net/http/http_cache_unittest.cc27
-rw-r--r--net/http/mock_http_cache.cc12
-rw-r--r--net/http/mock_http_cache.h3
-rw-r--r--net/url_request/url_request_context_builder.cc8
-rw-r--r--net/url_request/url_request_unittest.cc2
-rw-r--r--net/url_request/view_cache_helper_unittest.cc3
16 files changed, 101 insertions, 105 deletions
diff --git a/android_webview/browser/net/aw_url_request_context_getter.cc b/android_webview/browser/net/aw_url_request_context_getter.cc
index 607e1d0..4de5a33 100644
--- a/android_webview/browser/net/aw_url_request_context_getter.cc
+++ b/android_webview/browser/net/aw_url_request_context_getter.cc
@@ -233,12 +233,12 @@ void AwURLRequestContextGetter::InitializeURLRequestContext() {
new net::HttpNetworkSession(network_session_params));
main_http_factory_.reset(new net::HttpCache(
http_network_session_.get(),
- new net::HttpCache::DefaultBackend(
+ make_scoped_ptr(new net::HttpCache::DefaultBackend(
net::DISK_CACHE,
net::CACHE_BACKEND_SIMPLE,
cache_path_,
20 * 1024 * 1024, // 20M
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)),
+ BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE))),
true /* set_up_quic_server_info */));
url_request_context_->set_http_transaction_factory(main_http_factory_.get());
diff --git a/blimp/engine/browser/blimp_url_request_context_getter.cc b/blimp/engine/browser/blimp_url_request_context_getter.cc
index f2bc1de..93a4dda 100644
--- a/blimp/engine/browser/blimp_url_request_context_getter.cc
+++ b/blimp/engine/browser/blimp_url_request_context_getter.cc
@@ -142,11 +142,11 @@ net::URLRequestContext* BlimpURLRequestContextGetter::GetURLRequestContext() {
make_scoped_ptr(new net::HttpServerPropertiesImpl()));
base::FilePath cache_path = base_path_.Append(FILE_PATH_LITERAL("Cache"));
- net::HttpCache::DefaultBackend* main_backend =
+ scoped_ptr<net::HttpCache::DefaultBackend> main_backend(
new net::HttpCache::DefaultBackend(
net::DISK_CACHE, net::CACHE_BACKEND_DEFAULT, cache_path, 0,
content::BrowserThread::GetMessageLoopProxyForThread(
- content::BrowserThread::CACHE));
+ content::BrowserThread::CACHE)));
net::HttpNetworkSession::Params network_session_params;
network_session_params.cert_verifier =
@@ -183,7 +183,7 @@ net::URLRequestContext* BlimpURLRequestContextGetter::GetURLRequestContext() {
storage_->set_http_network_session(
make_scoped_ptr(new net::HttpNetworkSession(network_session_params)));
storage_->set_http_transaction_factory(make_scoped_ptr(new net::HttpCache(
- storage_->http_network_session(), main_backend, true)));
+ storage_->http_network_session(), main_backend.Pass(), true)));
scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(
new net::URLRequestJobFactoryImpl());
diff --git a/chrome/browser/profiles/off_the_record_profile_io_data.cc b/chrome/browser/profiles/off_the_record_profile_io_data.cc
index 908df15..d3fb0aac 100644
--- a/chrome/browser/profiles/off_the_record_profile_io_data.cc
+++ b/chrome/browser/profiles/off_the_record_profile_io_data.cc
@@ -245,11 +245,9 @@ void OffTheRecordProfileIOData::InitializeInternal(
NULL,
profile_params->cookie_monster_delegate.get())));
- net::HttpCache::BackendFactory* main_backend =
- net::HttpCache::DefaultBackend::InMemory(0);
http_network_session_ = CreateHttpNetworkSession(*profile_params);
- main_http_factory_ = CreateMainHttpFactory(http_network_session_.get(),
- main_backend);
+ main_http_factory_ = CreateMainHttpFactory(
+ http_network_session_.get(), net::HttpCache::DefaultBackend::InMemory(0));
main_context->set_http_transaction_factory(main_http_factory_.get());
#if !defined(DISABLE_FTP_SUPPORT)
@@ -345,10 +343,9 @@ net::URLRequestContext* OffTheRecordProfileIOData::InitializeAppRequestContext(
content::CreateCookieStore(content::CookieStoreConfig()));
// Use a separate in-memory cache for the app.
- net::HttpCache::BackendFactory* app_backend =
- net::HttpCache::DefaultBackend::InMemory(0);
scoped_ptr<net::HttpCache> app_http_cache =
- CreateHttpFactory(http_network_session_.get(), app_backend);
+ CreateHttpFactory(http_network_session_.get(),
+ net::HttpCache::DefaultBackend::InMemory(0));
context->SetHttpTransactionFactory(app_http_cache.Pass());
diff --git a/chrome/browser/profiles/profile_impl_io_data.cc b/chrome/browser/profiles/profile_impl_io_data.cc
index f8f5336..dd5c78a 100644
--- a/chrome/browser/profiles/profile_impl_io_data.cc
+++ b/chrome/browser/profiles/profile_impl_io_data.cc
@@ -539,7 +539,7 @@ void ProfileImplIOData::InitializeInternal(
// TODO(ttuttle): Remove ScopedTracker below once crbug.com/436671 is fixed.
tracked_objects::ScopedTracker tracking_profile(
FROM_HERE_WITH_EXPLICIT_FUNCTION("436671 HttpCache construction"));
- net::HttpCache::BackendFactory* main_backend(
+ scoped_ptr<net::HttpCache::BackendFactory> main_backend(
new net::HttpCache::DefaultBackend(
net::DISK_CACHE,
ChooseCacheBackendType(),
@@ -548,7 +548,7 @@ void ProfileImplIOData::InitializeInternal(
BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)));
http_network_session_ = CreateHttpNetworkSession(*profile_params);
main_http_factory_ = CreateMainHttpFactory(http_network_session_.get(),
- main_backend);
+ main_backend.Pass());
}
main_context->set_http_transaction_factory(main_http_factory_.get());
@@ -660,19 +660,19 @@ net::URLRequestContext* ProfileImplIOData::InitializeAppRequestContext(
partition_descriptor.path.Append(chrome::kCacheDirname);
// Use a separate HTTP disk cache for isolated apps.
- net::HttpCache::BackendFactory* app_backend;
+ scoped_ptr<net::HttpCache::BackendFactory> app_backend;
if (partition_descriptor.in_memory) {
app_backend = net::HttpCache::DefaultBackend::InMemory(0);
} else {
- app_backend = new net::HttpCache::DefaultBackend(
+ app_backend.reset(new net::HttpCache::DefaultBackend(
net::DISK_CACHE,
ChooseCacheBackendType(),
cache_path,
app_cache_max_size_,
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
+ BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)));
}
scoped_ptr<net::HttpCache> app_http_cache =
- CreateHttpFactory(http_network_session_.get(), app_backend);
+ CreateHttpFactory(http_network_session_.get(), app_backend.Pass());
scoped_refptr<net::CookieStore> cookie_store = NULL;
if (partition_descriptor.in_memory) {
@@ -744,15 +744,15 @@ ProfileImplIOData::InitializeMediaRequestContext(
}
// Use a separate HTTP disk cache for isolated apps.
- net::HttpCache::BackendFactory* media_backend =
+ scoped_ptr<net::HttpCache::BackendFactory> media_backend(
new net::HttpCache::DefaultBackend(
net::MEDIA_CACHE,
ChooseCacheBackendType(),
cache_path,
cache_max_size,
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
+ BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)));
scoped_ptr<net::HttpCache> media_http_cache =
- CreateHttpFactory(http_network_session_.get(), media_backend);
+ CreateHttpFactory(http_network_session_.get(), media_backend.Pass());
// Transfer ownership of the cache to MediaRequestContext.
context->SetHttpTransactionFactory(media_http_cache.Pass());
diff --git a/chrome/browser/profiles/profile_io_data.cc b/chrome/browser/profiles/profile_io_data.cc
index b53eb25..3e331d5 100644
--- a/chrome/browser/profiles/profile_io_data.cc
+++ b/chrome/browser/profiles/profile_io_data.cc
@@ -1331,23 +1331,20 @@ scoped_ptr<net::HttpNetworkSession> ProfileIOData::CreateHttpNetworkSession(
scoped_ptr<net::HttpCache> ProfileIOData::CreateMainHttpFactory(
net::HttpNetworkSession* session,
- net::HttpCache::BackendFactory* main_backend) const {
- net::URLRequestContext* context = main_request_context();
- return scoped_ptr<net::HttpCache>(new net::HttpCache(
- new DevToolsNetworkTransactionFactory(
- network_controller_handle_.GetController(), session),
- context->net_log(), main_backend,
- true /* set_up_quic_server_info */));
+ scoped_ptr<net::HttpCache::BackendFactory> main_backend) const {
+ return make_scoped_ptr(new net::HttpCache(
+ make_scoped_ptr(new DevToolsNetworkTransactionFactory(
+ network_controller_handle_.GetController(), session)),
+ main_backend.Pass(), true /* set_up_quic_server_info */));
}
scoped_ptr<net::HttpCache> ProfileIOData::CreateHttpFactory(
net::HttpNetworkSession* shared_session,
- net::HttpCache::BackendFactory* backend) const {
- return scoped_ptr<net::HttpCache>(new net::HttpCache(
- new DevToolsNetworkTransactionFactory(
- network_controller_handle_.GetController(), shared_session),
- shared_session->net_log(), backend,
- true /* set_up_quic_server_info */));
+ scoped_ptr<net::HttpCache::BackendFactory> backend) const {
+ return make_scoped_ptr(new net::HttpCache(
+ make_scoped_ptr(new DevToolsNetworkTransactionFactory(
+ network_controller_handle_.GetController(), shared_session)),
+ backend.Pass(), true /* set_up_quic_server_info */));
}
void ProfileIOData::SetCookieSettingsForTesting(
diff --git a/chrome/browser/profiles/profile_io_data.h b/chrome/browser/profiles/profile_io_data.h
index ea807b0..350ba73 100644
--- a/chrome/browser/profiles/profile_io_data.h
+++ b/chrome/browser/profiles/profile_io_data.h
@@ -389,12 +389,12 @@ class ProfileIOData {
// Creates main network transaction factory.
scoped_ptr<net::HttpCache> CreateMainHttpFactory(
net::HttpNetworkSession* session,
- net::HttpCache::BackendFactory* main_backend) const;
+ scoped_ptr<net::HttpCache::BackendFactory> main_backend) const;
// Creates network transaction factory.
scoped_ptr<net::HttpCache> CreateHttpFactory(
net::HttpNetworkSession* shared_session,
- net::HttpCache::BackendFactory* backend) const;
+ scoped_ptr<net::HttpCache::BackendFactory> backend) const;
void SetCookieSettingsForTesting(
content_settings::CookieSettings* cookie_settings);
diff --git a/content/shell/browser/shell_url_request_context_getter.cc b/content/shell/browser/shell_url_request_context_getter.cc
index 354f9c6..f1eaa01 100644
--- a/content/shell/browser/shell_url_request_context_getter.cc
+++ b/content/shell/browser/shell_url_request_context_getter.cc
@@ -141,7 +141,7 @@ net::URLRequestContext* ShellURLRequestContextGetter::GetURLRequestContext() {
make_scoped_ptr(new net::HttpServerPropertiesImpl()));
base::FilePath cache_path = base_path_.Append(FILE_PATH_LITERAL("Cache"));
- net::HttpCache::DefaultBackend* main_backend =
+ scoped_ptr<net::HttpCache::DefaultBackend> main_backend(
new net::HttpCache::DefaultBackend(
net::DISK_CACHE,
#if defined(OS_ANDROID)
@@ -153,7 +153,7 @@ net::URLRequestContext* ShellURLRequestContextGetter::GetURLRequestContext() {
#endif
cache_path,
0,
- BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE));
+ BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE)));
net::HttpNetworkSession::Params network_session_params;
network_session_params.cert_verifier =
@@ -204,7 +204,8 @@ net::URLRequestContext* ShellURLRequestContextGetter::GetURLRequestContext() {
storage_->set_http_network_session(
make_scoped_ptr(new net::HttpNetworkSession(network_session_params)));
storage_->set_http_transaction_factory(make_scoped_ptr(
- new net::HttpCache(storage_->http_network_session(), main_backend,
+ new net::HttpCache(storage_->http_network_session(),
+ main_backend.Pass(),
true /* set_up_quic_server_info */)));
scoped_ptr<net::URLRequestJobFactoryImpl> job_factory(
diff --git a/net/http/disk_cache_based_quic_server_info_unittest.cc b/net/http/disk_cache_based_quic_server_info_unittest.cc
index 8d390cf..6962fdf 100644
--- a/net/http/disk_cache_based_quic_server_info_unittest.cc
+++ b/net/http/disk_cache_based_quic_server_info_unittest.cc
@@ -85,7 +85,7 @@ TEST(DiskCacheBasedQuicServerInfo, DeleteInCallback) {
// Use the blocking mock backend factory to force asynchronous completion
// of quic_server_info->WaitForDataReady(), so that the callback will run.
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
- MockHttpCache cache(factory);
+ MockHttpCache cache(make_scoped_ptr(factory));
QuicServerId server_id("www.verisign.com", 443, PRIVACY_MODE_DISABLED);
scoped_ptr<QuicServerInfo> quic_server_info(
new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache()));
@@ -390,7 +390,7 @@ TEST(DiskCacheBasedQuicServerInfo, MultiplePersist) {
TEST(DiskCacheBasedQuicServerInfo, CancelWaitForDataReady) {
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
- MockHttpCache cache(factory);
+ MockHttpCache cache(make_scoped_ptr(factory));
TestCompletionCallback callback;
QuicServerId server_id("www.google.com", 443, PRIVACY_MODE_DISABLED);
scoped_ptr<QuicServerInfo> quic_server_info(
@@ -508,7 +508,7 @@ TEST(DiskCacheBasedQuicServerInfo, StartAndPersist) {
// persists the data when Start() finishes.
TEST(DiskCacheBasedQuicServerInfo, PersistWhenNotReadyToPersist) {
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
- MockHttpCache cache(factory);
+ MockHttpCache cache(make_scoped_ptr(factory));
AddMockTransaction(&kHostInfoTransaction1);
TestCompletionCallback callback;
@@ -639,7 +639,7 @@ TEST(DiskCacheBasedQuicServerInfo, DeleteServerInfoInCallback) {
// Use the blocking mock backend factory to force asynchronous completion
// of quic_server_info->WaitForDataReady(), so that the callback will run.
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
- MockHttpCache cache(factory);
+ MockHttpCache cache(make_scoped_ptr(factory));
QuicServerId server_id("www.verisign.com", 443, PRIVACY_MODE_DISABLED);
QuicServerInfo* quic_server_info =
new DiskCacheBasedQuicServerInfo(server_id, cache.http_cache());
diff --git a/net/http/http_cache.cc b/net/http/http_cache.cc
index 7494b86..6a33acb 100644
--- a/net/http/http_cache.cc
+++ b/net/http/http_cache.cc
@@ -74,9 +74,11 @@ HttpCache::DefaultBackend::DefaultBackend(
HttpCache::DefaultBackend::~DefaultBackend() {}
// static
-HttpCache::BackendFactory* HttpCache::DefaultBackend::InMemory(int max_bytes) {
- return new DefaultBackend(MEMORY_CACHE, CACHE_BACKEND_DEFAULT,
- base::FilePath(), max_bytes, NULL);
+scoped_ptr<HttpCache::BackendFactory> HttpCache::DefaultBackend::InMemory(
+ int max_bytes) {
+ return make_scoped_ptr(new DefaultBackend(MEMORY_CACHE, CACHE_BACKEND_DEFAULT,
+ base::FilePath(), max_bytes,
+ nullptr));
}
int HttpCache::DefaultBackend::CreateBackend(
@@ -294,31 +296,38 @@ class HttpCache::QuicServerInfoFactoryAdaptor : public QuicServerInfoFactory {
};
//-----------------------------------------------------------------------------
-// This call doesn't change the shared |session|'s QuicServerInfoFactory because
-// |session| is shared.
HttpCache::HttpCache(HttpNetworkSession* session,
- BackendFactory* backend_factory,
+ scoped_ptr<BackendFactory> backend_factory,
bool set_up_quic_server_info)
- : HttpCache(new HttpNetworkLayer(session),
- session->net_log(),
- backend_factory,
+ : HttpCache(make_scoped_ptr(new HttpNetworkLayer(session)),
+ backend_factory.Pass(),
set_up_quic_server_info) {}
-HttpCache::HttpCache(HttpTransactionFactory* network_layer,
- NetLog* net_log,
- BackendFactory* backend_factory,
+HttpCache::HttpCache(scoped_ptr<HttpTransactionFactory> network_layer,
+ scoped_ptr<BackendFactory> backend_factory,
bool set_up_quic_server_info)
- : net_log_(net_log),
- backend_factory_(backend_factory),
+ : net_log_(nullptr),
+ backend_factory_(backend_factory.Pass()),
building_backend_(false),
bypass_lock_for_test_(false),
fail_conditionalization_for_test_(false),
mode_(NORMAL),
- network_layer_(network_layer),
+ network_layer_(network_layer.Pass()),
clock_(new base::DefaultClock()),
weak_factory_(this) {
- if (set_up_quic_server_info)
- SetupQuicServerInfoFactory(network_layer_->GetSession());
+ HttpNetworkSession* session = network_layer_->GetSession();
+ // Session may be NULL in unittests.
+ // TODO(mmenke): Seems like tests could be changed to provide a session,
+ // rather than having logic only used in unit tests here.
+ if (session) {
+ net_log_ = session->net_log();
+ if (set_up_quic_server_info &&
+ !session->quic_stream_factory()->has_quic_server_info_factory()) {
+ // QuicStreamFactory takes ownership of QuicServerInfoFactoryAdaptor.
+ session->quic_stream_factory()->set_quic_server_info_factory(
+ new QuicServerInfoFactoryAdaptor(this));
+ }
+ }
}
HttpCache::~HttpCache() {
@@ -978,15 +987,6 @@ bool HttpCache::RemovePendingTransactionFromPendingOp(PendingOp* pending_op,
return false;
}
-void HttpCache::SetupQuicServerInfoFactory(HttpNetworkSession* session) {
- if (session &&
- !session->quic_stream_factory()->has_quic_server_info_factory()) {
- // QuicStreamFactory takes ownership of QuicServerInfoFactoryAdaptor.
- session->quic_stream_factory()->set_quic_server_info_factory(
- new QuicServerInfoFactoryAdaptor(this));
- }
-}
-
void HttpCache::ProcessPendingQueue(ActiveEntry* entry) {
// Multiple readers may finish with an entry at once, so we want to batch up
// calls to OnProcessPendingQueue. This flag also tells us that we should
diff --git a/net/http/http_cache.h b/net/http/http_cache.h
index d504941..c960bbd 100644
--- a/net/http/http_cache.h
+++ b/net/http/http_cache.h
@@ -106,7 +106,7 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory,
~DefaultBackend() override;
// Returns a factory for an in-memory cache.
- static BackendFactory* InMemory(int max_bytes);
+ static scoped_ptr<BackendFactory> InMemory(int max_bytes);
// BackendFactory implementation.
int CreateBackend(NetLog* net_log,
@@ -136,15 +136,13 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory,
// If |set_up_quic_server_info| is true, configures the cache to track
// information about servers supporting QUIC.
HttpCache(HttpNetworkSession* session,
- BackendFactory* backend_factory,
+ scoped_ptr<BackendFactory> backend_factory,
bool set_up_quic_server_info);
- // Initialize the cache from its component parts. The lifetime of the
- // |network_layer| and |backend_factory| are managed by the HttpCache and
- // will be destroyed using |delete| when the HttpCache is destroyed.
- HttpCache(HttpTransactionFactory* network_layer,
- NetLog* net_log,
- BackendFactory* backend_factory,
+ // Initialize the cache from its component parts. |network_layer| and
+ // |backend_factory| will be destroyed when the HttpCache is.
+ HttpCache(scoped_ptr<HttpTransactionFactory> network_layer,
+ scoped_ptr<BackendFactory> backend_factory,
bool set_up_quic_server_info);
~HttpCache() override;
@@ -380,10 +378,6 @@ class NET_EXPORT HttpCache : public HttpTransactionFactory,
// Removes the transaction |trans|, from the pending list of |pending_op|.
bool RemovePendingTransactionFromPendingOp(PendingOp* pending_op,
Transaction* trans);
-
- // Instantiates and sets QUIC server info factory.
- void SetupQuicServerInfoFactory(HttpNetworkSession* session);
-
// Resumes processing the pending list of |entry|.
void ProcessPendingQueue(ActiveEntry* entry);
diff --git a/net/http/http_cache_unittest.cc b/net/http/http_cache_unittest.cc
index 6eeef8f1..84dec61 100644
--- a/net/http/http_cache_unittest.cc
+++ b/net/http/http_cache_unittest.cc
@@ -702,10 +702,11 @@ TEST(HttpCache, SimpleGETNoDiskCache) {
TEST(HttpCache, SimpleGETNoDiskCache2) {
// This will initialize a cache object with NULL backend.
- MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
+ scoped_ptr<MockBlockingBackendFactory> factory(
+ new MockBlockingBackendFactory());
factory->set_fail(true);
factory->FinishCreation(); // We'll complete synchronously.
- MockHttpCache cache(factory);
+ MockHttpCache cache(factory.Pass());
// Read from the network, and don't use the cache.
RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
@@ -1744,8 +1745,8 @@ TEST(HttpCache, SimpleGET_AbandonedCacheRead) {
// Tests that we can delete the HttpCache and deal with queued transactions
// ("waiting for the backend" as opposed to Active or Doomed entries).
TEST(HttpCache, SimpleGET_ManyWriters_DeleteCache) {
- scoped_ptr<MockHttpCache> cache(new MockHttpCache(
- new MockBackendNoCbFactory()));
+ scoped_ptr<MockHttpCache> cache(
+ new MockHttpCache(make_scoped_ptr(new MockBackendNoCbFactory())));
MockHttpRequest request(kSimpleGET_Transaction);
@@ -1782,7 +1783,7 @@ TEST(HttpCache, SimpleGET_ManyWriters_DeleteCache) {
// Tests that we queue requests when initializing the backend.
TEST(HttpCache, SimpleGET_WaitForBackend) {
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
- MockHttpCache cache(factory);
+ MockHttpCache cache(make_scoped_ptr(factory));
MockHttpRequest request0(kSimpleGET_Transaction);
MockHttpRequest request1(kTypicalGET_Transaction);
@@ -1828,7 +1829,7 @@ TEST(HttpCache, SimpleGET_WaitForBackend) {
// to be initialized.
TEST(HttpCache, SimpleGET_WaitForBackend_CancelCreate) {
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
- MockHttpCache cache(factory);
+ MockHttpCache cache(make_scoped_ptr(factory));
MockHttpRequest request0(kSimpleGET_Transaction);
MockHttpRequest request1(kTypicalGET_Transaction);
@@ -1882,7 +1883,7 @@ TEST(HttpCache, SimpleGET_WaitForBackend_CancelCreate) {
// Tests that we can delete the cache while creating the backend.
TEST(HttpCache, DeleteCacheWaitingForBackend) {
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
- scoped_ptr<MockHttpCache> cache(new MockHttpCache(factory));
+ scoped_ptr<MockHttpCache> cache(new MockHttpCache(make_scoped_ptr(factory)));
MockHttpRequest request(kSimpleGET_Transaction);
@@ -1914,7 +1915,7 @@ TEST(HttpCache, DeleteCacheWaitingForBackend) {
// one of the callbacks.
TEST(HttpCache, DeleteCacheWaitingForBackend2) {
MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
- MockHttpCache* cache = new MockHttpCache(factory);
+ MockHttpCache* cache = new MockHttpCache(make_scoped_ptr(factory));
DeleteCacheCompletionCallback cb(cache);
disk_cache::Backend* backend;
@@ -3081,10 +3082,11 @@ TEST(HttpCache, SimplePOST_NoUploadId_Invalidate_205) {
// Tests that processing a POST before creating the backend doesn't crash.
TEST(HttpCache, SimplePOST_NoUploadId_NoBackend) {
// This will initialize a cache object with NULL backend.
- MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
+ scoped_ptr<MockBlockingBackendFactory> factory(
+ new MockBlockingBackendFactory());
factory->set_fail(true);
factory->FinishCreation();
- MockHttpCache cache(factory);
+ MockHttpCache cache(factory.Pass());
ScopedVector<UploadElementReader> element_readers;
element_readers.push_back(new UploadBytesElementReader("hello", 5));
@@ -5417,10 +5419,11 @@ TEST(HttpCache, RangeGET_LargeValues) {
// Tests that we don't crash with a range request if the disk cache was not
// initialized properly.
TEST(HttpCache, RangeGET_NoDiskCache) {
- MockBlockingBackendFactory* factory = new MockBlockingBackendFactory();
+ scoped_ptr<MockBlockingBackendFactory> factory(
+ new MockBlockingBackendFactory());
factory->set_fail(true);
factory->FinishCreation(); // We'll complete synchronously.
- MockHttpCache cache(factory);
+ MockHttpCache cache(factory.Pass());
AddMockTransaction(&kRangeGET_TransactionOK);
diff --git a/net/http/mock_http_cache.cc b/net/http/mock_http_cache.cc
index ce49d33..184270a 100644
--- a/net/http/mock_http_cache.cc
+++ b/net/http/mock_http_cache.cc
@@ -524,10 +524,14 @@ int MockBackendFactory::CreateBackend(NetLog* net_log,
//-----------------------------------------------------------------------------
-MockHttpCache::MockHttpCache() : MockHttpCache(new MockBackendFactory()) {}
-
-MockHttpCache::MockHttpCache(HttpCache::BackendFactory* disk_cache_factory)
- : http_cache_(new MockNetworkLayer(), nullptr, disk_cache_factory, true) {}
+MockHttpCache::MockHttpCache()
+ : MockHttpCache(make_scoped_ptr(new MockBackendFactory())) {}
+
+MockHttpCache::MockHttpCache(
+ scoped_ptr<HttpCache::BackendFactory> disk_cache_factory)
+ : http_cache_(make_scoped_ptr(new MockNetworkLayer()),
+ disk_cache_factory.Pass(),
+ true) {}
disk_cache::Backend* MockHttpCache::backend() {
TestCompletionCallback cb;
diff --git a/net/http/mock_http_cache.h b/net/http/mock_http_cache.h
index 554b815..e0b8e71 100644
--- a/net/http/mock_http_cache.h
+++ b/net/http/mock_http_cache.h
@@ -177,7 +177,8 @@ class MockBackendFactory : public HttpCache::BackendFactory {
class MockHttpCache {
public:
MockHttpCache();
- explicit MockHttpCache(HttpCache::BackendFactory* disk_cache_factory);
+ explicit MockHttpCache(
+ scoped_ptr<HttpCache::BackendFactory> disk_cache_factory);
HttpCache* http_cache() { return &http_cache_; }
diff --git a/net/url_request/url_request_context_builder.cc b/net/url_request/url_request_context_builder.cc
index 0f049dc..fb7512c 100644
--- a/net/url_request/url_request_context_builder.cc
+++ b/net/url_request/url_request_context_builder.cc
@@ -397,18 +397,18 @@ scoped_ptr<URLRequestContext> URLRequestContextBuilder::Build() {
scoped_ptr<HttpTransactionFactory> http_transaction_factory;
if (http_cache_enabled_) {
- HttpCache::BackendFactory* http_cache_backend;
+ scoped_ptr<HttpCache::BackendFactory> http_cache_backend;
if (http_cache_params_.type == HttpCacheParams::DISK) {
- http_cache_backend = new HttpCache::DefaultBackend(
+ http_cache_backend.reset(new HttpCache::DefaultBackend(
DISK_CACHE, CACHE_BACKEND_DEFAULT, http_cache_params_.path,
- http_cache_params_.max_size, context->GetFileTaskRunner());
+ http_cache_params_.max_size, context->GetFileTaskRunner()));
} else {
http_cache_backend =
HttpCache::DefaultBackend::InMemory(http_cache_params_.max_size);
}
http_transaction_factory.reset(new HttpCache(
- storage->http_network_session(), http_cache_backend, true));
+ storage->http_network_session(), http_cache_backend.Pass(), true));
} else {
http_transaction_factory.reset(
new HttpNetworkLayer(storage->http_network_session()));
diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc
index 530c3e6..59e885f 100644
--- a/net/url_request/url_request_unittest.cc
+++ b/net/url_request/url_request_unittest.cc
@@ -7297,7 +7297,7 @@ TEST_F(URLRequestTestHTTP, NetworkSuspendTest) {
new HttpNetworkLayer(&network_session));
network_layer->OnSuspend();
- HttpCache http_cache(network_layer.release(), default_context_.net_log(),
+ HttpCache http_cache(network_layer.Pass(),
HttpCache::DefaultBackend::InMemory(0), true);
TestURLRequestContext context(true);
diff --git a/net/url_request/view_cache_helper_unittest.cc b/net/url_request/view_cache_helper_unittest.cc
index e10b203..9671700 100644
--- a/net/url_request/view_cache_helper_unittest.cc
+++ b/net/url_request/view_cache_helper_unittest.cc
@@ -31,8 +31,7 @@ class TestURLRequestContext : public URLRequestContext {
};
TestURLRequestContext::TestURLRequestContext()
- : cache_(new MockNetworkLayer(),
- nullptr,
+ : cache_(make_scoped_ptr(new MockNetworkLayer()),
HttpCache::DefaultBackend::InMemory(0),
true) {
set_http_transaction_factory(&cache_);
generated by cgit v1.1 at 2024-09-24 22:35:49 +0000