Change scoped_ptr to std::unique_ptr in //net/disk_cache.

net/disk_cache/simple/simple_entry_impl.h

 // Copyright (c) 2013 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.
 
 #ifndef NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_
 #define NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_
 
 #include <stdint.h>
 
+#include <memory>
 #include <queue>
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "net/base/cache_type.h"
 #include "net/base/net_export.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/simple/simple_entry_format.h"
 #include "net/disk_cache/simple/simple_entry_operation.h"
 #include "net/log/net_log.h"
 
 namespace base {
 class TaskRunner;
@@ skipping 32 matching lines @@
   };
 
   SimpleEntryImpl(net::CacheType cache_type,
                   const base::FilePath& path,
                   uint64_t entry_hash,
                   OperationsMode operations_mode,
                   SimpleBackendImpl* backend,
                   net::NetLog* net_log);
 
   void SetActiveEntryProxy(
-      scoped_ptr<ActiveEntryProxy> active_entry_proxy);
+      std::unique_ptr<ActiveEntryProxy> active_entry_proxy);
 
   // Adds another reader/writer to this entry, if possible, returning |this| to
   // |entry|.
   int OpenEntry(Entry** entry, const CompletionCallback& callback);
 
   // Creates this entry, if possible. Returns |this| to |entry|.
   int CreateEntry(Entry** entry, const CompletionCallback& callback);
 
   // Identical to Backend::Doom() except that it accepts a CompletionCallback.
   int DoomEntry(const CompletionCallback& callback);
@@ skipping 133 matching lines @@
 
   void DoomEntryInternal(const CompletionCallback& callback);
 
   // Called after a SimpleSynchronousEntry has completed CreateEntry() or
   // OpenEntry(). If |in_sync_entry| is non-NULL, creation is successful and we
   // can return |this| SimpleEntryImpl to |*out_entry|. Runs
   // |completion_callback|.
   void CreationOperationComplete(
       const CompletionCallback& completion_callback,
       const base::TimeTicks& start_time,
-      scoped_ptr<SimpleEntryCreationResults> in_results,
+      std::unique_ptr<SimpleEntryCreationResults> in_results,
       Entry** out_entry,
       net::NetLog::EventType end_event_type);
 
   // Called after we've closed and written the EOF record to our entry. Until
   // this point it hasn't been safe to OpenEntry() the same entry, but from this
   // point it is.
   void CloseOperationComplete();
 
   // Internal utility method used by other completion methods. Calls
   // |completion_callback| after updating state and dooming on errors.
   void EntryOperationComplete(const CompletionCallback& completion_callback,
                               const SimpleEntryStat& entry_stat,
-                              scoped_ptr<int> result);
+                              std::unique_ptr<int> result);
 
   // Called after an asynchronous read. Updates |crc32s_| if possible.
   void ReadOperationComplete(int stream_index,
                              int offset,
                              const CompletionCallback& completion_callback,
-                             scoped_ptr<uint32_t> read_crc32,
-                             scoped_ptr<SimpleEntryStat> entry_stat,
-                             scoped_ptr<int> result);
+                             std::unique_ptr<uint32_t> read_crc32,
+                             std::unique_ptr<SimpleEntryStat> entry_stat,
+                             std::unique_ptr<int> result);
 
   // Called after an asynchronous write completes.
   void WriteOperationComplete(int stream_index,
                               const CompletionCallback& completion_callback,
-                              scoped_ptr<SimpleEntryStat> entry_stat,
-                              scoped_ptr<int> result);
+                              std::unique_ptr<SimpleEntryStat> entry_stat,
+                              std::unique_ptr<int> result);
 
   void ReadSparseOperationComplete(
       const CompletionCallback& completion_callback,
-      scoped_ptr<base::Time> last_used,
-      scoped_ptr<int> result);
+      std::unique_ptr<base::Time> last_used,
+      std::unique_ptr<int> result);
 
   void WriteSparseOperationComplete(
       const CompletionCallback& completion_callback,
-      scoped_ptr<SimpleEntryStat> entry_stat,
-      scoped_ptr<int> result);
+      std::unique_ptr<SimpleEntryStat> entry_stat,
+      std::unique_ptr<int> result);
 
   void GetAvailableRangeOperationComplete(
       const CompletionCallback& completion_callback,
-      scoped_ptr<int> result);
+      std::unique_ptr<int> result);
 
   // Called after an asynchronous doom completes.
   void DoomOperationComplete(const CompletionCallback& callback,
                              State state_to_restore,
                              int result);
 
   // Called after validating the checksums on an entry. Passes through the
   // original result if successful, propagates the error if the checksum does
   // not validate.
