Switch to using scoped_ptr with UserData

content/browser/appcache/appcache_request_handler_unittest.cc

 // Copyright 2014 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 "content/browser/appcache/appcache_request_handler.h"
 
 #include <stdint.h>
 
 #include <stack>
 #include <string>
@@ skipping 253 matching lines @@
 
   // MainResource_Miss --------------------------------------------------
 
   void MainResource_Miss() {
     PushNextTask(
         base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Miss,
                    base::Unretained(this)));
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
 
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     // We have to wait for completion of storage->FindResponseForMainRequest.
     ScheduleNextTask();
   }
@@ skipping 25 matching lines @@
 
   // MainResource_Hit --------------------------------------------------
 
   void MainResource_Hit() {
     PushNextTask(
         base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Hit,
                    base::Unretained(this)));
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         GURL(), AppCacheEntry(),
         1, 2, GURL("http://blah/manifest/"));
 
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_TRUE(job_.get());
@@ skipping 27 matching lines @@
 
   // MainResource_Fallback --------------------------------------------------
 
   void MainResource_Fallback() {
     PushNextTask(
         base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Fallback,
                    base::Unretained(this)));
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(),
         GURL("http://blah/fallbackurl"),
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         1, 2, GURL("http://blah/manifest/"));
 
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
@@ skipping 65 matching lines @@
   // MainResource_FallbackOverride --------------------------------------------
 
   void MainResource_FallbackOverride() {
     PushNextTask(base::Bind(
         &AppCacheRequestHandlerTest::Verify_MainResource_FallbackOverride,
         base::Unretained(this)));
 
     request_ =
         empty_context_->CreateRequest(GURL("http://blah/fallback-override"),
                                       net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
 
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(),
         GURL("http://blah/fallbackurl"),
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         1, 2, GURL("http://blah/manifest/"));
 
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
@@ skipping 42 matching lines @@
     EXPECT_TRUE(manifest_url.is_empty());
 
     TestFinished();
   }
 
   // SubResource_Miss_WithNoCacheSelected ----------------------------------
 
   void SubResource_Miss_WithNoCacheSelected() {
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_SUB_RESOURCE, false);
 
     // We avoid creating handler when possible, sub-resource requests are not
     // subject to retrieval from an appcache when there's no associated cache.
     EXPECT_FALSE(handler_.get());
 
     TestFinished();
   }
 
   // SubResource_Miss_WithCacheSelected ----------------------------------
 
   void SubResource_Miss_WithCacheSelected() {
     // A sub-resource load where the resource is not in an appcache, or
     // in a network or fallback namespace, should result in a failed request.
     host_->AssociateCompleteCache(MakeNewCache());
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
 
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_delivering_error_response());
 
     std::unique_ptr<AppCacheURLRequestJob> fallback_job(
         handler_->MaybeLoadFallbackForRedirect(
             request_.get(), request_->context()->network_delegate(),
             GURL("http://blah/redirect")));
     EXPECT_FALSE(fallback_job);
     fallback_job.reset(handler_->MaybeLoadFallbackForResponse(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_Miss_WithWaitForCacheSelection -----------------------------
 
   void SubResource_Miss_WithWaitForCacheSelection() {
     // Precondition, the host is waiting on cache selection.
     scoped_refptr<AppCache> cache(MakeNewCache());
     host_->pending_selected_cache_id_ = cache->cache_id();
     host_->set_preferred_manifest_url(cache->owning_group()->manifest_url());
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     host_->FinishCacheSelection(cache.get(), NULL);
     EXPECT_FALSE(job_->is_waiting());
     EXPECT_TRUE(job_->is_delivering_error_response());
 
@@ skipping 12 matching lines @@
   // SubResource_Hit -----------------------------
 
   void SubResource_Hit() {
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1), AppCacheEntry(), false);
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_delivering_appcache_response());
 
     std::unique_ptr<AppCacheURLRequestJob> fallback_job(
         handler_->MaybeLoadFallbackForRedirect(
             request_.get(), request_->context()->network_delegate(),
             GURL("http://blah/redirect")));
@@ skipping 10 matching lines @@
   void SubResource_RedirectFallback() {
     // Redirects to resources in the a different origin are subject to
     // fallback namespaces.
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(), AppCacheEntry(AppCacheEntry::EXPLICIT, 1), false);
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_FALSE(job_.get());
 
     job_.reset(handler_->MaybeLoadFallbackForRedirect(
         request_.get(), request_->context()->network_delegate(),
         GURL("http://not_blah/redirect")));
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_delivering_appcache_response());
@@ skipping 11 matching lines @@
   void SubResource_NoRedirectFallback() {
     // Redirects to resources in the same-origin are not subject to
     // fallback namespaces.
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(), AppCacheEntry(AppCacheEntry::EXPLICIT, 1), false);
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_FALSE(job_.get());
 
     std::unique_ptr<AppCacheURLRequestJob> fallback_job(
         handler_->MaybeLoadFallbackForRedirect(
             request_.get(), request_->context()->network_delegate(),
             GURL("http://blah/redirect")));
     EXPECT_FALSE(fallback_job);
