BASELINE: Update Chromium to 59.0.3071.134

Change-Id: Id02ef6fb2204c5fd21668a1c3e6911c83b17585a
Reviewed-by: Alexandru Croitor <alexandru.croitor@qt.io>

4 files changed, 40 insertions, 29 deletions

diff --git a/chromium/components/error_page/OWNERS b/chromium/components/error_page/OWNERS
index 2b70a4c33b6..bebb2c48565 100644
--- a/chromium/components/error_page/OWNERS
+++ b/chromium/components/error_page/OWNERS
@@ -3,4 +3,6 @@ juliatuttle@chromium.org
 
 # If changing network error strings, please visit go/chrome-neterror-strings
 # (Google internal) or contact edwardjung@chromium.org and rachelis@chromium.org
-per-file error_page_strings.grdp=edwardjung@chromium.org
\ No newline at end of file
+per-file error_page_strings.grdp=edwardjung@chromium.org
+
+# COMPONENT: Internals>Network
diff --git a/chromium/components/error_page/common/localized_error.cc b/chromium/components/error_page/common/localized_error.cc
index 5192a110541..32cb9e9b40b 100644
--- a/chromium/components/error_page/common/localized_error.cc
+++ b/chromium/components/error_page/common/localized_error.cc
@@ -248,6 +248,12 @@ const LocalizedErrorMap net_error_options[] = {
    SUGGEST_CONTACT_ADMINISTRATOR,
    SHOW_NO_BUTTONS,
   },
+  {net::ERR_SSL_VERSION_INTERFERENCE,
+   IDS_ERRORPAGES_HEADING_NOT_AVAILABLE,
+   IDS_ERRORPAGES_SUMMARY_CONNECTION_FAILED,
+   SUGGEST_CHECK_CONNECTION | SUGGEST_FIREWALL_CONFIG | SUGGEST_PROXY_CONFIG,
+   SHOW_BUTTON_RELOAD,
+  },
   {net::ERR_SSL_WEAK_SERVER_EPHEMERAL_DH_KEY,
    IDS_ERRORPAGES_HEADING_INSECURE_CONNECTION,
    IDS_ERRORPAGES_SUMMARY_SSL_SECURITY_ERROR,
@@ -757,6 +763,9 @@ base::DictionaryValue* AddSuggestionDetailDictionaryToList(
         l10n_util::GetStringUTF16(body_message_id));
   }
   list->Append(base::WrapUnique(suggestion_list_item));
+  // |suggestion_list_item| is invalidated at this point, so it needs to be
+  // reset.
+  list->GetDictionary(list->GetSize() - 1, &suggestion_list_item);
   return suggestion_list_item;
 }
 
