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

content/browser/appcache/appcache_update_job_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_update_job.h"
 
 #include <stddef.h>
 #include <stdint.h>
+
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_host.h"
 #include "content/browser/appcache/appcache_response.h"
 #include "content/browser/appcache/mock_appcache_service.h"
 #include "net/base/net_errors.h"
@@ skipping 546 matching lines @@
     return request_context_.get();
   }
 
   void SetNewJobFactory(net::URLRequestJobFactory* job_factory) {
     DCHECK(job_factory);
     job_factory_.reset(job_factory);
     request_context_->set_job_factory(job_factory_.get());
   }
 
   void Init() override {
-    scoped_ptr<net::URLRequestJobFactoryImpl> factory(
+    std::unique_ptr<net::URLRequestJobFactoryImpl> factory(
         new net::URLRequestJobFactoryImpl());
     factory->SetProtocolHandler("http",
-                                make_scoped_ptr(new MockHttpServerJobFactory));
+                                base::WrapUnique(new MockHttpServerJobFactory));
     factory->SetProtocolHandler("https",
-                                make_scoped_ptr(new MockHttpServerJobFactory));
+                                base::WrapUnique(new MockHttpServerJobFactory));
     job_factory_ = std::move(factory);
     request_context_.reset(new net::TestURLRequestContext());
     request_context_->set_job_factory(job_factory_.get());
   }
 
   void CleanUp() override {
     request_context_.reset();
     job_factory_.reset();
   }
 
  private:
-  scoped_ptr<net::URLRequestJobFactory> job_factory_;
-  scoped_ptr<net::URLRequestContext> request_context_;
+  std::unique_ptr<net::URLRequestJobFactory> job_factory_;
+  std::unique_ptr<net::URLRequestContext> request_context_;
 };
 
 class AppCacheUpdateJobTest : public testing::Test,
                               public AppCacheGroup::UpdateObserver {
  public:
   AppCacheUpdateJobTest()
       : do_checks_after_update_finished_(false),
         expect_group_obsolete_(false),
         expect_group_has_cache_(false),
         expect_group_is_being_deleted_(false),
@@ skipping 188 matching lines @@
 
     WaitForUpdateToFinish();
   }
 
   void ManifestRedirectTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler("http",
-                                    make_scoped_ptr(new RedirectFactory));
+                                    base::WrapUnique(new RedirectFactory));
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(), GURL("http://testme"),
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
@@ skipping 865 matching lines @@
 
   void RetryRequestTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     // Set some large number of times to return retry.
     // Expect 1 manifest fetch and 3 retries.
     RetryRequestTestJob::Initialize(5, RetryRequestTestJob::RETRY_AFTER_0, 4);
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler(
-        "http", make_scoped_ptr(new RetryRequestTestJobFactory));
+        "http", base::WrapUnique(new RetryRequestTestJobFactory));
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
                                RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
@@ skipping 13 matching lines @@
 
   void RetryNoRetryAfterTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     // Set some large number of times to return retry.
     // Expect 1 manifest fetch and 0 retries.
     RetryRequestTestJob::Initialize(5, RetryRequestTestJob::NO_RETRY_AFTER, 1);
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler(
-        "http", make_scoped_ptr(new RetryRequestTestJobFactory));
+        "http", base::WrapUnique(new RetryRequestTestJobFactory));
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
                                RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
@@ skipping 14 matching lines @@
   void RetryNonzeroRetryAfterTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     // Set some large number of times to return retry.
     // Expect 1 request and 0 retry attempts.
     RetryRequestTestJob::Initialize(
         5, RetryRequestTestJob::NONZERO_RETRY_AFTER, 1);
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler(
-        "http", make_scoped_ptr(new RetryRequestTestJobFactory));
+        "http", base::WrapUnique(new RetryRequestTestJobFactory));
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
                                RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
