Convert //content/browser from scoped_ptr to std::unique_ptr

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>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/single_thread_task_runner.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_backend_impl.h"
 #include "content/browser/appcache/appcache_url_request_job.h"
 #include "content/browser/appcache/mock_appcache_policy.h"
 #include "content/browser/appcache/mock_appcache_service.h"
@@ skipping 85 matching lines @@
     bool has_response_info_;
     net::HttpResponseInfo response_info_;
   };
 
   class MockURLRequestJobFactory : public net::URLRequestJobFactory {
    public:
     MockURLRequestJobFactory() {}
 
     ~MockURLRequestJobFactory() override { DCHECK(!job_); }
 
-    void SetJob(scoped_ptr<net::URLRequestJob> job) { job_ = std::move(job); }
+    void SetJob(std::unique_ptr<net::URLRequestJob> job) {
+      job_ = std::move(job);
+    }
 
     net::URLRequestJob* MaybeCreateJobWithProtocolHandler(
         const std::string& scheme,
         net::URLRequest* request,
         net::NetworkDelegate* network_delegate) const override {
       if (job_)
         return job_.release();
 
       // Some of these tests trigger UpdateJobs which start URLRequests.
       // We short circuit those be returning error jobs.
@@ skipping 20 matching lines @@
 
     bool IsHandledURL(const GURL& url) const override {
       return url.SchemeIs("http");
     }
 
     bool IsSafeRedirectTarget(const GURL& location) const override {
       return false;
     }
 
    private:
-    mutable scoped_ptr<net::URLRequestJob> job_;
+    mutable std::unique_ptr<net::URLRequestJob> job_;
   };
 
   static void SetUpTestCase() {
     io_thread_.reset(new base::Thread("AppCacheRequestHandlerTest Thread"));
     base::Thread::Options options(base::MessageLoop::TYPE_IO, 0);
     io_thread_->StartWithOptions(options);
   }
 
   static void TearDownTestCase() {
     io_thread_.reset(NULL);
@@ skipping 98 matching lines @@
     EXPECT_FALSE(job_->is_waiting());
     EXPECT_TRUE(job_->is_delivering_network_response());
 
     int64_t cache_id = kAppCacheNoCacheId;
     GURL manifest_url;
     handler_->GetExtraResponseInfo(&cache_id, &manifest_url);
     EXPECT_EQ(kAppCacheNoCacheId, cache_id);
     EXPECT_EQ(GURL(), manifest_url);
     EXPECT_EQ(0, handler_->found_group_id_);
 
-    scoped_ptr<AppCacheURLRequestJob> fallback_job(
+    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);
 
     EXPECT_TRUE(host_->preferred_manifest_url().is_empty());
 
@@ skipping 32 matching lines @@
     EXPECT_FALSE(job_->is_waiting());
     EXPECT_TRUE(job_->is_delivering_appcache_response());
 
     int64_t cache_id = kAppCacheNoCacheId;
     GURL manifest_url;
     handler_->GetExtraResponseInfo(&cache_id, &manifest_url);
     EXPECT_EQ(1, cache_id);
     EXPECT_EQ(GURL("http://blah/manifest/"), manifest_url);
     EXPECT_EQ(2, handler_->found_group_id_);
 
-    scoped_ptr<AppCacheURLRequestJob> fallback_job(
+    std::unique_ptr<AppCacheURLRequestJob> fallback_job(
         handler_->MaybeLoadFallbackForResponse(
             request_.get(), request_->context()->network_delegate()));
     EXPECT_FALSE(fallback_job);
 
     EXPECT_EQ(GURL("http://blah/manifest/"),
               host_->preferred_manifest_url());
 
     TestFinished();
   }
 
@@ skipping 20 matching lines @@
     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();
   }
 
   void SimulateResponseCode(int response_code) {
-    job_factory_->SetJob(make_scoped_ptr(new MockURLRequestJob(
+    job_factory_->SetJob(base::WrapUnique(new MockURLRequestJob(
         request_.get(), request_->context()->network_delegate(),
         response_code)));
     request_->Start();
     // All our simulation needs  to satisfy are the following two DCHECKs
     DCHECK(request_->status().is_success());
     DCHECK_EQ(response_code, request_->GetResponseCode());
   }
 
   void SimulateResponseInfo(const net::HttpResponseInfo& info) {
-    job_factory_->SetJob(make_scoped_ptr(new MockURLRequestJob(
+    job_factory_->SetJob(base::WrapUnique(new MockURLRequestJob(
         request_.get(), request_->context()->network_delegate(), info)));
     request_->Start();
   }
 
   void Verify_MainResource_Fallback() {
     EXPECT_FALSE(job_->is_waiting());
     EXPECT_TRUE(job_->is_delivering_network_response());
 
     // The handler expects to the job to tell it that the request is going to
     // be restarted before it sees the next request.
@@ skipping 126 matching lines @@
     handler_.reset(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());
 
-    scoped_ptr<AppCacheURLRequestJob> fallback_job(
+    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();
   }
@@ skipping 14 matching lines @@
     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());
 
-    scoped_ptr<AppCacheURLRequestJob> fallback_job(
+    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();
   }
@@ skipping 10 matching lines @@
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_);
     handler_.reset(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());
 
-    scoped_ptr<AppCacheURLRequestJob> fallback_job(
+    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();
   }
@@ skipping 17 matching lines @@
     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());
 
-    scoped_ptr<AppCacheURLRequestJob> fallback_job(
+    std::unique_ptr<AppCacheURLRequestJob> fallback_job(
         handler_->MaybeLoadFallbackForResponse(
             request_.get(), request_->context()->network_delegate()));
     EXPECT_FALSE(fallback_job);
 
     TestFinished();
   }
 
   // SubResource_NoRedirectFallback -----------------------------
 
   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));
     EXPECT_TRUE(handler_.get());
     job_.reset(handler_->MaybeLoadResource(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_FALSE(job_.get());
 
-    scoped_ptr<AppCacheURLRequestJob> fallback_job(
+    std::unique_ptr<AppCacheURLRequestJob> fallback_job(
         handler_->MaybeLoadFallbackForRedirect(
             request_.get(), request_->context()->network_delegate(),
             GURL("http://blah/redirect")));
     EXPECT_FALSE(fallback_job);
 
     SimulateResponseCode(200);
     fallback_job.reset(handler_->MaybeLoadFallbackForResponse(
         request_.get(), request_->context()->network_delegate()));
     EXPECT_FALSE(fallback_job);
 
@@ skipping 14 matching lines @@
     request_ = empty_context_.CreateRequest(
         GURL("http://blah/"), net::DEFAULT_PRIORITY, &delegate_);
     handler_.reset(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());
 
-    scoped_ptr<AppCacheURLRequestJob> fallback_job(
+    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();
   }
@@ skipping 217 matching lines @@
     group->AddCache(cache);
     return cache;
   }
 
   MockAppCacheStorage* mock_storage() {
     return reinterpret_cast<MockAppCacheStorage*>(mock_service_->storage());
   }
 
   // Data members --------------------------------------------------
 
-  scoped_ptr<base::WaitableEvent> test_finished_event_;
+  std::unique_ptr<base::WaitableEvent> test_finished_event_;
   std::stack<base::Closure> task_stack_;
-  scoped_ptr<MockAppCacheService> mock_service_;
-  scoped_ptr<AppCacheBackendImpl> backend_impl_;
-  scoped_ptr<MockFrontend> mock_frontend_;
-  scoped_ptr<MockAppCachePolicy> mock_policy_;
+  std::unique_ptr<MockAppCacheService> mock_service_;
+  std::unique_ptr<AppCacheBackendImpl> backend_impl_;
+  std::unique_ptr<MockFrontend> mock_frontend_;
+  std::unique_ptr<MockAppCachePolicy> mock_policy_;
   AppCacheHost* host_;
   net::URLRequestContext empty_context_;
-  scoped_ptr<MockURLRequestJobFactory> job_factory_;
+  std::unique_ptr<MockURLRequestJobFactory> job_factory_;
   MockURLRequestDelegate delegate_;
-  scoped_ptr<net::URLRequest> request_;
-  scoped_ptr<AppCacheRequestHandler> handler_;
-  scoped_ptr<AppCacheURLRequestJob> job_;
+  std::unique_ptr<net::URLRequest> request_;
+  std::unique_ptr<AppCacheRequestHandler> handler_;
+  std::unique_ptr<AppCacheURLRequestJob> job_;
 
-  static scoped_ptr<base::Thread> io_thread_;
+  static std::unique_ptr<base::Thread> io_thread_;
 };
 
 // static
-scoped_ptr<base::Thread> AppCacheRequestHandlerTest::io_thread_;
+std::unique_ptr<base::Thread> AppCacheRequestHandlerTest::io_thread_;
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Miss) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Miss);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Hit) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Hit);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Fallback) {
@@ skipping 56 matching lines @@
 
 TEST_F(AppCacheRequestHandlerTest, WorkerRequest) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::WorkerRequest);
 }
 
 TEST_F(AppCacheRequestHandlerTest, MainResource_Blocked) {
   RunTestOnIOThread(&AppCacheRequestHandlerTest::MainResource_Blocked);
 }
 
 }  // namespace content