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

content/browser/storage_partition_impl_map.cc

 // Copyright (c) 2012 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/storage_partition_impl_map.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 76 matching lines @@
           BrowserThread::GetMessageLoopProxyForThread(BrowserThread::FILE)
               .get()));
     }
     return blob_protocol_handler_->MaybeCreateJob(request, network_delegate);
   }
 
  private:
   const scoped_refptr<ChromeBlobStorageContext> blob_storage_context_;
   const scoped_refptr<StreamContext> stream_context_;
   const scoped_refptr<storage::FileSystemContext> file_system_context_;
-  mutable scoped_ptr<storage::BlobProtocolHandler> blob_protocol_handler_;
+  mutable std::unique_ptr<storage::BlobProtocolHandler> blob_protocol_handler_;
   DISALLOW_COPY_AND_ASSIGN(BlobProtocolHandler);
 };
 
 // These constants are used to create the directory structure under the profile
 // where renderers with a non-default storage partition keep their persistent
 // state. This will contain a set of directories that partially mirror the
 // directory structure of BrowserContext::GetPath().
 //
 // The kStoragePartitionDirname contains an extensions directory which is
 // further partitioned by extension id, followed by another level of directories
@@ skipping 198 matching lines @@
 // This code also ignores failed moves rather than attempting a smarter retry.
 // Moves shouldn't fail here unless there is some out-of-band error (eg.,
 // FS corruption). Retry logic is dangerous in the general case because
 // there is not necessarily a guaranteed case where the logic may succeed.
 //
 // This function is still named BlockingGarbageCollect() because it does
 // execute a few filesystem operations synchronously.
 void BlockingGarbageCollect(
     const base::FilePath& storage_root,
     const scoped_refptr<base::TaskRunner>& file_access_runner,
-    scoped_ptr<base::hash_set<base::FilePath> > active_paths) {
+    std::unique_ptr<base::hash_set<base::FilePath>> active_paths) {
   CHECK(storage_root.IsAbsolute());
 
   NormalizeActivePaths(storage_root, active_paths.get());
 
   base::FileEnumerator enumerator(storage_root, false, kAllFileTypes);
   base::FilePath trash_directory;
   if (!base::CreateTemporaryDirInDir(storage_root, kTrashDirname,
                                      &trash_directory)) {
     // Unable to continue without creating the trash directory so give up.
     return;
@@ skipping 199 matching lines @@
       GetStoragePartitionDomainPath(partition_domain));
 
   BrowserThread::PostBlockingPoolTask(
       FROM_HERE,
       base::Bind(&BlockingObliteratePath, browser_context_->GetPath(),
                  domain_root, paths_to_keep,
                  base::ThreadTaskRunnerHandle::Get(), on_gc_required));
 }
 
 void StoragePartitionImplMap::GarbageCollect(
-    scoped_ptr<base::hash_set<base::FilePath> > active_paths,
+    std::unique_ptr<base::hash_set<base::FilePath>> active_paths,
     const base::Closure& done) {
   // Include all paths for current StoragePartitions in the active_paths since
   // they cannot be deleted safely.
   for (PartitionMap::const_iterator it = partitions_.begin();
        it != partitions_.end();
        ++it) {
     const StoragePartitionConfig& config = it->first;
     if (!config.in_memory)
       active_paths->insert(it->second->GetPath());
   }
@@ skipping 62 matching lines @@
 
     // We do not call InitializeURLRequestContext() for media contexts because,
     // other than the HTTP cache, the media contexts share the same backing
     // objects as their associated "normal" request context.  Thus, the previous
     // call serves to initialize the media request context for this storage
     // partition as well.
   }
 }
 
 }  // namespace content