Remove some linked_ptr c/b/extension

chrome/browser/extensions/api/platform_keys/verify_trust_api.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/extensions/api/platform_keys/verify_trust_api.h"
 
 #include <algorithm>
+#include <memory>
 
 #include "base/lazy_instance.h"
 #include "base/macros.h"
-#include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/extensions/api/platform_keys/platform_keys_api.h"
 #include "chrome/common/extensions/api/platform_keys_internal.h"
 #include "extensions/browser/extension_registry_factory.h"
 #include "net/base/net_errors.h"
 #include "net/cert/cert_verifier.h"
 #include "net/cert/cert_verify_result.h"
 #include "net/cert/x509_certificate.h"
 #include "net/log/net_log_with_source.h"
 #include "net/ssl/ssl_config_service.h"
@@ skipping 42 matching lines @@
 
   // Calls back |callback| with the result and no error.
   void CallBackWithResult(const VerifyCallback& callback,
                           std::unique_ptr<net::CertVerifyResult> verify_result,
                           RequestState* request_state,
                           int return_value);
 
   // One CertVerifier per extension to verify trust. Each verifier is created on
   // first usage and deleted when this IOPart is destructed or the respective
   // extension is unloaded.
-  std::map<std::string, linked_ptr<net::CertVerifier>> extension_to_verifier_;
+  std::map<std::string, std::unique_ptr<net::CertVerifier>>
+      extension_to_verifier_;
 };
 
 // static
 BrowserContextKeyedAPIFactory<VerifyTrustAPI>*
 VerifyTrustAPI::GetFactoryInstance() {
   return g_factory.Pointer();
 }
 
 template <>
 void BrowserContextKeyedAPIFactory<
@@ skipping 85 matching lines @@
         reinterpret_cast<const char*>(cert_der.data()), cert_der.size()));
   }
   scoped_refptr<net::X509Certificate> cert_chain(
       net::X509Certificate::CreateFromDERCertChain(der_cert_chain));
   if (!cert_chain) {
     callback.Run(platform_keys::kErrorInvalidX509Cert, 0, 0);
     return;
   }
 
   if (!base::ContainsKey(extension_to_verifier_, extension_id)) {
-    extension_to_verifier_[extension_id] =
-        make_linked_ptr(net::CertVerifier::CreateDefault().release());
+    extension_to_verifier_[extension_id] = net::CertVerifier::CreateDefault();
   }
   net::CertVerifier* verifier = extension_to_verifier_[extension_id].get();
 
   std::unique_ptr<net::CertVerifyResult> verify_result(
       new net::CertVerifyResult);
   std::unique_ptr<net::NetLogWithSource> net_log(new net::NetLogWithSource);
   const int flags = 0;
 
   std::string ocsp_response;
   net::CertVerifyResult* const verify_result_ptr = verify_result.get();
@@ skipping 26 matching lines @@
     std::unique_ptr<net::CertVerifyResult> verify_result,
     RequestState* request_state,
     int return_value) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   callback.Run(std::string() /* no error message */, return_value,
                verify_result->cert_status);
 }
 
 }  // namespace extensions