Convert //components/[a-e]* from scoped_ptr to std::unique_ptr

components/error_page/renderer/net_error_helper_core.cc

 // Copyright 2013 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 "components/error_page/renderer/net_error_helper_core.h"
 
 #include <stddef.h>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 176 matching lines @@
   return false;
 }
 
 // Creates a request body for use with the fixurl service.  Sets parameters
 // shared by all types of requests to the service.  |correction_params| must
 // contain the parameters specific to the actual request type.
 std::string CreateRequestBody(
     const std::string& method,
     const std::string& error_param,
     const NetErrorHelperCore::NavigationCorrectionParams& correction_params,
-    scoped_ptr<base::DictionaryValue> params_dict) {
+    std::unique_ptr<base::DictionaryValue> params_dict) {
   // Set params common to all request types.
   params_dict->SetString("key", correction_params.api_key);
   params_dict->SetString("clientName", "chrome");
   params_dict->SetString("error", error_param);
 
   if (!correction_params.language.empty())
     params_dict->SetString("language", correction_params.language);
 
   if (!correction_params.country_code.empty())
     params_dict->SetString("originCountry", correction_params.country_code);
@@ skipping 14 matching lines @@
 // |correction_request_body| to be the body for the correction request.
 std::string CreateFixUrlRequestBody(
     const blink::WebURLError& error,
     const NetErrorHelperCore::NavigationCorrectionParams& correction_params) {
   std::string error_param;
   bool result = ShouldUseFixUrlServiceForError(error, &error_param);
   DCHECK(result);
 
   // TODO(mmenke):  Investigate open sourcing the relevant protocol buffers and
   //                using those directly instead.
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
   params->SetString("urlQuery", PrepareUrlForUpload(error.unreachableURL));
   return CreateRequestBody("linkdoctor.fixurl.fixurl", error_param,
                            correction_params, std::move(params));
 }
 
 std::string CreateClickTrackingUrlRequestBody(
     const blink::WebURLError& error,
     const NetErrorHelperCore::NavigationCorrectionParams& correction_params,
     const NavigationCorrectionResponse& response,
     const NavigationCorrection& correction) {
   std::string error_param;
   bool result = ShouldUseFixUrlServiceForError(error, &error_param);
   DCHECK(result);
 
-  scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue());
+  std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
 
   params->SetString("originalUrlQuery",
                     PrepareUrlForUpload(error.unreachableURL));
 
   params->SetString("clickedUrlCorrection", correction.url_correction);
   params->SetString("clickType", correction.click_type);
   params->SetString("clickData", correction.click_data);
 
   params->SetString("eventId", response.event_id);
   params->SetString("fingerprint", response.fingerprint);
 
   return CreateRequestBody("linkdoctor.fixurl.clicktracking", error_param,
                            correction_params, std::move(params));
 }
 
 base::string16 FormatURLForDisplay(const GURL& url, bool is_rtl) {
   // Translate punycode into UTF8, unescape UTF8 URLs.
   base::string16 url_for_display(url_formatter::FormatUrl(
       url, url_formatter::kFormatUrlOmitNothing,
       net::UnescapeRule::NORMAL, nullptr, nullptr, nullptr));
   // URLs are always LTR.
   if (is_rtl)
     base::i18n::WrapStringWithLTRFormatting(&url_for_display);
   return url_for_display;
 }
 
