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

chrome/browser/chromeos/certificate_provider/certificate_provider_service_factory.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/chromeos/certificate_provider/certificate_provider_service_factory.h"
 
+#include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
-#include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/certificate_provider/certificate_provider_service.h"
 #include "chrome/browser/chromeos/profiles/profile_helper.h"
 #include "chrome/browser/profiles/incognito_helpers.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/api/certificate_provider.h"
 #include "components/keyed_service/content/browser_context_dependency_manager.h"
 #include "extensions/browser/event_listener_map.h"
 #include "extensions/browser/event_router.h"
@@ skipping 62 matching lines @@
   std::vector<std::string> ids;
   for (const auto& listener :
        event_router_->listeners().GetEventListenersByName(event_name)) {
     ids.push_back(listener->extension_id());
   }
   return ids;
 }
 
 void DefaultDelegate::BroadcastCertificateRequest(int request_id) {
   const std::string event_name(api_cp::OnCertificatesRequested::kEventName);
-  scoped_ptr<base::ListValue> internal_args(new base::ListValue);
+  std::unique_ptr<base::ListValue> internal_args(new base::ListValue);
   internal_args->AppendInteger(request_id);
-  scoped_ptr<extensions::Event> event(new extensions::Event(
+  std::unique_ptr<extensions::Event> event(new extensions::Event(
       extensions::events::CERTIFICATEPROVIDER_ON_CERTIFICATES_REQUESTED,
       event_name, std::move(internal_args)));
   event_router_->BroadcastEvent(std::move(event));
 }
 
 bool DefaultDelegate::DispatchSignRequestToExtension(
     const std::string& extension_id,
     int request_id,
     net::SSLPrivateKey::Hash hash,
     const scoped_refptr<net::X509Certificate>& certificate,
@@ skipping 22 matching lines @@
   }
   request.digest.assign(digest.begin(), digest.end());
   std::string cert_der;
   if (!net::X509Certificate::GetDEREncoded(certificate->os_cert_handle(),
                                            &cert_der)) {
     LOG(ERROR) << "Could not DER encode the certificate.";
     return false;  // Behave as if the extension wasn't registered anymore.
   }
   request.certificate.assign(cert_der.begin(), cert_der.end());
 
-  scoped_ptr<base::ListValue> internal_args(new base::ListValue);
+  std::unique_ptr<base::ListValue> internal_args(new base::ListValue);
   internal_args->AppendInteger(request_id);
   internal_args->Append(request.ToValue());
 
   event_router_->DispatchEventToExtension(
       extension_id,
-      make_scoped_ptr(new extensions::Event(
+      base::WrapUnique(new extensions::Event(
           extensions::events::CERTIFICATEPROVIDER_ON_SIGN_DIGEST_REQUESTED,
           event_name, std::move(internal_args))));
   return true;
 }
 
 void DefaultDelegate::OnExtensionUnloaded(
     content::BrowserContext* browser_context,
     const extensions::Extension* extension,
     extensions::UnloadedExtensionInfo::Reason reason) {
   service_->OnExtensionUnloaded(extension->id());
@@ skipping 33 matching lines @@
   return true;
 }
 
 KeyedService* CertificateProviderServiceFactory::BuildServiceInstanceFor(
     content::BrowserContext* context) const {
   if (chromeos::ProfileHelper::IsSigninProfile(
           Profile::FromBrowserContext(context))) {
     return nullptr;
   }
   CertificateProviderService* const service = new CertificateProviderService();
-  service->SetDelegate(make_scoped_ptr(new DefaultDelegate(
+  service->SetDelegate(base::WrapUnique(new DefaultDelegate(
       service,
       extensions::ExtensionRegistryFactory::GetForBrowserContext(context),
       extensions::EventRouterFactory::GetForBrowserContext(context))));
   return service;
 }
 
 }  // namespace chromeos