| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright 2013 The Chromium Authors. All rights reserved. | |
| 2 // Use of this source code is governed by a BSD-style license that can be | |
| 3 // found in the LICENSE file. | |
| 4 | |
| 5 #include "chrome/renderer/net/net_error_helper_core.h" | |
| 6 | |
| 7 #include <set> | |
| 8 #include <string> | |
| 9 #include <vector> | |
| 10 | |
| 11 #include "base/bind.h" | |
| 12 #include "base/callback.h" | |
| 13 #include "base/i18n/rtl.h" | |
| 14 #include "base/json/json_reader.h" | |
| 15 #include "base/json/json_value_converter.h" | |
| 16 #include "base/json/json_writer.h" | |
| 17 #include "base/location.h" | |
| 18 #include "base/logging.h" | |
| 19 #include "base/memory/scoped_vector.h" | |
| 20 #include "base/metrics/histogram.h" | |
| 21 #include "base/strings/string16.h" | |
| 22 #include "base/strings/string_util.h" | |
| 23 #include "base/values.h" | |
| 24 #include "chrome/common/localized_error.h" | |
| 25 #include "chrome/grit/generated_resources.h" | |
| 26 #include "content/public/common/url_constants.h" | |
| 27 #include "net/base/escape.h" | |
| 28 #include "net/base/net_errors.h" | |
| 29 #include "net/base/net_util.h" | |
| 30 #include "third_party/WebKit/public/platform/WebString.h" | |
| 31 #include "third_party/WebKit/public/platform/WebURLError.h" | |
| 32 #include "ui/base/l10n/l10n_util.h" | |
| 33 #include "url/gurl.h" | |
| 34 | |
| 35 namespace { | |
| 36 | |
| 37 struct CorrectionTypeToResourceTable { | |
| 38 int resource_id; | |
| 39 const char* correction_type; | |
| 40 }; | |
| 41 | |
| 42 const CorrectionTypeToResourceTable kCorrectionResourceTable[] = { | |
| 43 {IDS_ERRORPAGES_SUGGESTION_VISIT_GOOGLE_CACHE, "cachedPage"}, | |
| 44 // "reloadPage" is has special handling. | |
| 45 {IDS_ERRORPAGES_SUGGESTION_CORRECTED_URL, "urlCorrection"}, | |
| 46 {IDS_ERRORPAGES_SUGGESTION_ALTERNATE_URL, "siteDomain"}, | |
| 47 {IDS_ERRORPAGES_SUGGESTION_ALTERNATE_URL, "host"}, | |
| 48 {IDS_ERRORPAGES_SUGGESTION_ALTERNATE_URL, "sitemap"}, | |
| 49 {IDS_ERRORPAGES_SUGGESTION_ALTERNATE_URL, "pathParentFolder"}, | |
| 50 // "siteSearchQuery" is not yet supported. | |
| 51 // TODO(mmenke): Figure out what format "siteSearchQuery" uses for its | |
| 52 // suggestions. | |
| 53 // "webSearchQuery" has special handling. | |
| 54 {IDS_ERRORPAGES_SUGGESTION_ALTERNATE_URL, "contentOverlap"}, | |
| 55 {IDS_ERRORPAGES_SUGGESTION_CORRECTED_URL, "emphasizedUrlCorrection"}, | |
| 56 }; | |
| 57 | |
| 58 struct NavigationCorrection { | |
| 59 NavigationCorrection() : is_porn(false), is_soft_porn(false) { | |
| 60 } | |
| 61 | |
| 62 static void RegisterJSONConverter( | |
| 63 base::JSONValueConverter<NavigationCorrection>* converter) { | |
| 64 converter->RegisterStringField("correctionType", | |
| 65 &NavigationCorrection::correction_type); | |
| 66 converter->RegisterStringField("urlCorrection", | |
| 67 &NavigationCorrection::url_correction); | |
| 68 converter->RegisterStringField("clickType", | |
| 69 &NavigationCorrection::click_type); | |
| 70 converter->RegisterStringField("clickData", | |
| 71 &NavigationCorrection::click_data); | |
| 72 converter->RegisterBoolField("isPorn", &NavigationCorrection::is_porn); | |
| 73 converter->RegisterBoolField("isSoftPorn", | |
| 74 &NavigationCorrection::is_soft_porn); | |
| 75 } | |
| 76 | |
| 77 std::string correction_type; | |
| 78 std::string url_correction; | |
| 79 std::string click_type; | |
| 80 std::string click_data; | |
| 81 bool is_porn; | |
| 82 bool is_soft_porn; | |
| 83 }; | |
| 84 | |
| 85 struct NavigationCorrectionResponse { | |
| 86 std::string event_id; | |
| 87 std::string fingerprint; | |
| 88 ScopedVector<NavigationCorrection> corrections; | |
| 89 | |
| 90 static void RegisterJSONConverter( | |
| 91 base::JSONValueConverter<NavigationCorrectionResponse>* converter) { | |
| 92 converter->RegisterStringField("result.eventId", | |
| 93 &NavigationCorrectionResponse::event_id); | |
| 94 converter->RegisterStringField("result.fingerprint", | |
| 95 &NavigationCorrectionResponse::fingerprint); | |
| 96 converter->RegisterRepeatedMessage( | |
| 97 "result.UrlCorrections", | |
| 98 &NavigationCorrectionResponse::corrections); | |
| 99 } | |
| 100 }; | |
| 101 | |
| 102 base::TimeDelta GetAutoReloadTime(size_t reload_count) { | |
| 103 static const int kDelaysMs[] = { | |
| 104 0, 5000, 30000, 60000, 300000, 600000, 1800000 | |
| 105 }; | |
| 106 if (reload_count >= arraysize(kDelaysMs)) | |
| 107 reload_count = arraysize(kDelaysMs) - 1; | |
| 108 return base::TimeDelta::FromMilliseconds(kDelaysMs[reload_count]); | |
| 109 } | |
| 110 | |
| 111 // Returns whether |net_error| is a DNS-related error (and therefore whether | |
| 112 // the tab helper should start a DNS probe after receiving it.) | |
| 113 bool IsDnsError(const blink::WebURLError& error) { | |
| 114 return error.domain.utf8() == net::kErrorDomain && | |
| 115 (error.reason == net::ERR_NAME_NOT_RESOLVED || | |
| 116 error.reason == net::ERR_NAME_RESOLUTION_FAILED); | |
| 117 } | |
| 118 | |
| 119 GURL SanitizeURL(const GURL& url) { | |
| 120 GURL::Replacements remove_params; | |
| 121 remove_params.ClearUsername(); | |
| 122 remove_params.ClearPassword(); | |
| 123 remove_params.ClearQuery(); | |
| 124 remove_params.ClearRef(); | |
| 125 return url.ReplaceComponents(remove_params); | |
| 126 } | |
| 127 | |
| 128 // Sanitizes and formats a URL for upload to the error correction service. | |
| 129 std::string PrepareUrlForUpload(const GURL& url) { | |
| 130 // TODO(yuusuke): Change to net::FormatUrl when Link Doctor becomes | |
| 131 // unicode-capable. | |
| 132 std::string spec_to_send = SanitizeURL(url).spec(); | |
| 133 | |
| 134 // Notify navigation correction service of the url truncation by sending of | |
| 135 // "?" at the end. | |
| 136 if (url.has_query()) | |
| 137 spec_to_send.append("?"); | |
| 138 return spec_to_send; | |
| 139 } | |
| 140 | |
| 141 // Given a WebURLError, returns true if the FixURL service should be used | |
| 142 // for that error. Also sets |error_param| to the string that should be sent to | |
| 143 // the FixURL service to identify the error type. | |
| 144 bool ShouldUseFixUrlServiceForError(const blink::WebURLError& error, | |
| 145 std::string* error_param) { | |
| 146 error_param->clear(); | |
| 147 | |
| 148 // Don't use the correction service for HTTPS (for privacy reasons). | |
| 149 GURL unreachable_url(error.unreachableURL); | |
| 150 if (GURL(unreachable_url).SchemeIsSecure()) | |
| 151 return false; | |
| 152 | |
| 153 std::string domain = error.domain.utf8(); | |
| 154 if (domain == "http" && error.reason == 404) { | |
| 155 *error_param = "http404"; | |
| 156 return true; | |
| 157 } | |
| 158 if (IsDnsError(error)) { | |
| 159 *error_param = "dnserror"; | |
| 160 return true; | |
| 161 } | |
| 162 if (domain == net::kErrorDomain && | |
| 163 (error.reason == net::ERR_CONNECTION_FAILED || | |
| 164 error.reason == net::ERR_CONNECTION_REFUSED || | |
| 165 error.reason == net::ERR_ADDRESS_UNREACHABLE || | |
| 166 error.reason == net::ERR_CONNECTION_TIMED_OUT)) { | |
| 167 *error_param = "connectionFailure"; | |
| 168 return true; | |
| 169 } | |
| 170 return false; | |
| 171 } | |
| 172 | |
| 173 // Creates a request body for use with the fixurl service. Sets parameters | |
| 174 // shared by all types of requests to the service. |correction_params| must | |
| 175 // contain the parameters specific to the actual request type. | |
| 176 std::string CreateRequestBody( | |
| 177 const std::string& method, | |
| 178 const std::string& error_param, | |
| 179 const NetErrorHelperCore::NavigationCorrectionParams& correction_params, | |
| 180 scoped_ptr<base::DictionaryValue> params_dict) { | |
| 181 // Set params common to all request types. | |
| 182 params_dict->SetString("key", correction_params.api_key); | |
| 183 params_dict->SetString("clientName", "chrome"); | |
| 184 params_dict->SetString("error", error_param); | |
| 185 | |
| 186 if (!correction_params.language.empty()) | |
| 187 params_dict->SetString("language", correction_params.language); | |
| 188 | |
| 189 if (!correction_params.country_code.empty()) | |
| 190 params_dict->SetString("originCountry", correction_params.country_code); | |
| 191 | |
| 192 base::DictionaryValue request_dict; | |
| 193 request_dict.SetString("method", method); | |
| 194 request_dict.SetString("apiVersion", "v1"); | |
| 195 request_dict.Set("params", params_dict.release()); | |
| 196 | |
| 197 std::string request_body; | |
| 198 bool success = base::JSONWriter::Write(&request_dict, &request_body); | |
| 199 DCHECK(success); | |
| 200 return request_body; | |
| 201 } | |
| 202 | |
| 203 // If URL correction information should be retrieved remotely for a main frame | |
| 204 // load that failed with |error|, returns true and sets | |
| 205 // |correction_request_body| to be the body for the correction request. | |
| 206 std::string CreateFixUrlRequestBody( | |
| 207 const blink::WebURLError& error, | |
| 208 const NetErrorHelperCore::NavigationCorrectionParams& correction_params) { | |
| 209 std::string error_param; | |
| 210 bool result = ShouldUseFixUrlServiceForError(error, &error_param); | |
| 211 DCHECK(result); | |
| 212 | |
| 213 // TODO(mmenke): Investigate open sourcing the relevant protocol buffers and | |
| 214 // using those directly instead. | |
| 215 scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue()); | |
| 216 params->SetString("urlQuery", PrepareUrlForUpload(error.unreachableURL)); | |
| 217 return CreateRequestBody("linkdoctor.fixurl.fixurl", error_param, | |
| 218 correction_params, params.Pass()); | |
| 219 } | |
| 220 | |
| 221 std::string CreateClickTrackingUrlRequestBody( | |
| 222 const blink::WebURLError& error, | |
| 223 const NetErrorHelperCore::NavigationCorrectionParams& correction_params, | |
| 224 const NavigationCorrectionResponse& response, | |
| 225 const NavigationCorrection& correction) { | |
| 226 std::string error_param; | |
| 227 bool result = ShouldUseFixUrlServiceForError(error, &error_param); | |
| 228 DCHECK(result); | |
| 229 | |
| 230 scoped_ptr<base::DictionaryValue> params(new base::DictionaryValue()); | |
| 231 | |
| 232 params->SetString("originalUrlQuery", | |
| 233 PrepareUrlForUpload(error.unreachableURL)); | |
| 234 | |
| 235 params->SetString("clickedUrlCorrection", correction.url_correction); | |
| 236 params->SetString("clickType", correction.click_type); | |
| 237 params->SetString("clickData", correction.click_data); | |
| 238 | |
| 239 params->SetString("eventId", response.event_id); | |
| 240 params->SetString("fingerprint", response.fingerprint); | |
| 241 | |
| 242 return CreateRequestBody("linkdoctor.fixurl.clicktracking", error_param, | |
| 243 correction_params, params.Pass()); | |
| 244 } | |
| 245 | |
| 246 base::string16 FormatURLForDisplay(const GURL& url, bool is_rtl, | |
| 247 const std::string accept_languages) { | |
| 248 // Translate punycode into UTF8, unescape UTF8 URLs. | |
| 249 base::string16 url_for_display(net::FormatUrl( | |
| 250 url, accept_languages, net::kFormatUrlOmitNothing, | |
| 251 net::UnescapeRule::NORMAL, NULL, NULL, NULL)); | |
| 252 // URLs are always LTR. | |
| 253 if (is_rtl) | |
| 254 base::i18n::WrapStringWithLTRFormatting(&url_for_display); | |
| 255 return url_for_display; | |
| 256 } | |
| 257 | |
| 258 scoped_ptr<NavigationCorrectionResponse> ParseNavigationCorrectionResponse( | |
| 259 const std::string raw_response) { | |
| 260 // TODO(mmenke): Open source related protocol buffers and use them directly. | |
| 261 scoped_ptr<base::Value> parsed(base::JSONReader::Read(raw_response)); | |
| 262 scoped_ptr<NavigationCorrectionResponse> response( | |
| 263 new NavigationCorrectionResponse()); | |
| 264 base::JSONValueConverter<NavigationCorrectionResponse> converter; | |
| 265 if (!parsed || !converter.Convert(*parsed, response.get())) | |
| 266 response.reset(); | |
| 267 return response.Pass(); | |
| 268 } | |
| 269 | |
| 270 scoped_ptr<LocalizedError::ErrorPageParams> CreateErrorPageParams( | |
| 271 const NavigationCorrectionResponse& response, | |
| 272 const blink::WebURLError& error, | |
| 273 const NetErrorHelperCore::NavigationCorrectionParams& correction_params, | |
| 274 const std::string& accept_languages, | |
| 275 bool is_rtl) { | |
| 276 // Version of URL for display in suggestions. It has to be sanitized first | |
| 277 // because any received suggestions will be relative to the sanitized URL. | |
| 278 base::string16 original_url_for_display = | |
| 279 FormatURLForDisplay(SanitizeURL(GURL(error.unreachableURL)), is_rtl, | |
| 280 accept_languages); | |
| 281 | |
| 282 scoped_ptr<LocalizedError::ErrorPageParams> params( | |
| 283 new LocalizedError::ErrorPageParams()); | |
| 284 params->override_suggestions.reset(new base::ListValue()); | |
| 285 scoped_ptr<base::ListValue> parsed_corrections(new base::ListValue()); | |
| 286 for (ScopedVector<NavigationCorrection>::const_iterator it = | |
| 287 response.corrections.begin(); | |
| 288 it != response.corrections.end(); ++it) { | |
| 289 // Doesn't seem like a good idea to show these. | |
| 290 if ((*it)->is_porn || (*it)->is_soft_porn) | |
| 291 continue; | |
| 292 | |
| 293 int tracking_id = it - response.corrections.begin(); | |
| 294 | |
| 295 if ((*it)->correction_type == "reloadPage") { | |
| 296 params->suggest_reload = true; | |
| 297 params->reload_tracking_id = tracking_id; | |
| 298 continue; | |
| 299 } | |
| 300 | |
| 301 if ((*it)->correction_type == "webSearchQuery") { | |
| 302 // If there are mutliple searches suggested, use the first suggestion. | |
| 303 if (params->search_terms.empty()) { | |
| 304 params->search_url = correction_params.search_url; | |
| 305 params->search_terms = (*it)->url_correction; | |
| 306 params->search_tracking_id = tracking_id; | |
| 307 } | |
| 308 continue; | |
| 309 } | |
| 310 | |
| 311 // Allow reload page and web search query to be empty strings, but not | |
| 312 // links. | |
| 313 if ((*it)->url_correction.empty()) | |
| 314 continue; | |
| 315 size_t correction_index; | |
| 316 for (correction_index = 0; | |
| 317 correction_index < arraysize(kCorrectionResourceTable); | |
| 318 ++correction_index) { | |
| 319 if ((*it)->correction_type != | |
| 320 kCorrectionResourceTable[correction_index].correction_type) { | |
| 321 continue; | |
| 322 } | |
| 323 base::DictionaryValue* suggest = new base::DictionaryValue(); | |
| 324 suggest->SetString("header", | |
| 325 l10n_util::GetStringUTF16( | |
| 326 kCorrectionResourceTable[correction_index].resource_id)); | |
| 327 suggest->SetString("urlCorrection", (*it)->url_correction); | |
| 328 suggest->SetString( | |
| 329 "urlCorrectionForDisplay", | |
| 330 FormatURLForDisplay(GURL((*it)->url_correction), is_rtl, | |
| 331 accept_languages)); | |
| 332 suggest->SetString("originalUrlForDisplay", original_url_for_display); | |
| 333 suggest->SetInteger("trackingId", tracking_id); | |
| 334 params->override_suggestions->Append(suggest); | |
| 335 break; | |
| 336 } | |
| 337 } | |
| 338 | |
| 339 if (params->override_suggestions->empty() && !params->search_url.is_valid()) | |
| 340 params.reset(); | |
| 341 return params.Pass(); | |
| 342 } | |
| 343 | |
| 344 void ReportAutoReloadSuccess(const blink::WebURLError& error, size_t count) { | |
| 345 if (error.domain.utf8() != net::kErrorDomain) | |
| 346 return; | |
| 347 UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtSuccess", | |
| 348 -error.reason, | |
| 349 net::GetAllErrorCodesForUma()); | |
| 350 UMA_HISTOGRAM_COUNTS("Net.AutoReload.CountAtSuccess", count); | |
| 351 if (count == 1) { | |
| 352 UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtFirstSuccess", | |
| 353 -error.reason, | |
| 354 net::GetAllErrorCodesForUma()); | |
| 355 } | |
| 356 } | |
| 357 | |
| 358 void ReportAutoReloadFailure(const blink::WebURLError& error, size_t count) { | |
| 359 if (error.domain.utf8() != net::kErrorDomain) | |
| 360 return; | |
| 361 UMA_HISTOGRAM_CUSTOM_ENUMERATION("Net.AutoReload.ErrorAtStop", | |
| 362 -error.reason, | |
| 363 net::GetAllErrorCodesForUma()); | |
| 364 UMA_HISTOGRAM_COUNTS("Net.AutoReload.CountAtStop", count); | |
| 365 } | |
| 366 | |
| 367 } // namespace | |
| 368 | |
| 369 struct NetErrorHelperCore::ErrorPageInfo { | |
| 370 ErrorPageInfo(blink::WebURLError error, bool was_failed_post) | |
| 371 : error(error), | |
| 372 was_failed_post(was_failed_post), | |
| 373 needs_dns_updates(false), | |
| 374 needs_load_navigation_corrections(false), | |
| 375 reload_button_in_page(false), | |
| 376 load_stale_button_in_page(false), | |
| 377 is_finished_loading(false), | |
| 378 auto_reload_triggered(false) { | |
| 379 } | |
| 380 | |
| 381 // Information about the failed page load. | |
| 382 blink::WebURLError error; | |
| 383 bool was_failed_post; | |
| 384 | |
| 385 // Information about the status of the error page. | |
| 386 | |
| 387 // True if a page is a DNS error page and has not yet received a final DNS | |
| 388 // probe status. | |
| 389 bool needs_dns_updates; | |
| 390 | |
| 391 // True if a blank page was loaded, and navigation corrections need to be | |
| 392 // loaded to generate the real error page. | |
| 393 bool needs_load_navigation_corrections; | |
| 394 | |
| 395 // Navigation correction service paramers, which will be used in response to | |
| 396 // certain types of network errors. They are all stored here in case they | |
| 397 // change over the course of displaying the error page. | |
| 398 scoped_ptr<NetErrorHelperCore::NavigationCorrectionParams> | |
| 399 navigation_correction_params; | |
| 400 | |
| 401 scoped_ptr<NavigationCorrectionResponse> navigation_correction_response; | |
| 402 | |
| 403 // All the navigation corrections that have been clicked, for tracking | |
| 404 // purposes. | |
| 405 std::set<int> clicked_corrections; | |
| 406 | |
| 407 // Track if specific buttons are included in an error page, for statistics. | |
| 408 bool reload_button_in_page; | |
| 409 bool load_stale_button_in_page; | |
| 410 | |
| 411 // True if a page has completed loading, at which point it can receive | |
| 412 // updates. | |
| 413 bool is_finished_loading; | |
| 414 | |
| 415 // True if the auto-reload timer has fired and a reload is or has been in | |
| 416 // flight. | |
| 417 bool auto_reload_triggered; | |
| 418 }; | |
| 419 | |
| 420 NetErrorHelperCore::NavigationCorrectionParams::NavigationCorrectionParams() { | |
| 421 } | |
| 422 | |
| 423 NetErrorHelperCore::NavigationCorrectionParams::~NavigationCorrectionParams() { | |
| 424 } | |
| 425 | |
| 426 bool NetErrorHelperCore::IsReloadableError( | |
| 427 const NetErrorHelperCore::ErrorPageInfo& info) { | |
| 428 return info.error.domain.utf8() == net::kErrorDomain && | |
| 429 info.error.reason != net::ERR_ABORTED && | |
| 430 !info.was_failed_post; | |
| 431 } | |
| 432 | |
| 433 NetErrorHelperCore::NetErrorHelperCore(Delegate* delegate, | |
| 434 bool auto_reload_enabled, | |
| 435 bool auto_reload_visible_only, | |
| 436 bool is_visible) | |
| 437 : delegate_(delegate), | |
| 438 last_probe_status_(chrome_common_net::DNS_PROBE_POSSIBLE), | |
| 439 auto_reload_enabled_(auto_reload_enabled), | |
| 440 auto_reload_visible_only_(auto_reload_visible_only), | |
| 441 auto_reload_timer_(new base::Timer(false, false)), | |
| 442 auto_reload_paused_(false), | |
| 443 uncommitted_load_started_(false), | |
| 444 // TODO(ellyjones): Make online_ accurate at object creation. | |
| 445 online_(true), | |
| 446 visible_(is_visible), | |
| 447 auto_reload_count_(0), | |
| 448 navigation_from_button_(NO_BUTTON) { | |
| 449 } | |
| 450 | |
| 451 NetErrorHelperCore::~NetErrorHelperCore() { | |
| 452 if (committed_error_page_info_ && | |
| 453 committed_error_page_info_->auto_reload_triggered) { | |
| 454 ReportAutoReloadFailure(committed_error_page_info_->error, | |
| 455 auto_reload_count_); | |
| 456 } | |
| 457 } | |
| 458 | |
| 459 void NetErrorHelperCore::CancelPendingFetches() { | |
| 460 // Cancel loading the alternate error page, and prevent any pending error page | |
| 461 // load from starting a new error page load. Swapping in the error page when | |
| 462 // it's finished loading could abort the navigation, otherwise. | |
| 463 if (committed_error_page_info_) | |
| 464 committed_error_page_info_->needs_load_navigation_corrections = false; | |
| 465 if (pending_error_page_info_) | |
| 466 pending_error_page_info_->needs_load_navigation_corrections = false; | |
| 467 delegate_->CancelFetchNavigationCorrections(); | |
| 468 auto_reload_timer_->Stop(); | |
| 469 auto_reload_paused_ = false; | |
| 470 } | |
| 471 | |
| 472 void NetErrorHelperCore::OnStop() { | |
| 473 if (committed_error_page_info_ && | |
| 474 committed_error_page_info_->auto_reload_triggered) { | |
| 475 ReportAutoReloadFailure(committed_error_page_info_->error, | |
| 476 auto_reload_count_); | |
| 477 } | |
| 478 CancelPendingFetches(); | |
| 479 uncommitted_load_started_ = false; | |
| 480 auto_reload_count_ = 0; | |
| 481 } | |
| 482 | |
| 483 void NetErrorHelperCore::OnWasShown() { | |
| 484 visible_ = true; | |
| 485 if (!auto_reload_visible_only_) | |
| 486 return; | |
| 487 if (auto_reload_paused_) | |
| 488 MaybeStartAutoReloadTimer(); | |
| 489 } | |
| 490 | |
| 491 void NetErrorHelperCore::OnWasHidden() { | |
| 492 visible_ = false; | |
| 493 if (!auto_reload_visible_only_) | |
| 494 return; | |
| 495 PauseAutoReloadTimer(); | |
| 496 } | |
| 497 | |
| 498 void NetErrorHelperCore::OnStartLoad(FrameType frame_type, PageType page_type) { | |
| 499 if (frame_type != MAIN_FRAME) | |
| 500 return; | |
| 501 | |
| 502 uncommitted_load_started_ = true; | |
| 503 | |
| 504 // If there's no pending error page information associated with the page load, | |
| 505 // or the new page is not an error page, then reset pending error page state. | |
| 506 if (!pending_error_page_info_ || page_type != ERROR_PAGE) | |
| 507 CancelPendingFetches(); | |
| 508 } | |
| 509 | |
| 510 void NetErrorHelperCore::OnCommitLoad(FrameType frame_type, const GURL& url) { | |
| 511 if (frame_type != MAIN_FRAME) | |
| 512 return; | |
| 513 | |
| 514 // uncommitted_load_started_ could already be false, since RenderFrameImpl | |
| 515 // calls OnCommitLoad once for each in-page navigation (like a fragment | |
| 516 // change) with no corresponding OnStartLoad. | |
| 517 uncommitted_load_started_ = false; | |
| 518 | |
| 519 // Track if an error occurred due to a page button press. | |
| 520 // This isn't perfect; if (for instance), the server is slow responding | |
| 521 // to a request generated from the page reload button, and the user hits | |
| 522 // the browser reload button, this code will still believe the | |
| 523 // result is from the page reload button. | |
| 524 if (committed_error_page_info_ && pending_error_page_info_ && | |
| 525 navigation_from_button_ != NO_BUTTON && | |
| 526 committed_error_page_info_->error.unreachableURL == | |
| 527 pending_error_page_info_->error.unreachableURL) { | |
| 528 DCHECK(navigation_from_button_ == RELOAD_BUTTON || | |
| 529 navigation_from_button_ == LOAD_STALE_BUTTON); | |
| 530 chrome_common_net::RecordEvent( | |
| 531 navigation_from_button_ == RELOAD_BUTTON ? | |
| 532 chrome_common_net::NETWORK_ERROR_PAGE_RELOAD_BUTTON_ERROR : | |
| 533 chrome_common_net::NETWORK_ERROR_PAGE_LOAD_STALE_BUTTON_ERROR); | |
| 534 } | |
| 535 navigation_from_button_ = NO_BUTTON; | |
| 536 | |
| 537 if (committed_error_page_info_ && !pending_error_page_info_ && | |
| 538 committed_error_page_info_->auto_reload_triggered) { | |
| 539 const blink::WebURLError& error = committed_error_page_info_->error; | |
| 540 const GURL& error_url = error.unreachableURL; | |
| 541 if (url == error_url) | |
| 542 ReportAutoReloadSuccess(error, auto_reload_count_); | |
| 543 else if (url != GURL(content::kUnreachableWebDataURL)) | |
| 544 ReportAutoReloadFailure(error, auto_reload_count_); | |
| 545 } | |
| 546 | |
| 547 committed_error_page_info_.reset(pending_error_page_info_.release()); | |
| 548 } | |
| 549 | |
| 550 void NetErrorHelperCore::OnFinishLoad(FrameType frame_type) { | |
| 551 if (frame_type != MAIN_FRAME) | |
| 552 return; | |
| 553 | |
| 554 if (!committed_error_page_info_) { | |
| 555 auto_reload_count_ = 0; | |
| 556 return; | |
| 557 } | |
| 558 | |
| 559 committed_error_page_info_->is_finished_loading = true; | |
| 560 | |
| 561 chrome_common_net::RecordEvent(chrome_common_net::NETWORK_ERROR_PAGE_SHOWN); | |
| 562 if (committed_error_page_info_->reload_button_in_page) { | |
| 563 chrome_common_net::RecordEvent( | |
| 564 chrome_common_net::NETWORK_ERROR_PAGE_RELOAD_BUTTON_SHOWN); | |
| 565 } | |
| 566 if (committed_error_page_info_->load_stale_button_in_page) { | |
| 567 chrome_common_net::RecordEvent( | |
| 568 chrome_common_net::NETWORK_ERROR_PAGE_LOAD_STALE_BUTTON_SHOWN); | |
| 569 } | |
| 570 | |
| 571 delegate_->EnablePageHelperFunctions(); | |
| 572 | |
| 573 if (committed_error_page_info_->needs_load_navigation_corrections) { | |
| 574 // If there is another pending error page load, |fix_url| should have been | |
| 575 // cleared. | |
| 576 DCHECK(!pending_error_page_info_); | |
| 577 DCHECK(!committed_error_page_info_->needs_dns_updates); | |
| 578 delegate_->FetchNavigationCorrections( | |
| 579 committed_error_page_info_->navigation_correction_params->url, | |
| 580 CreateFixUrlRequestBody( | |
| 581 committed_error_page_info_->error, | |
| 582 *committed_error_page_info_->navigation_correction_params)); | |
| 583 } else if (auto_reload_enabled_ && | |
| 584 IsReloadableError(*committed_error_page_info_)) { | |
| 585 MaybeStartAutoReloadTimer(); | |
| 586 } | |
| 587 | |
| 588 if (!committed_error_page_info_->needs_dns_updates || | |
| 589 last_probe_status_ == chrome_common_net::DNS_PROBE_POSSIBLE) { | |
| 590 return; | |
| 591 } | |
| 592 DVLOG(1) << "Error page finished loading; sending saved status."; | |
| 593 UpdateErrorPage(); | |
| 594 } | |
| 595 | |
| 596 void NetErrorHelperCore::GetErrorHTML( | |
| 597 FrameType frame_type, | |
| 598 const blink::WebURLError& error, | |
| 599 bool is_failed_post, | |
| 600 std::string* error_html) { | |
| 601 if (frame_type == MAIN_FRAME) { | |
| 602 // If navigation corrections were needed before, that should have been | |
| 603 // cancelled earlier by starting a new page load (Which has now failed). | |
| 604 DCHECK(!committed_error_page_info_ || | |
| 605 !committed_error_page_info_->needs_load_navigation_corrections); | |
| 606 | |
| 607 pending_error_page_info_.reset(new ErrorPageInfo(error, is_failed_post)); | |
| 608 pending_error_page_info_->navigation_correction_params.reset( | |
| 609 new NavigationCorrectionParams(navigation_correction_params_)); | |
| 610 GetErrorHtmlForMainFrame(pending_error_page_info_.get(), error_html); | |
| 611 } else { | |
| 612 // These values do not matter, as error pages in iframes hide the buttons. | |
| 613 bool reload_button_in_page; | |
| 614 bool load_stale_button_in_page; | |
| 615 | |
| 616 delegate_->GenerateLocalizedErrorPage( | |
| 617 error, is_failed_post, scoped_ptr<LocalizedError::ErrorPageParams>(), | |
| 618 &reload_button_in_page, &load_stale_button_in_page, | |
| 619 error_html); | |
| 620 } | |
| 621 } | |
| 622 | |
| 623 void NetErrorHelperCore::OnNetErrorInfo( | |
| 624 chrome_common_net::DnsProbeStatus status) { | |
| 625 DCHECK_NE(chrome_common_net::DNS_PROBE_POSSIBLE, status); | |
| 626 | |
| 627 last_probe_status_ = status; | |
| 628 | |
| 629 if (!committed_error_page_info_ || | |
| 630 !committed_error_page_info_->needs_dns_updates || | |
| 631 !committed_error_page_info_->is_finished_loading) { | |
| 632 return; | |
| 633 } | |
| 634 | |
| 635 UpdateErrorPage(); | |
| 636 } | |
| 637 | |
| 638 void NetErrorHelperCore::OnSetNavigationCorrectionInfo( | |
| 639 const GURL& navigation_correction_url, | |
| 640 const std::string& language, | |
| 641 const std::string& country_code, | |
| 642 const std::string& api_key, | |
| 643 const GURL& search_url) { | |
| 644 navigation_correction_params_.url = navigation_correction_url; | |
| 645 navigation_correction_params_.language = language; | |
| 646 navigation_correction_params_.country_code = country_code; | |
| 647 navigation_correction_params_.api_key = api_key; | |
| 648 navigation_correction_params_.search_url = search_url; | |
| 649 } | |
| 650 | |
| 651 void NetErrorHelperCore::GetErrorHtmlForMainFrame( | |
| 652 ErrorPageInfo* pending_error_page_info, | |
| 653 std::string* error_html) { | |
| 654 std::string error_param; | |
| 655 blink::WebURLError error = pending_error_page_info->error; | |
| 656 | |
| 657 if (pending_error_page_info->navigation_correction_params && | |
| 658 pending_error_page_info->navigation_correction_params->url.is_valid() && | |
| 659 ShouldUseFixUrlServiceForError(error, &error_param)) { | |
| 660 pending_error_page_info->needs_load_navigation_corrections = true; | |
| 661 return; | |
| 662 } | |
| 663 | |
| 664 if (IsDnsError(pending_error_page_info->error)) { | |
| 665 // The last probe status needs to be reset if this is a DNS error. This | |
| 666 // means that if a DNS error page is committed but has not yet finished | |
| 667 // loading, a DNS probe status scheduled to be sent to it may be thrown | |
| 668 // out, but since the new error page should trigger a new DNS probe, it | |
| 669 // will just get the results for the next page load. | |
| 670 last_probe_status_ = chrome_common_net::DNS_PROBE_POSSIBLE; | |
| 671 pending_error_page_info->needs_dns_updates = true; | |
| 672 error = GetUpdatedError(error); | |
| 673 } | |
| 674 | |
| 675 delegate_->GenerateLocalizedErrorPage( | |
| 676 error, pending_error_page_info->was_failed_post, | |
| 677 scoped_ptr<LocalizedError::ErrorPageParams>(), | |
| 678 &pending_error_page_info->reload_button_in_page, | |
| 679 &pending_error_page_info->load_stale_button_in_page, | |
| 680 error_html); | |
| 681 } | |
| 682 | |
| 683 void NetErrorHelperCore::UpdateErrorPage() { | |
| 684 DCHECK(committed_error_page_info_->needs_dns_updates); | |
| 685 DCHECK(committed_error_page_info_->is_finished_loading); | |
| 686 DCHECK_NE(chrome_common_net::DNS_PROBE_POSSIBLE, last_probe_status_); | |
| 687 | |
| 688 UMA_HISTOGRAM_ENUMERATION("DnsProbe.ErrorPageUpdateStatus", | |
| 689 last_probe_status_, | |
| 690 chrome_common_net::DNS_PROBE_MAX); | |
| 691 // Every status other than DNS_PROBE_POSSIBLE and DNS_PROBE_STARTED is a | |
| 692 // final status code. Once one is reached, the page does not need further | |
| 693 // updates. | |
| 694 if (last_probe_status_ != chrome_common_net::DNS_PROBE_STARTED) | |
| 695 committed_error_page_info_->needs_dns_updates = false; | |
| 696 | |
| 697 // There is no need to worry about the button display statistics here because | |
| 698 // the presentation of the reload and load stale buttons can't be changed | |
| 699 // by a DNS error update. | |
| 700 delegate_->UpdateErrorPage( | |
| 701 GetUpdatedError(committed_error_page_info_->error), | |
| 702 committed_error_page_info_->was_failed_post); | |
| 703 } | |
| 704 | |
| 705 void NetErrorHelperCore::OnNavigationCorrectionsFetched( | |
| 706 const std::string& corrections, | |
| 707 const std::string& accept_languages, | |
| 708 bool is_rtl) { | |
| 709 // Loading suggestions only starts when a blank error page finishes loading, | |
| 710 // and is cancelled with a new load. | |
| 711 DCHECK(!pending_error_page_info_); | |
| 712 DCHECK(committed_error_page_info_->is_finished_loading); | |
| 713 DCHECK(committed_error_page_info_->needs_load_navigation_corrections); | |
| 714 DCHECK(committed_error_page_info_->navigation_correction_params); | |
| 715 | |
| 716 pending_error_page_info_.reset( | |
| 717 new ErrorPageInfo(committed_error_page_info_->error, | |
| 718 committed_error_page_info_->was_failed_post)); | |
| 719 pending_error_page_info_->navigation_correction_response = | |
| 720 ParseNavigationCorrectionResponse(corrections); | |
| 721 | |
| 722 std::string error_html; | |
| 723 scoped_ptr<LocalizedError::ErrorPageParams> params; | |
| 724 if (pending_error_page_info_->navigation_correction_response) { | |
| 725 // Copy navigation correction parameters used for the request, so tracking | |
| 726 // requests can still be sent if the configuration changes. | |
| 727 pending_error_page_info_->navigation_correction_params.reset( | |
| 728 new NavigationCorrectionParams( | |
| 729 *committed_error_page_info_->navigation_correction_params)); | |
| 730 params = CreateErrorPageParams( | |
| 731 *pending_error_page_info_->navigation_correction_response, | |
| 732 pending_error_page_info_->error, | |
| 733 *pending_error_page_info_->navigation_correction_params, | |
| 734 accept_languages, is_rtl); | |
| 735 delegate_->GenerateLocalizedErrorPage( | |
| 736 pending_error_page_info_->error, | |
| 737 pending_error_page_info_->was_failed_post, | |
| 738 params.Pass(), | |
| 739 &pending_error_page_info_->reload_button_in_page, | |
| 740 &pending_error_page_info_->load_stale_button_in_page, | |
| 741 &error_html); | |
| 742 } else { | |
| 743 // Since |navigation_correction_params| in |pending_error_page_info_| is | |
| 744 // NULL, this won't trigger another attempt to load corrections. | |
| 745 GetErrorHtmlForMainFrame(pending_error_page_info_.get(), &error_html); | |
| 746 } | |
| 747 | |
| 748 // TODO(mmenke): Once the new API is in place, look into replacing this | |
| 749 // double page load by just updating the error page, like DNS | |
| 750 // probes do. | |
| 751 delegate_->LoadErrorPageInMainFrame( | |
| 752 error_html, | |
| 753 pending_error_page_info_->error.unreachableURL); | |
| 754 } | |
| 755 | |
| 756 blink::WebURLError NetErrorHelperCore::GetUpdatedError( | |
| 757 const blink::WebURLError& error) const { | |
| 758 // If a probe didn't run or wasn't conclusive, restore the original error. | |
| 759 if (last_probe_status_ == chrome_common_net::DNS_PROBE_NOT_RUN || | |
| 760 last_probe_status_ == | |
| 761 chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE) { | |
| 762 return error; | |
| 763 } | |
| 764 | |
| 765 blink::WebURLError updated_error; | |
| 766 updated_error.domain = blink::WebString::fromUTF8( | |
| 767 chrome_common_net::kDnsProbeErrorDomain); | |
| 768 updated_error.reason = last_probe_status_; | |
| 769 updated_error.unreachableURL = error.unreachableURL; | |
| 770 updated_error.staleCopyInCache = error.staleCopyInCache; | |
| 771 | |
| 772 return updated_error; | |
| 773 } | |
| 774 | |
| 775 void NetErrorHelperCore::Reload() { | |
| 776 if (!committed_error_page_info_) { | |
| 777 return; | |
| 778 } | |
| 779 delegate_->ReloadPage(); | |
| 780 } | |
| 781 | |
| 782 bool NetErrorHelperCore::MaybeStartAutoReloadTimer() { | |
| 783 if (!committed_error_page_info_ || | |
| 784 !committed_error_page_info_->is_finished_loading || | |
| 785 pending_error_page_info_ || | |
| 786 uncommitted_load_started_) { | |
| 787 return false; | |
| 788 } | |
| 789 | |
| 790 StartAutoReloadTimer(); | |
| 791 return true; | |
| 792 } | |
| 793 | |
| 794 void NetErrorHelperCore::StartAutoReloadTimer() { | |
| 795 DCHECK(committed_error_page_info_); | |
| 796 DCHECK(IsReloadableError(*committed_error_page_info_)); | |
| 797 | |
| 798 committed_error_page_info_->auto_reload_triggered = true; | |
| 799 | |
| 800 if (!online_ || (!visible_ && auto_reload_visible_only_)) { | |
| 801 auto_reload_paused_ = true; | |
| 802 return; | |
| 803 } | |
| 804 | |
| 805 auto_reload_paused_ = false; | |
| 806 base::TimeDelta delay = GetAutoReloadTime(auto_reload_count_); | |
| 807 auto_reload_timer_->Stop(); | |
| 808 auto_reload_timer_->Start(FROM_HERE, delay, | |
| 809 base::Bind(&NetErrorHelperCore::AutoReloadTimerFired, | |
| 810 base::Unretained(this))); | |
| 811 } | |
| 812 | |
| 813 void NetErrorHelperCore::AutoReloadTimerFired() { | |
| 814 auto_reload_count_++; | |
| 815 Reload(); | |
| 816 } | |
| 817 | |
| 818 void NetErrorHelperCore::PauseAutoReloadTimer() { | |
| 819 if (!auto_reload_timer_->IsRunning()) | |
| 820 return; | |
| 821 DCHECK(committed_error_page_info_); | |
| 822 DCHECK(!auto_reload_paused_); | |
| 823 DCHECK(committed_error_page_info_->auto_reload_triggered); | |
| 824 auto_reload_timer_->Stop(); | |
| 825 auto_reload_paused_ = true; | |
| 826 } | |
| 827 | |
| 828 void NetErrorHelperCore::NetworkStateChanged(bool online) { | |
| 829 bool was_online = online_; | |
| 830 online_ = online; | |
| 831 if (!was_online && online) { | |
| 832 // Transitioning offline -> online | |
| 833 if (auto_reload_paused_) | |
| 834 MaybeStartAutoReloadTimer(); | |
| 835 } else if (was_online && !online) { | |
| 836 // Transitioning online -> offline | |
| 837 if (auto_reload_timer_->IsRunning()) | |
| 838 auto_reload_count_ = 0; | |
| 839 PauseAutoReloadTimer(); | |
| 840 } | |
| 841 } | |
| 842 | |
| 843 bool NetErrorHelperCore::ShouldSuppressErrorPage(FrameType frame_type, | |
| 844 const GURL& url) { | |
| 845 // Don't suppress child frame errors. | |
| 846 if (frame_type != MAIN_FRAME) | |
| 847 return false; | |
| 848 | |
| 849 if (!auto_reload_enabled_) | |
| 850 return false; | |
| 851 | |
| 852 // If there's no committed error page, this error page wasn't from an auto | |
| 853 // reload. | |
| 854 if (!committed_error_page_info_) | |
| 855 return false; | |
| 856 | |
| 857 // If the error page wasn't reloadable, display it. | |
| 858 if (!IsReloadableError(*committed_error_page_info_)) | |
| 859 return false; | |
| 860 | |
| 861 // If |auto_reload_timer_| is still running or is paused, this error page | |
| 862 // isn't from an auto reload. | |
| 863 if (auto_reload_timer_->IsRunning() || auto_reload_paused_) | |
| 864 return false; | |
| 865 | |
| 866 // If the error page was reloadable, and the timer isn't running or paused, an | |
| 867 // auto-reload has already been triggered. | |
| 868 DCHECK(committed_error_page_info_->auto_reload_triggered); | |
| 869 | |
| 870 GURL error_url = committed_error_page_info_->error.unreachableURL; | |
| 871 // TODO(ellyjones): also plumb the error code down to CCRC and check that | |
| 872 if (error_url != url) | |
| 873 return false; | |
| 874 | |
| 875 // Suppressed an error-page load; the previous uncommitted load was the error | |
| 876 // page load starting, so forget about it. | |
| 877 uncommitted_load_started_ = false; | |
| 878 | |
| 879 // The first iteration of the timer is started by OnFinishLoad calling | |
| 880 // MaybeStartAutoReloadTimer, but since error pages for subsequent loads are | |
| 881 // suppressed in this function, subsequent iterations of the timer have to be | |
| 882 // started here. | |
| 883 MaybeStartAutoReloadTimer(); | |
| 884 return true; | |
| 885 } | |
| 886 | |
| 887 void NetErrorHelperCore::ExecuteButtonPress(Button button) { | |
| 888 switch (button) { | |
| 889 case RELOAD_BUTTON: | |
| 890 chrome_common_net::RecordEvent( | |
| 891 chrome_common_net::NETWORK_ERROR_PAGE_RELOAD_BUTTON_CLICKED); | |
| 892 navigation_from_button_ = RELOAD_BUTTON; | |
| 893 Reload(); | |
| 894 return; | |
| 895 case LOAD_STALE_BUTTON: | |
| 896 chrome_common_net::RecordEvent( | |
| 897 chrome_common_net::NETWORK_ERROR_PAGE_LOAD_STALE_BUTTON_CLICKED); | |
| 898 navigation_from_button_ = LOAD_STALE_BUTTON; | |
| 899 delegate_->LoadPageFromCache( | |
| 900 committed_error_page_info_->error.unreachableURL); | |
| 901 return; | |
| 902 case MORE_BUTTON: | |
| 903 // Visual effects on page are handled in Javascript code. | |
| 904 chrome_common_net::RecordEvent( | |
| 905 chrome_common_net::NETWORK_ERROR_PAGE_MORE_BUTTON_CLICKED); | |
| 906 return; | |
| 907 case NO_BUTTON: | |
| 908 NOTREACHED(); | |
| 909 return; | |
| 910 } | |
| 911 } | |
| 912 | |
| 913 void NetErrorHelperCore::TrackClick(int tracking_id) { | |
| 914 // It's technically possible for |navigation_correction_params| to be NULL but | |
| 915 // for |navigation_correction_response| not to be NULL, if the paramters | |
| 916 // changed between loading the original error page and loading the error page | |
| 917 if (!committed_error_page_info_ || | |
| 918 !committed_error_page_info_->navigation_correction_response) { | |
| 919 return; | |
| 920 } | |
| 921 | |
| 922 NavigationCorrectionResponse* response = | |
| 923 committed_error_page_info_->navigation_correction_response.get(); | |
| 924 | |
| 925 // |tracking_id| is less than 0 when the error page was not generated by the | |
| 926 // navigation correction service. |tracking_id| should never be greater than | |
| 927 // the array size, but best to be safe, since it contains data from a remote | |
| 928 // site, though none of that data should make it into Javascript callbacks. | |
| 929 if (tracking_id < 0 || | |
| 930 static_cast<size_t>(tracking_id) >= response->corrections.size()) { | |
| 931 return; | |
| 932 } | |
| 933 | |
| 934 // Only report a clicked link once. | |
| 935 if (committed_error_page_info_->clicked_corrections.count(tracking_id)) | |
| 936 return; | |
| 937 | |
| 938 committed_error_page_info_->clicked_corrections.insert(tracking_id); | |
| 939 std::string request_body = CreateClickTrackingUrlRequestBody( | |
| 940 committed_error_page_info_->error, | |
| 941 *committed_error_page_info_->navigation_correction_params, | |
| 942 *response, | |
| 943 *response->corrections[tracking_id]); | |
| 944 delegate_->SendTrackingRequest( | |
| 945 committed_error_page_info_->navigation_correction_params->url, | |
| 946 request_body); | |
| 947 } | |
| 948 | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 570253002:
Componentize NetErrorHelperCore (Closed)
Base URL: https://chromium.googlesource.com/chromium/src.git@master