Convert //chrome/browser/safe_browsing from scoped_ptr to std::unique_ptr

chrome/browser/safe_browsing/incident_reporting/download_metadata_manager.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 "chrome/browser/safe_browsing/incident_reporting/download_metadata_manager.h"
 
 #include <limits.h>
 #include <stdint.h>
+
 #include <list>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file.h"
 #include "base/files/file_util.h"
 #include "base/files/important_file_writer.h"
 #include "base/location.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/sequenced_task_runner.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/download_item.h"
 
 namespace safe_browsing {
 
 namespace {
@@ skipping 24 matching lines @@
     FILE_PATH_LITERAL("DownloadMetadata");
 
 
 // DownloadItemData ------------------------------------------------------------
 
 // A UserData object that holds the ClientDownloadRequest for a download while
 // it is in progress.
 class DownloadItemData : public base::SupportsUserData::Data {
  public:
   // Sets the ClientDownloadRequest for a given DownloadItem.
-  static void SetRequestForDownload(content::DownloadItem* item,
-                                    scoped_ptr<ClientDownloadRequest> request);
+  static void SetRequestForDownload(
+      content::DownloadItem* item,
+      std::unique_ptr<ClientDownloadRequest> request);
 
   // Returns the ClientDownloadRequest for a download or null if there is none.
-  static scoped_ptr<ClientDownloadRequest> TakeRequestForDownload(
+  static std::unique_ptr<ClientDownloadRequest> TakeRequestForDownload(
       content::DownloadItem* item);
 
  private:
   // A unique id for associating metadata with a content::DownloadItem.
   static const void* const kKey_;
 
-  explicit DownloadItemData(scoped_ptr<ClientDownloadRequest> request)
+  explicit DownloadItemData(std::unique_ptr<ClientDownloadRequest> request)
       : request_(std::move(request)) {}
   ~DownloadItemData() override {}
 
-  scoped_ptr<ClientDownloadRequest> request_;
+  std::unique_ptr<ClientDownloadRequest> request_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadItemData);
 };
 
 // Make the key's value unique by setting it to its own location.
 // static
 const void* const DownloadItemData::kKey_ = &DownloadItemData::kKey_;
 
 // static
 void DownloadItemData::SetRequestForDownload(
     content::DownloadItem* item,
-    scoped_ptr<ClientDownloadRequest> request) {
+    std::unique_ptr<ClientDownloadRequest> request) {
   item->SetUserData(&kKey_, new DownloadItemData(std::move(request)));
 }
 
 // static
-scoped_ptr<ClientDownloadRequest> DownloadItemData::TakeRequestForDownload(
+std::unique_ptr<ClientDownloadRequest> DownloadItemData::TakeRequestForDownload(
     content::DownloadItem* item) {
   DownloadItemData* data =
       static_cast<DownloadItemData*>(item->GetUserData(&kKey_));
   if (!data)
     return nullptr;
-  scoped_ptr<ClientDownloadRequest> request = std::move(data->request_);
+  std::unique_ptr<ClientDownloadRequest> request = std::move(data->request_);
   item->RemoveUserData(&kKey_);
   return request;
 }
 
 
 // Utility functions------------------------------------------------------------
 
 // Returns the path to the metadata file for |browser_context|.
 base::FilePath GetMetadataPath(content::BrowserContext* browser_context) {
   return browser_context->GetPath().Append(kDownloadMetadataBasename);
@@ skipping 13 matching lines @@
                               DownloadMetadata* metadata) {
   using base::File;
   DCHECK(metadata);
   MetadataReadResult result = NUM_READ_RESULTS;
   File metadata_file(metadata_path, File::FLAG_OPEN | File::FLAG_READ);
   if (metadata_file.IsValid()) {
     base::File::Info info;
     if (metadata_file.GetInfo(&info)) {
       if (info.size <= INT_MAX) {
         const int size = static_cast<int>(info.size);
-        scoped_ptr<char[]> file_data(new char[info.size]);
+        std::unique_ptr<char[]> file_data(new char[info.size]);
         if (metadata_file.Read(0, file_data.get(), size)) {
           if (!metadata->ParseFromArray(file_data.get(), size))
             result = PARSE_FAILURE;
           else if (!MetadataIsValid(*metadata))
             result = MALFORMED_DATA;
           else
             result = READ_SUCCESS;
         } else {
           result = READ_FAILURE;
         }
@@ skipping 33 matching lines @@
 
 // Deletes |metadata_path|.
 void DeleteMetadataOnWorkerPool(const base::FilePath& metadata_path) {
   bool success = base::DeleteFile(metadata_path, false /* not recursive */);
   UMA_HISTOGRAM_BOOLEAN("SBIRS.DownloadMetadata.DeleteSuccess", success);
 }
 
 // Runs |callback| with the DownloadDetails in |download_metadata|.
 void ReturnResults(
     const DownloadMetadataManager::GetDownloadDetailsCallback& callback,
-    scoped_ptr<DownloadMetadata> download_metadata) {
+    std::unique_ptr<DownloadMetadata> download_metadata) {
   if (!download_metadata->has_download_id())
-    callback.Run(scoped_ptr<ClientIncidentReport_DownloadDetails>());
+    callback.Run(std::unique_ptr<ClientIncidentReport_DownloadDetails>());
   else
-    callback.Run(make_scoped_ptr(download_metadata->release_download()));
+    callback.Run(base::WrapUnique(download_metadata->release_download()));

[Nathan Parker, 2016/04/11 17:56:44]

Should every use of WrapUnique also include <memory>?

[dcheng, 2016/04/11 18:31:15]

The jury's out on that one. On one hand, it's part of WrapUnique's contract, so
including it seems redundant... on the other, it's weird to see unique_ptr
without the corresponding header actually included.

I have an OKR of figuring out some same set of IWYU rules to try to apply. I'm
not sure how much progress I'll be able to make on it... but I'm definitely
thinking about it.

 }
 
 }  // namespace
 
 // Applies operations to the profile's persistent DownloadMetadata as they occur
 // on its corresponding download item. An instance can be in one of three
 // states: waiting for metatada load, waiting for metadata to load after its
 // corresponding DownloadManager has gone down, and not waiting for metadata to
 // load. The instance observes all download items beloing to its manager. While
 // it is waiting for metadata to load, it records all operations on download
@@ skipping 15 matching lines @@
   // callbacks.
   void Detach(content::DownloadManager* download_manager);
 
   // Notifies the context that |download| has been added to its manager.
   void OnDownloadCreated(content::DownloadItem* download);
 
   // Sets |request| as the relevant metadata to persist for |download| if or
   // when it is complete. If |request| is null, the metadata for |download|
   // is/will be removed.
   void SetRequest(content::DownloadItem* download,
-                  scoped_ptr<ClientDownloadRequest> request);
+                  std::unique_ptr<ClientDownloadRequest> request);
 
   // Gets the persisted DownloadDetails. |callback| will be run immediately if
   // the data is available. Otherwise, it will be run later on the caller's
   // thread.
   void GetDownloadDetails(const GetDownloadDetailsCallback& callback);
 
  protected:
   // content::DownloadItem::Observer methods.
   void OnDownloadUpdated(content::DownloadItem* download) override;
   void OnDownloadOpened(content::DownloadItem* download) override;
@@ skipping 20 matching lines @@
 
   // A mapping of download IDs to their corresponding data.
   typedef std::map<uint32_t, ItemData> ItemDataMap;
 
   ~ManagerContext() override;
 
   // Commits |request| to the DownloadDetails for |item|'s BrowserContext.
   // Callbacks will be run immediately if the context had been waiting for a
   // load (which will be abandoned).
   void CommitRequest(content::DownloadItem* item,
-                     scoped_ptr<ClientDownloadRequest> request);
+                     std::unique_ptr<ClientDownloadRequest> request);
 
   // Posts a task in the worker pool to read the metadata from disk.
   void ReadMetadata();
 
   // Posts a task in the worker pool to write the metadata to disk.
   void WriteMetadata();
 
   // Removes metadata for the context from memory and posts a task in the worker
   // pool to delete it on disk.
   void RemoveMetadata();
 
   // Clears the |pending_items_| mapping.
   void ClearPendingItems();
 
   // Runs all |get_details_callbacks_| with the current metadata.
   void RunCallbacks();
 
   // Returns true if metadata corresponding to |item| is available.
   bool HasMetadataFor(const content::DownloadItem* item) const;
 
   // A callback run on the main thread with the results from reading the
   // metadata file from disk.
-  void OnMetadataReady(scoped_ptr<DownloadMetadata> download_metadata);
+  void OnMetadataReady(std::unique_ptr<DownloadMetadata> download_metadata);
 
   // Updates the last opened time in the metadata and writes it to disk.
   void UpdateLastOpenedTime(const base::Time& last_opened_time);
 
   // A task runner to which read tasks are posted.
   scoped_refptr<base::SequencedTaskRunner> read_runner_;
 
   // A task runner to which write tasks are posted.
   scoped_refptr<base::SequencedTaskRunner> write_runner_;
 
   // The path to the metadata file for this context.
   base::FilePath metadata_path_;
 
   // When not LOAD_COMPLETE, the context is waiting for a pending read operation
   // to complete. While this is the case, events are temporarily recorded in
   // |pending_items_|. Once the read completes, pending operations for the item
   // corresponding to the metadata file are applied to the file and all other
   // recorded data are dropped. Queued GetDownloadDetailsCallbacks are run upon
   // read completion as well. The context is moved to the DETACHED_WAIT state if
   // the corresponding DownloadManager goes away while a read operation is
   // outstanding. When the read subsequently completes, the context is destroyed
   // after the processing described above is performed.
   State state_;
 
   // The current metadata for the context. May be supplied either by reading
   // from the file or by having been set via |SetRequest|.
-  scoped_ptr<DownloadMetadata> download_metadata_;
+  std::unique_ptr<DownloadMetadata> download_metadata_;
 
   // The operation data that accumulates for added download items while the
   // metadata file is being read.
   ItemDataMap pending_items_;
 
   // Pending callbacks in response to GetDownloadDetails. The callbacks are run
   // in order when a pending read operation completes.
   std::list<GetDownloadDetailsCallback> get_details_callbacks_;
 
   base::WeakPtrFactory<ManagerContext> weak_factory_;
@@ skipping 40 matching lines @@
       new ManagerContext(read_runner_, write_runner_, download_manager);
 }
 
 void DownloadMetadataManager::SetRequest(content::DownloadItem* item,
                                          const ClientDownloadRequest* request) {
   DCHECK(request);
   content::DownloadManager* download_manager =
       GetDownloadManagerForBrowserContext(item->GetBrowserContext());
   DCHECK_EQ(contexts_.count(download_manager), 1U);
   contexts_[download_manager]->SetRequest(
-      item, make_scoped_ptr(new ClientDownloadRequest(*request)));
+      item, base::WrapUnique(new ClientDownloadRequest(*request)));
 }
 
 void DownloadMetadataManager::GetDownloadDetails(
     content::BrowserContext* browser_context,
     const GetDownloadDetailsCallback& callback) {
   DCHECK(browser_context);
   // The DownloadManager for |browser_context| may not have been created yet. In
   // this case, asking for it would cause history to load in the background and
   // wouldn't really help much. Instead, scan the contexts to see if one belongs
   // to |browser_context|. If one is not found, read the metadata and return it.
-  scoped_ptr<ClientIncidentReport_DownloadDetails> download_details;
+  std::unique_ptr<ClientIncidentReport_DownloadDetails> download_details;
   for (const auto& manager_context_pair : contexts_) {
     if (manager_context_pair.first->GetBrowserContext() == browser_context) {
       manager_context_pair.second->GetDownloadDetails(callback);
       return;
     }
   }
 
   // Fire off a task to load the details and return them to the caller.
   DownloadMetadata* metadata = new DownloadMetadata();
   read_runner_->PostTaskAndReply(
-      FROM_HERE,
-      base::Bind(&ReadMetadataOnWorkerPool,
-                 GetMetadataPath(browser_context),
-                 metadata),
-      base::Bind(
-          &ReturnResults, callback, base::Passed(make_scoped_ptr(metadata))));
+      FROM_HERE, base::Bind(&ReadMetadataOnWorkerPool,
+                            GetMetadataPath(browser_context), metadata),
+      base::Bind(&ReturnResults, callback,
+                 base::Passed(base::WrapUnique(metadata))));
 }
 
 content::DownloadManager*
 DownloadMetadataManager::GetDownloadManagerForBrowserContext(
     content::BrowserContext* context) {
   return content::BrowserContext::GetDownloadManager(context);
 }
 
 void DownloadMetadataManager::OnDownloadCreated(
     content::DownloadManager* download_manager,
@@ skipping 51 matching lines @@
   }
 }
 
 void DownloadMetadataManager::ManagerContext::OnDownloadCreated(
     content::DownloadItem* download) {
   download->AddObserver(this);
 }
 
 void DownloadMetadataManager::ManagerContext::SetRequest(
     content::DownloadItem* download,
-    scoped_ptr<ClientDownloadRequest> request) {
+    std::unique_ptr<ClientDownloadRequest> request) {
   DCHECK(request);
   // Hold on to the request for completion time if the download is in progress.
   // Otherwise, commit the request.
   if (download->GetState() == content::DownloadItem::IN_PROGRESS)
     DownloadItemData::SetRequestForDownload(download, std::move(request));
   else
     CommitRequest(download, std::move(request));
 }
 
 void DownloadMetadataManager::ManagerContext::GetDownloadDetails(
     const GetDownloadDetailsCallback& callback) {
   if (state_ != LOAD_COMPLETE) {
     get_details_callbacks_.push_back(callback);
   } else {
-    callback.Run(download_metadata_ ?
-                     make_scoped_ptr(new ClientIncidentReport_DownloadDetails(
-                                         download_metadata_->download())) :
-                     nullptr);
+    callback.Run(
+        download_metadata_
+            ? base::WrapUnique(new ClientIncidentReport_DownloadDetails(
+                  download_metadata_->download()))
+            : nullptr);
   }
 }
 
 void DownloadMetadataManager::ManagerContext::OnDownloadUpdated(
     content::DownloadItem* download) {
   // Persist metadata for this download if it has just completed.
   if (download->GetState() == content::DownloadItem::COMPLETE) {
     // Ignore downloads we don't have a ClientDownloadRequest for.
-    scoped_ptr<ClientDownloadRequest> request =
+    std::unique_ptr<ClientDownloadRequest> request =
         DownloadItemData::TakeRequestForDownload(download);
     if (request)
       CommitRequest(download, std::move(request));
   }
 }
 
 void DownloadMetadataManager::ManagerContext::OnDownloadOpened(
     content::DownloadItem* download) {
   const base::Time now = base::Time::Now();
   if (state_ != LOAD_COMPLETE)
@@ skipping 11 matching lines @@
 }
 
 DownloadMetadataManager::ManagerContext::~ManagerContext() {
   // A context should not be deleted while waiting for a load to complete.
   DCHECK(pending_items_.empty());
   DCHECK(get_details_callbacks_.empty());
 }
 
 void DownloadMetadataManager::ManagerContext::CommitRequest(
     content::DownloadItem* item,
-    scoped_ptr<ClientDownloadRequest> request) {
+    std::unique_ptr<ClientDownloadRequest> request) {
   DCHECK_EQ(content::DownloadItem::COMPLETE, item->GetState());
   if (state_ != LOAD_COMPLETE) {
     // Abandon the read task since |item| is the new top dog.
     weak_factory_.InvalidateWeakPtrs();
     state_ = LOAD_COMPLETE;
     // Drop any recorded operations.
     ClearPendingItems();
   }
   // Take the request.
   download_metadata_.reset(new DownloadMetadata);
@@ skipping 11 matching lines @@
 void DownloadMetadataManager::ManagerContext::ReadMetadata() {
   DCHECK_NE(state_, LOAD_COMPLETE);
 
   DownloadMetadata* metadata = new DownloadMetadata();
   // Do not block shutdown on this read since nothing will come of it.
   read_runner_->PostTaskAndReply(
       FROM_HERE,
       base::Bind(&ReadMetadataOnWorkerPool, metadata_path_, metadata),
       base::Bind(&DownloadMetadataManager::ManagerContext::OnMetadataReady,
                  weak_factory_.GetWeakPtr(),
-                 base::Passed(make_scoped_ptr(metadata))));
+                 base::Passed(base::WrapUnique(metadata))));
 }
 
 void DownloadMetadataManager::ManagerContext::WriteMetadata() {
   write_runner_->PostTask(
       FROM_HERE,
       base::Bind(&WriteMetadataOnWorkerPool,
                  metadata_path_,
                  base::Owned(new DownloadMetadata(*download_metadata_))));
 }
 
