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

content/browser/appcache/appcache_service_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 <stdint.h>
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 65 matching lines @@
     data_size_ = 0;
   }
 
  private:
   void ScheduleUserCallback(int result) {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(&MockResponseReader::InvokeUserCompletionCallback,
                               weak_factory_.GetWeakPtr(), result));
   }
 
-  scoped_ptr<net::HttpResponseInfo> info_;
+  std::unique_ptr<net::HttpResponseInfo> info_;
   int info_size_;
   const char* data_;
   int data_size_;
 };
 
 }  // namespace
 
 
 class AppCacheServiceImplTest : public testing::Test {
  public:
@@ skipping 24 matching lines @@
 
   bool IsGroupStored(const GURL& manifest_url) {
     return mock_storage()->IsGroupForManifestStored(manifest_url);
   }
 
   int CountPendingHelpers() {
     return service_->pending_helpers_.size();
   }
 
   void SetupMockGroup() {
-    scoped_ptr<net::HttpResponseInfo> info(MakeMockResponseInfo());
+    std::unique_ptr<net::HttpResponseInfo> info(MakeMockResponseInfo());
     const int kMockInfoSize = GetResponseInfoSize(info.get());
 
     // Create a mock group, cache, and entry and stuff them into mock storage.
     scoped_refptr<AppCacheGroup> group(
         new AppCacheGroup(service_->storage(), kManifestUrl, kMockGroupId));
     scoped_refptr<AppCache> cache(
         new AppCache(service_->storage(), kMockCacheId));
     cache->AddEntry(
         kManifestUrl,
         AppCacheEntry(AppCacheEntry::MANIFEST, kMockResponseId,
@@ skipping 34 matching lines @@
                          const net::HttpResponseInfo* info) {
     const bool kSkipTransientHeaders = true;
     const bool kTruncated = false;
     info->Persist(pickle, kSkipTransientHeaders, kTruncated);
     return pickle->size();
   }
 
   const GURL kOrigin;
   const GURL kManifestUrl;
 
-  scoped_ptr<AppCacheServiceImpl> service_;
+  std::unique_ptr<AppCacheServiceImpl> service_;
   int delete_result_;
   int delete_completion_count_;
   net::CompletionCallback deletion_callback_;
 
  private:
   base::MessageLoop message_loop_;
 };
 
 TEST_F(AppCacheServiceImplTest, DeleteAppCachesForOrigin) {
   // Without giving mock storage simiulated info, should fail.
@@ skipping 133 matching lines @@
 }
 
 // Just tests the backoff scheduling function, not the actual reinit function.
 TEST_F(AppCacheServiceImplTest, ScheduleReinitialize) {
   const base::TimeDelta kNoDelay;
   const base::TimeDelta kOneSecond(base::TimeDelta::FromSeconds(1));
   const base::TimeDelta k30Seconds(base::TimeDelta::FromSeconds(30));
   const base::TimeDelta kOneHour(base::TimeDelta::FromHours(1));
 
   // Do things get initialized as expected?
-  scoped_ptr<AppCacheServiceImpl> service(new AppCacheServiceImpl(NULL));
+  std::unique_ptr<AppCacheServiceImpl> service(new AppCacheServiceImpl(NULL));
   EXPECT_TRUE(service->last_reinit_time_.is_null());
   EXPECT_FALSE(service->reinit_timer_.IsRunning());
   EXPECT_EQ(kNoDelay, service->next_reinit_delay_);
 
   // Do we see artifacts of the timer pending and such?
   service->ScheduleReinitialize();
   EXPECT_TRUE(service->reinit_timer_.IsRunning());
   EXPECT_EQ(kNoDelay, service->reinit_timer_.GetCurrentDelay());
   EXPECT_EQ(k30Seconds, service->next_reinit_delay_);
 
@@ skipping 29 matching lines @@
   EXPECT_EQ(kOneHour, service->reinit_timer_.GetCurrentDelay());
   EXPECT_EQ(kOneHour, service->next_reinit_delay_);
 
   // Fine to delete while pending.
   service.reset(NULL);
 }
 
 
 
 }  // namespace content