Three way experiment for "Show saved copy" button.

components/error_page/renderer/net_error_helper_core.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/error_page/renderer/net_error_helper_core.h"
 
 #include <set>
 #include <string>
 #include <vector>
 
@@ skipping 359 matching lines @@
 
 }  // namespace
 
 struct NetErrorHelperCore::ErrorPageInfo {
   ErrorPageInfo(blink::WebURLError error, bool was_failed_post)
       : error(error),
         was_failed_post(was_failed_post),
         needs_dns_updates(false),
         needs_load_navigation_corrections(false),
         reload_button_in_page(false),
-        load_stale_button_in_page(false),
+        show_saved_copy_button_in_page(false),
         is_finished_loading(false),
         auto_reload_triggered(false) {
   }
 
   // Information about the failed page load.
   blink::WebURLError error;
   bool was_failed_post;
 
   // Information about the status of the error page.
 
@@ skipping 12 matching lines @@
       navigation_correction_params;
 
   scoped_ptr<NavigationCorrectionResponse> navigation_correction_response;
 
   // All the navigation corrections that have been clicked, for tracking
   // purposes.
   std::set<int> clicked_corrections;
 
   // Track if specific buttons are included in an error page, for statistics.
   bool reload_button_in_page;
-  bool load_stale_button_in_page;
+  bool show_saved_copy_button_in_page;
 
   // True if a page has completed loading, at which point it can receive
   // updates.
   bool is_finished_loading;
 
   // True if the auto-reload timer has fired and a reload is or has been in
   // flight.
   bool auto_reload_triggered;
 };
 
@@ skipping 116 matching lines @@
   // Track if an error occurred due to a page button press.
   // This isn't perfect; if (for instance), the server is slow responding
   // to a request generated from the page reload button, and the user hits
   // the browser reload button, this code will still believe the
   // 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) {
     DCHECK(navigation_from_button_ == RELOAD_BUTTON ||
-           navigation_from_button_ == LOAD_STALE_BUTTON);
+           navigation_from_button_ == SHOW_SAVED_COPY_BUTTON);
     chrome_common_net::RecordEvent(
         navigation_from_button_ == RELOAD_BUTTON ?
             chrome_common_net::NETWORK_ERROR_PAGE_RELOAD_BUTTON_ERROR :
-            chrome_common_net::NETWORK_ERROR_PAGE_LOAD_STALE_BUTTON_ERROR);
+            chrome_common_net::NETWORK_ERROR_PAGE_SHOW_SAVED_COPY_BUTTON_ERROR);
   }
   navigation_from_button_ = NO_BUTTON;
 
   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;
     if (url == error_url)
       ReportAutoReloadSuccess(error, auto_reload_count_);
     else if (url != GURL(content::kUnreachableWebDataURL))
@@ skipping 12 matching lines @@
     return;
   }
 
   committed_error_page_info_->is_finished_loading = true;
 
   chrome_common_net::RecordEvent(chrome_common_net::NETWORK_ERROR_PAGE_SHOWN);
   if (committed_error_page_info_->reload_button_in_page) {
     chrome_common_net::RecordEvent(
         chrome_common_net::NETWORK_ERROR_PAGE_RELOAD_BUTTON_SHOWN);
   }
