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

chrome/browser/safe_browsing/incident_reporting/resource_request_detector.cc

 // Copyright 2015 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/resource_request_detector.h"
 
 #include <utility>
 
+#include "base/memory/ptr_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/incident_reporting/incident_receiver.h"
 #include "chrome/browser/safe_browsing/incident_reporting/resource_request_incident.h"
 #include "chrome/common/safe_browsing/csd.pb.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/browser/site_instance.h"
 #include "crypto/sha2.h"
@@ skipping 35 matching lines @@
 
 // Implementation of SafeBrowsingDatabaseManager::Client that is used to lookup
 // a resource blacklist. Can be constructed on any thread.
 class ResourceRequestDetectorClient
     : public SafeBrowsingDatabaseManager::Client,
       public base::RefCountedThreadSafe<ResourceRequestDetectorClient> {
  public:
   using ResourceRequestIncidentMessage =
       ClientIncidentReport::IncidentData::ResourceRequestIncident;
 
-  typedef base::Callback<void(scoped_ptr<ResourceRequestIncidentMessage>)>
+  typedef base::Callback<void(std::unique_ptr<ResourceRequestIncidentMessage>)>
       OnResultCallback;
 
   ResourceRequestDetectorClient(
       const GURL& resource_url,
       const scoped_refptr<SafeBrowsingDatabaseManager>& database_manager,
       const OnResultCallback& callback)
       : database_manager_(database_manager)
       , callback_(callback) {
     content::BrowserThread::PostTask(
         content::BrowserThread::IO, FROM_HERE,
@@ skipping 18 matching lines @@
     // client object may be destroyed immediately.
     if (database_manager_->CheckResourceUrl(resource_url, this)) {
       Release();
     }
   }
 
   void OnCheckResourceUrlResult(const GURL& url,
                                 SBThreatType threat_type,
                                 const std::string& threat_hash) override {
     if (threat_type == SB_THREAT_TYPE_BLACKLISTED_RESOURCE) {
-      scoped_ptr<ResourceRequestIncidentMessage> incident_data(
+      std::unique_ptr<ResourceRequestIncidentMessage> incident_data(
           new ResourceRequestIncidentMessage());
       incident_data->set_type(ResourceRequestIncidentMessage::TYPE_PATTERN);
       incident_data->set_digest(threat_hash);
       content::BrowserThread::PostTask(
           content::BrowserThread::UI, FROM_HERE,
           base::Bind(callback_, base::Passed(&incident_data)));
     }
     Release();  // Balanced in StartCheck.
   }
 
   scoped_refptr<SafeBrowsingDatabaseManager> database_manager_;
   OnResultCallback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceRequestDetectorClient);
 };
 
 }  // namespace
 
 ResourceRequestDetector::ResourceRequestDetector(
     scoped_refptr<SafeBrowsingDatabaseManager> database_manager,
-    scoped_ptr<IncidentReceiver> incident_receiver)
+    std::unique_ptr<IncidentReceiver> incident_receiver)
     : incident_receiver_(std::move(incident_receiver)),
       database_manager_(database_manager),
       allow_null_profile_for_testing_(false),
-      weak_ptr_factory_(this) {
-}
+      weak_ptr_factory_(this) {}
 
 ResourceRequestDetector::~ResourceRequestDetector() {
 }
 
 void ResourceRequestDetector::OnResourceRequest(
     const net::URLRequest* request) {
   // Only look at actual net requests (e.g., not chrome-extensions://id/foo.js).
   if (!request->url().SchemeIsHTTPOrHTTPS())
     return;
 
@@ skipping 16 matching lines @@
 }
 
 void ResourceRequestDetector::set_allow_null_profile_for_testing(
     bool allow_null_profile_for_testing) {
   allow_null_profile_for_testing_ = allow_null_profile_for_testing;
 }
 
 void ResourceRequestDetector::ReportIncidentOnUIThread(
     int render_process_id,
     int render_frame_id,
-    scoped_ptr<ClientIncidentReport_IncidentData_ResourceRequestIncident>
+    std::unique_ptr<ClientIncidentReport_IncidentData_ResourceRequestIncident>
         incident_data) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   Profile* profile = GetProfileForRenderProcessId(render_process_id);
   if (profile || allow_null_profile_for_testing_) {
     // Add the URL obtained from the RenderFrameHost, if available.
     GURL host_url = GetUrlForRenderFrameId(render_process_id, render_frame_id);
     if (host_url.is_valid())
       incident_data->set_origin(host_url.GetOrigin().spec());
 
     incident_receiver_->AddIncidentForProfile(
-        profile,
-        make_scoped_ptr(new ResourceRequestIncident(std::move(incident_data))));
+        profile, base::WrapUnique(
+                     new ResourceRequestIncident(std::move(incident_data))));
   }
 }
 
 }  // namespace safe_browsing