Refactor HostContentSettingsMap::SetWebsiteSettingDefaultScope to take a std::unique_ptr.

chrome/browser/ssl/chrome_ssl_host_state_delegate.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/ssl/chrome_ssl_host_state_delegate.h"
 
 #include <stdint.h>
 
 #include <set>
 
@@ skipping 115 matching lines @@
                                        std::string(), nullptr);
       }
       // Remove the old pattern.
       map->SetWebsiteSettingCustomScope(
           setting.primary_pattern, setting.secondary_pattern,
           CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS, std::string(), nullptr);
       // Set the new pattern.
       if (value) {
         map->SetWebsiteSettingDefaultScope(
             url, GURL(), CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS,
-            std::string(), value.release());
+            std::string(), std::move(value));
       }
     }
   }
 }
 
 }  // namespace
 
 // This helper function gets the dictionary of certificate fingerprints to
 // errors of certificates that have been accepted by the user from the content
 // dictionary that has been passed in. The returned pointer is owned by the the
@@ skipping 156 matching lines @@
     return;
 
   dict->SetIntegerWithoutPathExpansion(kSSLCertDecisionVersionKey,
                                        kDefaultSSLCertDecisionVersion);
   cert_dict->SetIntegerWithoutPathExpansion(GetKey(cert, error), ALLOWED);
 
   // The map takes ownership of the value, so it is released in the call to
   // SetWebsiteSettingDefaultScope.
   map->SetWebsiteSettingDefaultScope(url, GURL(),
                                      CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS,
-                                     std::string(), value.release());
+                                     std::string(), std::move(value));
 }
 
 void ChromeSSLHostStateDelegate::Clear() {
   HostContentSettingsMapFactory::GetForProfile(profile_)
       ->ClearSettingsForOneType(CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS);
 }
 
 content::SSLHostStateDelegate::CertJudgment
 ChromeSSLHostStateDelegate::QueryPolicy(const std::string& host,
                                         const net::X509Certificate& cert,
@@ skipping 47 matching lines @@
 }
 
 void ChromeSSLHostStateDelegate::RevokeUserAllowExceptions(
     const std::string& host) {
   GURL url = GetSecureGURLForHost(host);
   HostContentSettingsMap* map =
       HostContentSettingsMapFactory::GetForProfile(profile_);
 
   map->SetWebsiteSettingDefaultScope(url, GURL(),
                                      CONTENT_SETTINGS_TYPE_SSL_CERT_DECISIONS,
-                                     std::string(), NULL);
+                                     std::string(), nullptr);
 }
 
 // TODO(jww): This will revoke all of the decisions in the browser context.
 // However, the networking stack actually keeps track of its own list of
 // exceptions per-HttpNetworkTransaction in the SSLConfig structure (see the
 // allowed_bad_certs Vector in net/ssl/ssl_config.h). This dual-tracking of
 // exceptions introduces a problem where the browser context can revoke a
 // certificate, but if a transaction reuses a cached version of the SSLConfig
 // (probably from a pooled socket), it may bypass the intestitial layer.
 //
@@ skipping 48 matching lines @@
 }
 
 bool ChromeSSLHostStateDelegate::DidHostRunInsecureContent(
     const std::string& host,
     int pid) const {
   return !!ran_insecure_content_hosts_.count(BrokenHostEntry(host, pid));
 }
 void ChromeSSLHostStateDelegate::SetClock(std::unique_ptr<base::Clock> clock) {
   clock_.reset(clock.release());
 }