Convert //components/[u-z]* from scoped_ptr to std::unique_ptr

components/visitedlink/browser/visitedlink_master.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 "components/visitedlink/browser/visitedlink_master.h"
 
 #include <stdio.h>
 #include <string.h>
 #include <algorithm>
 #include <utility>
@@ skipping 105 matching lines @@
   if (*file)
     base::IgnoreResult(fclose(*file));
   free(file);
 }
 
 }  // namespace
 
 struct VisitedLinkMaster::LoadFromFileResult
     : public base::RefCountedThreadSafe<LoadFromFileResult> {
   LoadFromFileResult(base::ScopedFILE file,
-                     scoped_ptr<base::SharedMemory> shared_memory,
+                     std::unique_ptr<base::SharedMemory> shared_memory,
                      Fingerprint* hash_table,
                      int32_t num_entries,
                      int32_t used_count,
                      uint8_t salt[LINK_SALT_LENGTH]);
 
   base::ScopedFILE file;
-  scoped_ptr<base::SharedMemory> shared_memory;
+  std::unique_ptr<base::SharedMemory> shared_memory;
   Fingerprint* hash_table;
   int32_t num_entries;
   int32_t used_count;
   uint8_t salt[LINK_SALT_LENGTH];
 
  private:
   friend class base::RefCountedThreadSafe<LoadFromFileResult>;
   virtual ~LoadFromFileResult();
 
   DISALLOW_COPY_AND_ASSIGN(LoadFromFileResult);
 };
 
 VisitedLinkMaster::LoadFromFileResult::LoadFromFileResult(
     base::ScopedFILE file,
-    scoped_ptr<base::SharedMemory> shared_memory,
+    std::unique_ptr<base::SharedMemory> shared_memory,
     Fingerprint* hash_table,
     int32_t num_entries,
     int32_t used_count,
     uint8_t salt[LINK_SALT_LENGTH])
     : file(std::move(file)),
       shared_memory(std::move(shared_memory)),
       hash_table(hash_table),
       num_entries(num_entries),
       used_count(used_count) {
   memcpy(this->salt, salt, LINK_SALT_LENGTH);
@@ skipping 496 matching lines @@
   base::ScopedFILE file_closer(base::OpenFile(filename, "rb+"));
   if (!file_closer.get())
     return false;
 
   int32_t num_entries, used_count;
   uint8_t salt[LINK_SALT_LENGTH];
   if (!ReadFileHeader(file_closer.get(), &num_entries, &used_count, salt))
     return false;  // Header isn't valid.
 
   // Allocate and read the table.
-  scoped_ptr<base::SharedMemory> shared_memory;
+  std::unique_ptr<base::SharedMemory> shared_memory;
   VisitedLinkCommon::Fingerprint* hash_table;
   if (!CreateApartURLTable(num_entries, salt, &shared_memory, &hash_table))
     return false;
 
   if (!ReadFromFile(file_closer.get(), kFileHeaderSize, hash_table,
                     num_entries * sizeof(Fingerprint))) {
     return false;
   }
 
   *load_from_file_result =
@@ skipping 176 matching lines @@
     return false;
 
   base::FilePath profile_dir = browser_context_->GetPath();
   *filename = profile_dir.Append(FILE_PATH_LITERAL("Visited Links"));
   return true;
 }
 
 // Initializes the shared memory structure. The salt should already be filled
 // in so that it can be written to the shared memory
 bool VisitedLinkMaster::CreateURLTable(int32_t num_entries) {
-  scoped_ptr<base::SharedMemory> shared_memory;
+  std::unique_ptr<base::SharedMemory> shared_memory;
   VisitedLinkCommon::Fingerprint* hash_table;
   if (CreateApartURLTable(num_entries, salt_, &shared_memory, &hash_table)) {
     shared_memory_ = shared_memory.release();
     hash_table_ = hash_table;
     table_length_ = num_entries;
     used_items_ = 0;
     return true;
   }
 
   return false;
 }
 
 // static
 bool VisitedLinkMaster::CreateApartURLTable(
     int32_t num_entries,
     const uint8_t salt[LINK_SALT_LENGTH],
-    scoped_ptr<base::SharedMemory>* shared_memory,
+    std::unique_ptr<base::SharedMemory>* shared_memory,
     VisitedLinkCommon::Fingerprint** hash_table) {
   DCHECK(salt);
   DCHECK(shared_memory);
   DCHECK(hash_table);
 
   // The table is the size of the table followed by the entries.
   uint32_t alloc_size =
       num_entries * sizeof(Fingerprint) + sizeof(SharedHeader);
 
   // Create the shared memory object.
-  scoped_ptr<base::SharedMemory> sh_mem(new base::SharedMemory());
+  std::unique_ptr<base::SharedMemory> sh_mem(new base::SharedMemory());
   if (!sh_mem)
     return false;
 
   base::SharedMemoryCreateOptions options;
   options.size = alloc_size;
   options.share_read_only = true;
 
   if (!sh_mem->Create(options) || !sh_mem->Map(alloc_size))
     return false;
 
@@ skipping 294 matching lines @@
       BrowserThread::UI, FROM_HERE,
       base::Bind(&TableBuilder::OnCompleteMainThread, this));
 }
 
 void VisitedLinkMaster::TableBuilder::OnCompleteMainThread() {
   if (master_)
     master_->OnTableRebuildComplete(success_, fingerprints_);
 }
 
 }  // namespace visitedlink