@@ skipping 12 matching lines @@
     // A sub-resource load where the resource is in a network namespace,
     // should result in the system using a 'real' job to do the network
     // retrieval.
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(), AppCacheEntry(), true);
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_FALSE(job_.get());
 
     std::unique_ptr<AppCacheURLRequestJob> fallback_job(
         handler_->MaybeLoadFallbackForRedirect(
             request_.get(), request_->context()->network_delegate(),
             GURL("http://blah/redirect")));
     EXPECT_FALSE(fallback_job);
     fallback_job.reset(handler_->MaybeLoadFallbackForResponse(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // DestroyedHost -----------------------------
 
   void DestroyedHost() {
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1), AppCacheEntry(), false);
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
 
     backend_impl_->UnregisterHost(1);
     host_ = NULL;
 
     EXPECT_FALSE(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
         request_.get(),
         request_->context()->network_delegate(),
         GURL("http://blah/redirect")));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
         request_.get(), request_->context()->network_delegate()));
 
     TestFinished();
   }
 
   // DestroyedHostWithWaitingJob -----------------------------
 
   void DestroyedHostWithWaitingJob() {
     // Precondition, the host is waiting on cache selection.
     host_->pending_selected_cache_id_ = 1;
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
 
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
 
     backend_impl_->UnregisterHost(1);
     host_ = NULL;
     EXPECT_TRUE(job_->has_been_killed());
@@ skipping 13 matching lines @@
   // DestroyedService -----------------------------
 
   void DestroyedService() {
     host_->AssociateCompleteCache(MakeNewCache());
 
     mock_storage()->SimulateFindSubResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1), AppCacheEntry(), false);
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_TRUE(job_.get());
 
     backend_impl_.reset();
     mock_frontend_.reset();
     mock_service_.reset();
     mock_policy_.reset();
     host_ = NULL;
 
     EXPECT_TRUE(job_->has_been_killed());
     EXPECT_FALSE(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
         request_.get(),
         request_->context()->network_delegate(),
         GURL("http://blah/redirect")));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
         request_.get(), request_->context()->network_delegate()));
 
     TestFinished();
   }
 
   void DestroyedServiceWithCrossSiteNav() {
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
     handler_->PrepareForCrossSiteTransfer(backend_impl_->process_id());
     EXPECT_TRUE(handler_->host_for_cross_site_transfer_.get());
 
     backend_impl_.reset();
     mock_frontend_.reset();
     mock_service_.reset();
     mock_policy_.reset();
     host_ = NULL;
 
@@ skipping 11 matching lines @@
   }
 
   // UnsupportedScheme -----------------------------
 
   void UnsupportedScheme() {
     // Precondition, the host is waiting on cache selection.
     host_->pending_selected_cache_id_ = 1;
 
     request_ = empty_context_->CreateRequest(GURL("ftp://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_SUB_RESOURCE,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_SUB_RESOURCE, false);
     EXPECT_TRUE(handler_.get());  // we could redirect to http (conceivably)
 
     EXPECT_FALSE(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForRedirect(
         request_.get(),
         request_->context()->network_delegate(),
         GURL("ftp://blah/redirect")));
     EXPECT_FALSE(handler_->MaybeLoadFallbackForResponse(
         request_.get(), request_->context()->network_delegate()));
 
     TestFinished();
   }
 
   // CanceledRequest -----------------------------
 
   void CanceledRequest() {
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
 
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_TRUE(job_.get());
     EXPECT_TRUE(job_->is_waiting());
     EXPECT_FALSE(job_->has_been_started());
 
     base::WeakPtr<AppCacheURLRequestJob> weak_job = job_->GetWeakPtr();
 
@@ skipping 27 matching lines @@
                                              net::DEFAULT_PRIORITY, &delegate_);
 
     const int kParentHostId = host_->host_id();
     const int kWorkerHostId = 2;
     const int kAbandonedWorkerHostId = 3;
     const int kNonExsitingHostId = 700;
 
     backend_impl_->RegisterHost(kWorkerHostId);
     AppCacheHost* worker_host = backend_impl_->GetHost(kWorkerHostId);
     worker_host->SelectCacheForWorker(kParentHostId, kMockProcessId);
-    handler_.reset(worker_host->CreateRequestHandler(
-        request_.get(), RESOURCE_TYPE_SHARED_WORKER, false));
+    handler_ = worker_host->CreateRequestHandler(
+        request_.get(), RESOURCE_TYPE_SHARED_WORKER, false);
     EXPECT_TRUE(handler_.get());
     // Verify that the handler is associated with the parent host.
     EXPECT_EQ(host_, handler_->host_);
 
     // Create a new worker host, but associate it with a parent host that
     // does not exists to simulate the host having been torn down.
     backend_impl_->UnregisterHost(kWorkerHostId);
     backend_impl_->RegisterHost(kAbandonedWorkerHostId);
     worker_host = backend_impl_->GetHost(kAbandonedWorkerHostId);
     EXPECT_EQ(NULL, backend_impl_->GetHost(kNonExsitingHostId));
     worker_host->SelectCacheForWorker(kNonExsitingHostId, kMockProcessId);
-    handler_.reset(worker_host->CreateRequestHandler(
-        request_.get(), RESOURCE_TYPE_SHARED_WORKER, false));
+    handler_ = worker_host->CreateRequestHandler(
+        request_.get(), RESOURCE_TYPE_SHARED_WORKER, false);
     EXPECT_FALSE(handler_.get());
 
     TestFinished();
   }
 
   // MainResource_Blocked --------------------------------------------------
 
   void MainResource_Blocked() {
     PushNextTask(
         base::Bind(&AppCacheRequestHandlerTest::Verify_MainResource_Blocked,
                    base::Unretained(this)));
 
     request_ = empty_context_->CreateRequest(GURL("http://blah/"),
                                              net::DEFAULT_PRIORITY, &delegate_);
-    handler_.reset(host_->CreateRequestHandler(request_.get(),
-                                               RESOURCE_TYPE_MAIN_FRAME,
-                                               false));
+    handler_ = host_->CreateRequestHandler(request_.get(),
+                                           RESOURCE_TYPE_MAIN_FRAME, false);
     EXPECT_TRUE(handler_.get());
 
     mock_policy_->can_load_return_value_ = false;
     mock_storage()->SimulateFindMainResource(
         AppCacheEntry(AppCacheEntry::EXPLICIT, 1),
         GURL(), AppCacheEntry(),
         1, 2, GURL("http://blah/manifest/"));
 
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
@@ skipping 134 matching lines @@
 
 TEST_F(AppCacheRequestHandlerTest, WorkerRequest) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::WorkerRequest);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Blocked) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Blocked);
 }
 
 }  // namespace content