Home | History | Annotate | Download | only in net 
      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 
    949