-scoped_ptr<NavigationCorrectionResponse> ParseNavigationCorrectionResponse(
+std::unique_ptr<NavigationCorrectionResponse> ParseNavigationCorrectionResponse(
     const std::string raw_response) {
   // TODO(mmenke):  Open source related protocol buffers and use them directly.
-  scoped_ptr<base::Value> parsed = base::JSONReader::Read(raw_response);
-  scoped_ptr<NavigationCorrectionResponse> response(
+  std::unique_ptr<base::Value> parsed = base::JSONReader::Read(raw_response);
+  std::unique_ptr<NavigationCorrectionResponse> response(
       new NavigationCorrectionResponse());
   base::JSONValueConverter<NavigationCorrectionResponse> converter;
   if (!parsed || !converter.Convert(*parsed, response.get()))
     response.reset();
   return response;
 }
 
 void LogCorrectionTypeShown(int type_id) {
   UMA_HISTOGRAM_ENUMERATION(
       "Net.ErrorPageCounts.NavigationCorrectionLinksShown", type_id,
       kWebSearchQueryUMAId + 1);
 }
 
-scoped_ptr<ErrorPageParams> CreateErrorPageParams(
+std::unique_ptr<ErrorPageParams> CreateErrorPageParams(
     const NavigationCorrectionResponse& response,
     const blink::WebURLError& error,
     const NetErrorHelperCore::NavigationCorrectionParams& correction_params,
     bool is_rtl) {
   // Version of URL for display in suggestions.  It has to be sanitized first
   // because any received suggestions will be relative to the sanitized URL.
   base::string16 original_url_for_display =
       FormatURLForDisplay(SanitizeURL(GURL(error.unreachableURL)), is_rtl);
 
-  scoped_ptr<ErrorPageParams> params(new ErrorPageParams());
+  std::unique_ptr<ErrorPageParams> params(new ErrorPageParams());
   params->override_suggestions.reset(new base::ListValue());
-  scoped_ptr<base::ListValue> parsed_corrections(new base::ListValue());
+  std::unique_ptr<base::ListValue> parsed_corrections(new base::ListValue());
   for (ScopedVector<NavigationCorrection>::const_iterator it =
            response.corrections.begin();
        it != response.corrections.end(); ++it) {
     // Doesn't seem like a good idea to show these.
     if ((*it)->is_porn || (*it)->is_soft_porn)
       continue;
 
     int tracking_id = it - response.corrections.begin();
 
     if ((*it)->correction_type == "reloadPage") {
@@ skipping 126 matching lines @@
   // probe status.
   bool needs_dns_updates;
 
   // True if a blank page was loaded, and navigation corrections need to be
   // loaded to generate the real error page.
   bool needs_load_navigation_corrections;
 
   // Navigation correction service paramers, which will be used in response to
   // certain types of network errors.  They are all stored here in case they
   // change over the course of displaying the error page.
-  scoped_ptr<NetErrorHelperCore::NavigationCorrectionParams>
+  std::unique_ptr<NetErrorHelperCore::NavigationCorrectionParams>
       navigation_correction_params;
 
-  scoped_ptr<NavigationCorrectionResponse> navigation_correction_response;
+  std::unique_ptr<NavigationCorrectionResponse> navigation_correction_response;
 
   // All the navigation corrections that have been clicked, for tracking
   // purposes.
   std::set<int> clicked_corrections;
 
   // Track if specific buttons are included in an error page, for statistics.
   bool reload_button_in_page;
   bool show_saved_copy_button_in_page;
   bool show_cached_copy_button_in_page;
   bool show_offline_pages_button_in_page;
@@ skipping 237 matching lines @@
   } else {
     // These values do not matter, as error pages in iframes hide the buttons.
     bool reload_button_in_page;
     bool show_saved_copy_button_in_page;
     bool show_cached_copy_button_in_page;
     bool show_offline_pages_button_in_page;
 
     delegate_->GenerateLocalizedErrorPage(
         error, is_failed_post,
         false /* No diagnostics dialogs allowed for subframes. */,
-        false /* No offline button provided in subframes */,
-        scoped_ptr<ErrorPageParams>(), &reload_button_in_page,
-        &show_saved_copy_button_in_page, &show_cached_copy_button_in_page,
-        &show_offline_pages_button_in_page, error_html);
+        false /* No offline button provided in subframes */, nullptr,
+        &reload_button_in_page, &show_saved_copy_button_in_page,
+        &show_cached_copy_button_in_page, &show_offline_pages_button_in_page,
+        error_html);
   }
 }
 
 void NetErrorHelperCore::OnNetErrorInfo(DnsProbeStatus status) {
   DCHECK_NE(DNS_PROBE_POSSIBLE, status);
 
   last_probe_status_ = status;
 
   if (!committed_error_page_info_ ||
       !committed_error_page_info_->needs_dns_updates ||
@@ skipping 47 matching lines @@
     // loading, a DNS probe status scheduled to be sent to it may be thrown
     // out, but since the new error page should trigger a new DNS probe, it
     // will just get the results for the next page load.
     last_probe_status_ = DNS_PROBE_POSSIBLE;
     pending_error_page_info->needs_dns_updates = true;
     error = GetUpdatedError(error);
   }
 
   delegate_->GenerateLocalizedErrorPage(
       error, pending_error_page_info->was_failed_post,
-      can_show_network_diagnostics_dialog_,
-      HasOfflinePages(),
-      scoped_ptr<ErrorPageParams>(),
+      can_show_network_diagnostics_dialog_, HasOfflinePages(), nullptr,
       &pending_error_page_info->reload_button_in_page,
       &pending_error_page_info->show_saved_copy_button_in_page,
       &pending_error_page_info->show_cached_copy_button_in_page,
-      &pending_error_page_info->show_offline_pages_button_in_page,
-      error_html);
+      &pending_error_page_info->show_offline_pages_button_in_page, error_html);
 }
 
 void NetErrorHelperCore::UpdateErrorPage() {
   DCHECK(committed_error_page_info_->needs_dns_updates);
   DCHECK(committed_error_page_info_->is_finished_loading);
   DCHECK_NE(DNS_PROBE_POSSIBLE, last_probe_status_);
 
   UMA_HISTOGRAM_ENUMERATION("DnsProbe.ErrorPageUpdateStatus",
                             last_probe_status_,
                             DNS_PROBE_MAX);
@@ skipping 24 matching lines @@
   DCHECK(committed_error_page_info_->navigation_correction_params);
 
   pending_error_page_info_.reset(new ErrorPageInfo(
       committed_error_page_info_->error,
       committed_error_page_info_->was_failed_post,
       committed_error_page_info_->was_ignoring_cache));
   pending_error_page_info_->navigation_correction_response =
       ParseNavigationCorrectionResponse(corrections);
 
   std::string error_html;
-  scoped_ptr<ErrorPageParams> params;
+  std::unique_ptr<ErrorPageParams> params;
   if (pending_error_page_info_->navigation_correction_response) {
     // Copy navigation correction parameters used for the request, so tracking
     // requests can still be sent if the configuration changes.
     pending_error_page_info_->navigation_correction_params.reset(
         new NavigationCorrectionParams(
             *committed_error_page_info_->navigation_correction_params));
     params = CreateErrorPageParams(
           *pending_error_page_info_->navigation_correction_response,
           pending_error_page_info_->error,
           *pending_error_page_info_->navigation_correction_params, is_rtl);
@@ skipping 219 matching lines @@
 
 bool NetErrorHelperCore::HasOfflinePages() const {
 #if defined(OS_ANDROID)
   return has_offline_pages_;
 #else
   return false;
 #endif  // defined(OS_ANDROID)
 }
 
 }  // namespace error_page