Convert //content from scoped_ptr to std::unique_ptr

content/public/browser/download_url_parameters.h

 // 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.
 
 #ifndef CONTENT_PUBLIC_BROWSER_DOWNLOAD_URL_PARAMETERS_H_
 #define CONTENT_PUBLIC_BROWSER_DOWNLOAD_URL_PARAMETERS_H_
 
 #include <stdint.h>
+
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
-#include "base/memory/scoped_ptr.h"
 #include "content/public/browser/download_interrupt_reasons.h"
 #include "content/public/browser/download_save_info.h"
 #include "content/public/common/referrer.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "url/gurl.h"
 
 namespace content {
 
 class DownloadItem;
 class ResourceContext;
@@ skipping 27 matching lines @@
   // download request. I.e. the download triggered a warning of some sort and
   // the user chose to not to proceed with the download as a result.
   typedef base::Callback<void(DownloadItem*, DownloadInterruptReason)>
       OnStartedCallback;
 
   typedef std::pair<std::string, std::string> RequestHeadersNameValuePair;
   typedef std::vector<RequestHeadersNameValuePair> RequestHeadersType;
 
   // Construct DownloadUrlParameters for downloading the resource at |url| and
   // associating the download with |web_contents|.
-  static scoped_ptr<DownloadUrlParameters> FromWebContents(
+  static std::unique_ptr<DownloadUrlParameters> FromWebContents(
       WebContents* web_contents,
       const GURL& url);
 
   // Construct DownloadUrlParameters for downloading the resource at |url| and
   // associating the download with the WebContents identified by
   // |render_process_host_id| and |render_view_host_routing_id|.
   //
   // If the download is not associated with a WebContents, then set the IDs to
   // -1.
   // NOTE: This is not safe and should only be done in a limited set of cases
@@ skipping 88 matching lines @@
   // meaningful if a partial file exists and is identified by either the
   // |file_path()| or |file()|.
   void set_hash_of_partial_file(const std::string& hash_of_partial_file) {
     save_info_.hash_of_partial_file = hash_of_partial_file;
   }
 
   // If |offset| is non-zero, then |hash_state| indicates the SHA-256 hash state
   // of the first |offset| bytes of the target file. In this case, the prefix
   // hash will be ignored since the |hash_state| is assumed to be correct if
   // provided.
-  void set_hash_state(scoped_ptr<crypto::SecureHash> hash_state) {
+  void set_hash_state(std::unique_ptr<crypto::SecureHash> hash_state) {
     save_info_.hash_state = std::move(hash_state);
   }
 
   // If |prompt| is true, then the user will be prompted for a filename. Ignored
   // if |file_path| is non-empty.
   void set_prompt(bool prompt) { save_info_.prompt_for_save_location = prompt; }
   void set_file(base::File file) { save_info_.file = std::move(file); }
   void set_do_not_prompt_for_login(bool do_not_prompt) {
     do_not_prompt_for_login_ = do_not_prompt;
   }
 
   // For downloads of blob URLs, the caller can store a BlobDataHandle in the
   // DownloadUrlParameters object so that the blob will remain valid until
   // the download starts. The BlobDataHandle will be attached to the associated
   // URLRequest.
   //
   // This is optional. If left unspecified, and the blob URL cannot be mapped to
   // a blob by the time the download request starts, then the download will
   // fail.
   void set_blob_data_handle(
-      scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
+      std::unique_ptr<storage::BlobDataHandle> blob_data_handle) {
     blob_data_handle_ = std::move(blob_data_handle);
   }
 
   const OnStartedCallback& callback() const { return callback_; }
   bool content_initiated() const { return content_initiated_; }
   const std::string& last_modified() const { return last_modified_; }
   const std::string& etag() const { return etag_; }
   const std::string& method() const { return method_; }
   const std::string& post_body() const { return post_body_; }
   int64_t post_id() const { return post_id_; }
@@ skipping 15 matching lines @@
   }
   int64_t offset() const { return save_info_.offset; }
   const std::string& hash_of_partial_file() const {
     return save_info_.hash_of_partial_file;
   }
   bool prompt() const { return save_info_.prompt_for_save_location; }
   const GURL& url() const { return url_; }
   bool do_not_prompt_for_login() const { return do_not_prompt_for_login_; }
 
   // STATE_CHANGING: Return the BlobDataHandle.
-  scoped_ptr<storage::BlobDataHandle> GetBlobDataHandle() {
+  std::unique_ptr<storage::BlobDataHandle> GetBlobDataHandle() {
     return std::move(blob_data_handle_);
   }
 
   // STATE CHANGING: All save_info_ sub-objects will be in an indeterminate
   // state following this call.
   DownloadSaveInfo GetSaveInfo() { return std::move(save_info_); }
 
  private:
   OnStartedCallback callback_;
   bool content_initiated_;
   RequestHeadersType request_headers_;
   std::string last_modified_;
   std::string etag_;
   std::string method_;
   std::string post_body_;
   int64_t post_id_;
   bool prefer_cache_;
   Referrer referrer_;
   std::string referrer_encoding_;
   int render_process_host_id_;
   int render_view_host_routing_id_;
   int render_frame_host_routing_id_;
   ResourceContext* resource_context_;
   DownloadSaveInfo save_info_;
   GURL url_;
   bool do_not_prompt_for_login_;
-  scoped_ptr<storage::BlobDataHandle> blob_data_handle_;
+  std::unique_ptr<storage::BlobDataHandle> blob_data_handle_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadUrlParameters);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_PUBLIC_BROWSER_DOWNLOAD_URL_PARAMETERS_H_