@@ skipping 13 matching lines @@
 
   void RetrySuccessTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     // Set 2 as the retry limit (does not exceed the max).
     // Expect 1 manifest fetch, 2 retries, 1 url fetch, 1 manifest refetch.
     RetryRequestTestJob::Initialize(2, RetryRequestTestJob::RETRY_AFTER_0, 5);
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler(
-        "http", make_scoped_ptr(new RetryRequestTestJobFactory));
+        "http", base::WrapUnique(new RetryRequestTestJobFactory));
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(),
                                RetryRequestTestJob::kRetryUrl,
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
@@ skipping 13 matching lines @@
 
   void RetryUrlTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     // Set 1 as the retry limit (does not exceed the max).
     // Expect 1 manifest fetch, 1 url fetch, 1 url retry, 1 manifest refetch.
     RetryRequestTestJob::Initialize(1, RetryRequestTestJob::RETRY_AFTER_0, 4);
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler(
-        "http", make_scoped_ptr(new RetryRequestTestJobFactory));
+        "http", base::WrapUnique(new RetryRequestTestJobFactory));
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(service_->storage(), GURL("http://retryurl"),
                                service_->storage()->NewGroupId());
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     MockFrontend* frontend = MakeMockFrontend();
@@ skipping 845 matching lines @@
     // WaitForUpdateToFinish.
     group_->AddUpdateObserver(this);
   }
 
   void IfModifiedSinceTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler(
-        "http", make_scoped_ptr(new IfModifiedSinceJobFactory));
+        "http", base::WrapUnique(new IfModifiedSinceJobFactory));
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), GURL("http://headertest"), 111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // First test against a cache attempt. Will start manifest fetch
@@ skipping 51 matching lines @@
   }
 
   void IfModifiedSinceUpgradeTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     HttpHeadersRequestTestJob::Initialize("Sat, 29 Oct 1994 19:43:31 GMT",
                                           std::string());
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler(
-        "http", make_scoped_ptr(new IfModifiedSinceJobFactory));
+        "http", base::WrapUnique(new IfModifiedSinceJobFactory));
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
@@ skipping 43 matching lines @@
     // Start update after data write completes asynchronously.
   }
 
   void IfNoneMatchUpgradeTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     HttpHeadersRequestTestJob::Initialize(std::string(), "\"LadeDade\"");
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler(
-        "http", make_scoped_ptr(new IfModifiedSinceJobFactory));
+        "http", base::WrapUnique(new IfModifiedSinceJobFactory));
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(),
         MockHttpServer::GetMockUrl("files/manifest1"),
         111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
@@ skipping 43 matching lines @@
     // Start update after data write completes asynchronously.
   }
 
   void IfNoneMatchRefetchTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     HttpHeadersRequestTestJob::Initialize(std::string(), "\"LadeDade\"");
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler(
-        "http", make_scoped_ptr(new IfModifiedSinceJobFactory));
+        "http", base::WrapUnique(new IfModifiedSinceJobFactory));
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), GURL("http://headertest"), 111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Simulate a refetch manifest request that uses an ETag header.
@@ skipping 18 matching lines @@
 
   void MultipleHeadersRefetchTest() {
     ASSERT_TRUE(base::MessageLoopForIO::IsCurrent());
 
     // Verify that code is correct when building multiple extra headers.
     HttpHeadersRequestTestJob::Initialize(
         "Sat, 29 Oct 1994 19:43:31 GMT", "\"LadeDade\"");
     net::URLRequestJobFactoryImpl* new_factory(
         new net::URLRequestJobFactoryImpl);
     new_factory->SetProtocolHandler(
-        "http", make_scoped_ptr(new IfModifiedSinceJobFactory));
+        "http", base::WrapUnique(new IfModifiedSinceJobFactory));
     io_thread_->SetNewJobFactory(new_factory);
 
     MakeService();
     group_ = new AppCacheGroup(
         service_->storage(), GURL("http://headertest"), 111);
     AppCacheUpdateJob* update =
         new AppCacheUpdateJob(service_.get(), group_.get());
     group_->update_job_ = update;
 
     // Simulate a refetch manifest request that uses an ETag header.
@@ skipping 468 matching lines @@
   enum TestedManifest {
     NONE,
     MANIFEST1,
     MANIFEST_MERGED_TYPES,
     EMPTY_MANIFEST,
     EMPTY_FILE_MANIFEST,
     PENDING_MASTER_NO_UPDATE,
     MANIFEST_WITH_INTERCEPT
   };
 
-  scoped_ptr<IOThread> io_thread_;
+  std::unique_ptr<IOThread> io_thread_;
 
-  scoped_ptr<MockAppCacheService> service_;
+  std::unique_ptr<MockAppCacheService> service_;
   scoped_refptr<AppCacheGroup> group_;
   scoped_refptr<AppCache> protect_newest_cache_;
-  scoped_ptr<base::WaitableEvent> event_;
+  std::unique_ptr<base::WaitableEvent> event_;
 
-  scoped_ptr<AppCacheResponseWriter> response_writer_;
+  std::unique_ptr<AppCacheResponseWriter> response_writer_;
 
   // Hosts used by an async test that need to live until update job finishes.
   // Otherwise, test can put host on the stack instead of here.
   std::vector<AppCacheHost*> hosts_;
 
   // Response infos used by an async test that need to live until update job
   // finishes.
   std::vector<scoped_refptr<AppCacheResponseInfo> > response_infos_;
 
   // Flag indicating if test cares to verify the update after update finishes.
@@ skipping 285 matching lines @@
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsSuccess) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsSuccessTest);
 }
 
 TEST_F(AppCacheUpdateJobTest, CrossOriginHttpsDenied) {
   RunTestOnIOThread(&AppCacheUpdateJobTest::CrossOriginHttpsDeniedTest);
 }
 
 }  // namespace content