-  void ChecksumOperationComplete(
-      int stream_index,
-      int orig_result,
-      const CompletionCallback& completion_callback,
-      scoped_ptr<int> result);
+  void ChecksumOperationComplete(int stream_index,
+                                 int orig_result,
+                                 const CompletionCallback& completion_callback,
+                                 std::unique_ptr<int> result);
 
   // Called after completion of asynchronous IO and receiving file metadata for
   // the entry in |entry_stat|. Updates the metadata in the entry and in the
   // index to make them available on next IO operations.
   void UpdateDataFromEntryStat(const SimpleEntryStat& entry_stat);
 
   int64_t GetDiskUsage() const;
 
   // Used to report histograms.
   void RecordReadIsParallelizable(const SimpleEntryOperation& operation) const;
   void RecordWriteDependencyType(const SimpleEntryOperation& operation) const;
 
   // Reads from the stream 0 data kept in memory.
   int ReadStream0Data(net::IOBuffer* buf, int offset, int buf_len);
 
   // Copies data from |buf| to the internal in-memory buffer for stream 0. If
   // |truncate| is set to true, the target buffer will be truncated at |offset|
   // + |buf_len| before being written.
   int SetStream0Data(net::IOBuffer* buf,
                      int offset, int buf_len,
                      bool truncate);
 
   // Updates |crc32s_| and |crc32s_end_offset_| for a write of the data in
   // |buffer| on |stream_index|, starting at |offset| and of length |length|.
   void AdvanceCrc(net::IOBuffer* buffer,
                   int offset,
                   int length,
                   int stream_index);
 
-  scoped_ptr<ActiveEntryProxy> active_entry_proxy_;
+  std::unique_ptr<ActiveEntryProxy> active_entry_proxy_;
 
   // All nonstatic SimpleEntryImpl methods should always be called on the IO
   // thread, in all cases. |io_thread_checker_| documents and enforces this.
   base::ThreadChecker io_thread_checker_;
 
   const base::WeakPtr<SimpleBackendImpl> backend_;
   const net::CacheType cache_type_;
   const scoped_refptr<base::TaskRunner> worker_pool_;
   const base::FilePath path_;
   const uint64_t entry_hash_;
@@ skipping 41 matching lines @@
   // is false (i.e. when an operation is not pending on the worker pool). When
   // an operation is being executed no one owns the synchronous entry. Therefore
   // SimpleEntryImpl should not be deleted while an operation is running as that
   // would leak the SimpleSynchronousEntry.
   SimpleSynchronousEntry* synchronous_entry_;
 
   std::queue<SimpleEntryOperation> pending_operations_;
 
   net::BoundNetLog net_log_;
 
-  scoped_ptr<SimpleEntryOperation> executing_operation_;
+  std::unique_ptr<SimpleEntryOperation> executing_operation_;
 
   // Unlike other streams, stream 0 data is read from the disk when the entry is
   // opened, and then kept in memory. All read/write operations on stream 0
   // affect the |stream_0_data_| buffer. When the entry is closed,
   // |stream_0_data_| is written to the disk.
   // Stream 0 is kept in memory because it is stored in the same file as stream
   // 1 on disk, to reduce the number of file descriptors and save disk space.
   // This strategy allows stream 1 to change size easily. Since stream 0 is only
   // used to write HTTP headers, the memory consumption of keeping it in memory
   // is acceptable.
   scoped_refptr<net::GrowableIOBuffer> stream_0_data_;
 };
 
 }  // namespace disk_cache
 
 #endif  // NET_DISK_CACHE_SIMPLE_SIMPLE_ENTRY_IMPL_H_