diff --git a/chromium/components/error_page/renderer/net_error_helper_core.cc b/chromium/components/error_page/renderer/net_error_helper_core.cc
index e9c1eef43d7..287cd84def6 100644
--- a/chromium/components/error_page/renderer/net_error_helper_core.cc
+++ b/chromium/components/error_page/renderer/net_error_helper_core.cc
@@ -129,7 +129,7 @@ base::TimeDelta GetAutoReloadTime(size_t reload_count) {
 // Returns whether |error| is a DNS-related error (and therefore whether
 // the tab helper should start a DNS probe after receiving it).
 bool IsBlinkDnsError(const blink::WebURLError& error) {
-  return (error.domain.utf8() == net::kErrorDomain) &&
+  return (error.domain.Utf8() == net::kErrorDomain) &&
          net::IsDnsError(error.reason);
 }
 
@@ -163,11 +163,11 @@ bool ShouldUseFixUrlServiceForError(const blink::WebURLError& error,
   error_param->clear();
 
   // Don't use the correction service for HTTPS (for privacy reasons).
-  GURL unreachable_url(error.unreachableURL);
+  GURL unreachable_url(error.unreachable_url);
   if (GURL(unreachable_url).SchemeIsCryptographic())
     return false;
 
-  std::string domain = error.domain.utf8();
+  std::string domain = error.domain.Utf8();
   if (domain == url::kHttpScheme && error.reason == 404) {
     *error_param = "http404";
     return true;
@@ -230,7 +230,7 @@ std::string CreateFixUrlRequestBody(
   // TODO(mmenke):  Investigate open sourcing the relevant protocol buffers and
   //                using those directly instead.
   std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
-  params->SetString("urlQuery", PrepareUrlForUpload(error.unreachableURL));
+  params->SetString("urlQuery", PrepareUrlForUpload(error.unreachable_url));
   return CreateRequestBody("linkdoctor.fixurl.fixurl", error_param,
                            correction_params, std::move(params));
 }
@@ -247,7 +247,7 @@ std::string CreateClickTrackingUrlRequestBody(
   std::unique_ptr<base::DictionaryValue> params(new base::DictionaryValue());
 
   params->SetString("originalUrlQuery",
-                    PrepareUrlForUpload(error.unreachableURL));
+                    PrepareUrlForUpload(error.unreachable_url));
 
   params->SetString("clickedUrlCorrection", correction.url_correction);
   params->SetString("clickType", correction.click_type);
@@ -297,7 +297,7 @@ std::unique_ptr<ErrorPageParams> CreateErrorPageParams(
   // 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);
+      FormatURLForDisplay(SanitizeURL(GURL(error.unreachable_url)), is_rtl);
 
   std::unique_ptr<ErrorPageParams> params(new ErrorPageParams());
   params->override_suggestions.reset(new base::ListValue());
@@ -368,7 +368,7 @@ std::unique_ptr<ErrorPageParams> CreateErrorPageParams(
 }
 
 void ReportAutoReloadSuccess(const blink::WebURLError& error, size_t count) {
-  if (error.domain.utf8() != net::kErrorDomain)
+  if (error.domain.Utf8() != net::kErrorDomain)
     return;
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.AutoReload.ErrorAtSuccess", -error.reason);
   UMA_HISTOGRAM_COUNTS("Net.AutoReload.CountAtSuccess",
@@ -380,7 +380,7 @@ void ReportAutoReloadSuccess(const blink::WebURLError& error, size_t count) {
 }
 
 void ReportAutoReloadFailure(const blink::WebURLError& error, size_t count) {
-  if (error.domain.utf8() != net::kErrorDomain)
+  if (error.domain.Utf8() != net::kErrorDomain)
     return;
   UMA_HISTOGRAM_SPARSE_SLOWLY("Net.AutoReload.ErrorAtStop", -error.reason);
   UMA_HISTOGRAM_COUNTS("Net.AutoReload.CountAtStop",
@@ -483,8 +483,8 @@ NetErrorHelperCore::NavigationCorrectionParams::~NavigationCorrectionParams() {
 
 bool NetErrorHelperCore::IsReloadableError(
     const NetErrorHelperCore::ErrorPageInfo& info) {
-  GURL url = info.error.unreachableURL;
-  return info.error.domain.utf8() == net::kErrorDomain &&
+  GURL url = info.error.unreachable_url;
+  return info.error.domain.Utf8() == net::kErrorDomain &&
          info.error.reason != net::ERR_ABORTED &&
          // For now, net::ERR_UNKNOWN_URL_SCHEME is only being displayed on
          // Chrome for Android.
@@ -605,8 +605,8 @@ void NetErrorHelperCore::OnCommitLoad(FrameType frame_type, const GURL& url) {
   // result is from the page reload button.
   if (committed_error_page_info_ && pending_error_page_info_ &&
       navigation_from_button_ != NO_BUTTON &&
-      committed_error_page_info_->error.unreachableURL ==
-          pending_error_page_info_->error.unreachableURL) {
+      committed_error_page_info_->error.unreachable_url ==
+          pending_error_page_info_->error.unreachable_url) {
     DCHECK(navigation_from_button_ == RELOAD_BUTTON ||
            navigation_from_button_ == SHOW_SAVED_COPY_BUTTON);
     RecordEvent(navigation_from_button_ == RELOAD_BUTTON ?
@@ -618,7 +618,7 @@ void NetErrorHelperCore::OnCommitLoad(FrameType frame_type, const GURL& url) {
   if (committed_error_page_info_ && !pending_error_page_info_ &&
       committed_error_page_info_->auto_reload_triggered) {
     const blink::WebURLError& error = committed_error_page_info_->error;
-    const GURL& error_url = error.unreachableURL;
+    const GURL& error_url = error.unreachable_url;
     if (url == error_url)
       ReportAutoReloadSuccess(error, auto_reload_count_);
     else if (url != content::kUnreachableWebDataURL)
@@ -853,7 +853,7 @@ void NetErrorHelperCore::OnNavigationCorrectionsFetched(
   //                double page load by just updating the error page, like DNS
   //                probes do.
   delegate_->LoadErrorPage(error_html,
-                           pending_error_page_info_->error.unreachableURL);
+                           pending_error_page_info_->error.unreachable_url);
 }
 
 blink::WebURLError NetErrorHelperCore::GetUpdatedError(
@@ -865,10 +865,10 @@ blink::WebURLError NetErrorHelperCore::GetUpdatedError(
   }
 
   blink::WebURLError updated_error;
-  updated_error.domain = blink::WebString::fromUTF8(kDnsProbeErrorDomain);
+  updated_error.domain = blink::WebString::FromUTF8(kDnsProbeErrorDomain);
   updated_error.reason = last_probe_status_;
-  updated_error.unreachableURL = error.unreachableURL;
-  updated_error.staleCopyInCache = error.staleCopyInCache;
+  updated_error.unreachable_url = error.unreachable_url;
+  updated_error.stale_copy_in_cache = error.stale_copy_in_cache;
 
   return updated_error;
 }
@@ -989,7 +989,7 @@ void NetErrorHelperCore::ExecuteButtonPress(Button button) {
         RecordEvent(NETWORK_ERROR_PAGE_BOTH_BUTTONS_SHOWN_SAVED_COPY_CLICKED);
       }
       delegate_->LoadPageFromCache(
-          committed_error_page_info_->error.unreachableURL);
+          committed_error_page_info_->error.unreachable_url);
       return;
     case MORE_BUTTON:
       // Visual effects on page are handled in Javascript code.
@@ -1004,7 +1004,7 @@ void NetErrorHelperCore::ExecuteButtonPress(Button button) {
     case DIAGNOSE_ERROR:
       RecordEvent(NETWORK_ERROR_DIAGNOSE_BUTTON_CLICKED);
       delegate_->DiagnoseError(
-          committed_error_page_info_->error.unreachableURL);
+          committed_error_page_info_->error.unreachable_url);
       return;
     case DOWNLOAD_BUTTON:
       RecordEvent(NETWORK_ERROR_PAGE_DOWNLOAD_BUTTON_CLICKED);
diff --git a/chromium/components/error_page/renderer/net_error_helper_core_unittest.cc b/chromium/components/error_page/renderer/net_error_helper_core_unittest.cc
index db07d6862e2..f67d1cd4991 100644
--- a/chromium/components/error_page/renderer/net_error_helper_core_unittest.cc
+++ b/chromium/components/error_page/renderer/net_error_helper_core_unittest.cc
@@ -114,23 +114,23 @@ testing::AssertionResult StringValueEquals(
 // error page for that error.
 std::string ErrorToString(const WebURLError& error, bool is_failed_post) {
   return base::StringPrintf("(%s, %s, %i, %s)",
-                            error.unreachableURL.string().utf8().c_str(),
-                            error.domain.utf8().c_str(), error.reason,
+                            error.unreachable_url.GetString().Utf8().c_str(),
+                            error.domain.Utf8().c_str(), error.reason,
                             is_failed_post ? "POST" : "NOT POST");
 }
 
 WebURLError ProbeError(DnsProbeStatus status) {
   WebURLError error;
-  error.unreachableURL = GURL(kFailedUrl);
-  error.domain = blink::WebString::fromUTF8(kDnsProbeErrorDomain);
+  error.unreachable_url = GURL(kFailedUrl);
+  error.domain = blink::WebString::FromUTF8(kDnsProbeErrorDomain);
   error.reason = status;
   return error;
 }
 
 WebURLError NetErrorForURL(net::Error net_error, const GURL& url) {
   WebURLError error;
-  error.unreachableURL = url;
-  error.domain = blink::WebString::fromUTF8(net::kErrorDomain);
+  error.unreachable_url = url;
+  error.domain = blink::WebString::FromUTF8(net::kErrorDomain);
   error.reason = net_error;
   return error;
 }
@@ -1176,13 +1176,13 @@ TEST_F(NetErrorHelperCoreTest, NoCorrectionsForHttps) {
   // The HTTPS page fails to load.
   std::string html;
   blink::WebURLError error = NetError(net::ERR_NAME_NOT_RESOLVED);
-  error.unreachableURL = GURL(kFailedHttpsUrl);
+  error.unreachable_url = GURL(kFailedHttpsUrl);
   core()->GetErrorHTML(NetErrorHelperCore::MAIN_FRAME, error,
                        false /* is_failed_post */,
                        false /* is_ignoring_cache */, &html);
 
   blink::WebURLError probe_error = ProbeError(DNS_PROBE_POSSIBLE);
-  probe_error.unreachableURL = GURL(kFailedHttpsUrl);
+  probe_error.unreachable_url = GURL(kFailedHttpsUrl);
   EXPECT_EQ(ErrorToString(probe_error, false), html);
   EXPECT_FALSE(is_url_being_fetched());
   EXPECT_FALSE(last_error_page_params());
@@ -1203,7 +1203,7 @@ TEST_F(NetErrorHelperCoreTest, NoCorrectionsForHttps) {
   EXPECT_FALSE(last_error_page_params());
   blink::WebURLError final_probe_error =
       ProbeError(DNS_PROBE_FINISHED_NXDOMAIN);
-  final_probe_error.unreachableURL = GURL(kFailedHttpsUrl);
+  final_probe_error.unreachable_url = GURL(kFailedHttpsUrl);
   EXPECT_EQ(ErrorToString(final_probe_error, false), last_error_html());
 }