@@ skipping 13 matching lines @@
   RunCallbacks();
 }
 
 void DownloadMetadataManager::ManagerContext::ClearPendingItems() {
   pending_items_.clear();
 }
 
 void DownloadMetadataManager::ManagerContext::RunCallbacks() {
   while (!get_details_callbacks_.empty()) {
     const auto& callback = get_details_callbacks_.front();
-    callback.Run(download_metadata_ ?
-                     make_scoped_ptr(new ClientIncidentReport_DownloadDetails(
-                                         download_metadata_->download())) :
-                     nullptr);
+    callback.Run(
+        download_metadata_
+            ? base::WrapUnique(new ClientIncidentReport_DownloadDetails(
+                  download_metadata_->download()))
+            : nullptr);
     get_details_callbacks_.pop_front();
   }
 }
 
 bool DownloadMetadataManager::ManagerContext::HasMetadataFor(
     const content::DownloadItem* item) const {
   // There must not be metadata if the load is not complete.
   DCHECK(state_ == LOAD_COMPLETE || !download_metadata_);
   return (download_metadata_ &&
           download_metadata_->download_id() == item->GetId());
 }
 
 void DownloadMetadataManager::ManagerContext::OnMetadataReady(
-    scoped_ptr<DownloadMetadata> download_metadata) {
+    std::unique_ptr<DownloadMetadata> download_metadata) {
   DCHECK_NE(state_, LOAD_COMPLETE);
 
   const bool is_detached = (state_ == DETACHED_WAIT);
 
   // Note that any available data has been read.
   state_ = LOAD_COMPLETE;
   if (download_metadata->has_download_id())
     download_metadata_ = std::move(download_metadata);
   else
     download_metadata_.reset();
@@ skipping 22 matching lines @@
 }
 
 void DownloadMetadataManager::ManagerContext::UpdateLastOpenedTime(
     const base::Time& last_opened_time) {
   download_metadata_->mutable_download()->set_open_time_msec(
       last_opened_time.ToJavaTime());
   WriteMetadata();
 }
 
 }  // namespace safe_browsing