-  if (committed_error_page_info_->load_stale_button_in_page) {
+  if (committed_error_page_info_->show_saved_copy_button_in_page) {
     chrome_common_net::RecordEvent(
-        chrome_common_net::NETWORK_ERROR_PAGE_LOAD_STALE_BUTTON_SHOWN);
+        chrome_common_net::NETWORK_ERROR_PAGE_SHOW_SAVED_COPY_BUTTON_SHOWN);
   }
 
   delegate_->EnablePageHelperFunctions();
 
   if (committed_error_page_info_->needs_load_navigation_corrections) {
     // If there is another pending error page load, |fix_url| should have been
     // cleared.
     DCHECK(!pending_error_page_info_);
     DCHECK(!committed_error_page_info_->needs_dns_updates);
     delegate_->FetchNavigationCorrections(
@@ skipping 25 matching lines @@
     DCHECK(!committed_error_page_info_ ||
            !committed_error_page_info_->needs_load_navigation_corrections);
 
     pending_error_page_info_.reset(new ErrorPageInfo(error, is_failed_post));
     pending_error_page_info_->navigation_correction_params.reset(
         new NavigationCorrectionParams(navigation_correction_params_));
     GetErrorHtmlForMainFrame(pending_error_page_info_.get(), error_html);
   } else {
     // These values do not matter, as error pages in iframes hide the buttons.
     bool reload_button_in_page;
-    bool load_stale_button_in_page;
+    bool show_saved_copy_button_in_page;
 
     delegate_->GenerateLocalizedErrorPage(
         error, is_failed_post, scoped_ptr<ErrorPageParams>(),
-        &reload_button_in_page, &load_stale_button_in_page,
+        &reload_button_in_page, &show_saved_copy_button_in_page,
         error_html);
   }
 }
 
 void NetErrorHelperCore::OnNetErrorInfo(
     chrome_common_net::DnsProbeStatus status) {
   DCHECK_NE(chrome_common_net::DNS_PROBE_POSSIBLE, status);
 
   last_probe_status_ = status;
 
@@ skipping 40 matching lines @@
     // will just get the results for the next page load.
     last_probe_status_ = chrome_common_net::DNS_PROBE_POSSIBLE;
     pending_error_page_info->needs_dns_updates = true;
     error = GetUpdatedError(error);
   }
 
   delegate_->GenerateLocalizedErrorPage(
       error, pending_error_page_info->was_failed_post,
       scoped_ptr<ErrorPageParams>(),
       &pending_error_page_info->reload_button_in_page,
-      &pending_error_page_info->load_stale_button_in_page,
+      &pending_error_page_info->show_saved_copy_button_in_page,
       error_html);
 }
 
 void NetErrorHelperCore::UpdateErrorPage() {
   DCHECK(committed_error_page_info_->needs_dns_updates);
   DCHECK(committed_error_page_info_->is_finished_loading);
   DCHECK_NE(chrome_common_net::DNS_PROBE_POSSIBLE, last_probe_status_);
 
   UMA_HISTOGRAM_ENUMERATION("DnsProbe.ErrorPageUpdateStatus",
                             last_probe_status_,
                             chrome_common_net::DNS_PROBE_MAX);
   // Every status other than DNS_PROBE_POSSIBLE and DNS_PROBE_STARTED is a
   // final status code.  Once one is reached, the page does not need further
   // updates.
   if (last_probe_status_ != chrome_common_net::DNS_PROBE_STARTED)
     committed_error_page_info_->needs_dns_updates = false;
 
   // There is no need to worry about the button display statistics here because
-  // the presentation of the reload and load stale buttons can't be changed
+  // the presentation of the reload and show saved copy buttons can't be changed
   // by a DNS error update.
   delegate_->UpdateErrorPage(
       GetUpdatedError(committed_error_page_info_->error),
       committed_error_page_info_->was_failed_post);
 }
 
 void NetErrorHelperCore::OnNavigationCorrectionsFetched(
     const std::string& corrections,
     const std::string& accept_languages,
     bool is_rtl) {
@@ skipping 21 matching lines @@
     params = CreateErrorPageParams(
           *pending_error_page_info_->navigation_correction_response,
           pending_error_page_info_->error,
           *pending_error_page_info_->navigation_correction_params,
           accept_languages, is_rtl);
     delegate_->GenerateLocalizedErrorPage(
         pending_error_page_info_->error,
         pending_error_page_info_->was_failed_post,
         params.Pass(),
         &pending_error_page_info_->reload_button_in_page,
-        &pending_error_page_info_->load_stale_button_in_page,
+        &pending_error_page_info_->show_saved_copy_button_in_page,
         &error_html);
   } else {
     // Since |navigation_correction_params| in |pending_error_page_info_| is
     // NULL, this won't trigger another attempt to load corrections.
     GetErrorHtmlForMainFrame(pending_error_page_info_.get(), &error_html);
   }
 
   // TODO(mmenke):  Once the new API is in place, look into replacing this
   //                double page load by just updating the error page, like DNS
   //                probes do.
@@ skipping 118 matching lines @@
 }
 
 void NetErrorHelperCore::ExecuteButtonPress(Button button) {
   switch (button) {
     case RELOAD_BUTTON:
       chrome_common_net::RecordEvent(
           chrome_common_net::NETWORK_ERROR_PAGE_RELOAD_BUTTON_CLICKED);
       navigation_from_button_ = RELOAD_BUTTON;
       Reload();
       return;
-    case LOAD_STALE_BUTTON:
+    case SHOW_SAVED_COPY_BUTTON:
       chrome_common_net::RecordEvent(
-          chrome_common_net::NETWORK_ERROR_PAGE_LOAD_STALE_BUTTON_CLICKED);
-      navigation_from_button_ = LOAD_STALE_BUTTON;
+          chrome_common_net::NETWORK_ERROR_PAGE_SHOW_SAVED_COPY_BUTTON_CLICKED);
+      navigation_from_button_ = SHOW_SAVED_COPY_BUTTON;
       delegate_->LoadPageFromCache(
           committed_error_page_info_->error.unreachableURL);
       return;
     case MORE_BUTTON:
       // Visual effects on page are handled in Javascript code.
       chrome_common_net::RecordEvent(
           chrome_common_net::NETWORK_ERROR_PAGE_MORE_BUTTON_CLICKED);
       return;
     case NO_BUTTON:
       NOTREACHED();
@@ skipping 31 matching lines @@
       committed_error_page_info_->error,
       *committed_error_page_info_->navigation_correction_params,
       *response,
       *response->corrections[tracking_id]);
   delegate_->SendTrackingRequest(
       committed_error_page_info_->navigation_correction_params->url,
       request_body);
 }
 
 }  // namespace error_page