0

Move DNS functions from net_error_info.h into error_page namespace.

This was a TODO for hashimoto. The rest of the file will be moved into
error_page in a separate CL.

BUG=None
R=mmenke@chromium.org,thestig@chromium.org

Review URL: https://codereview.chromium.org/1277213003

Cr-Commit-Position: refs/heads/master@{#342699}
This commit is contained in:
tfarina
2015-08-10 14:20:14 -07:00
committed by Commit bot
parent 0262e947b4
commit 01832b6414
8 changed files with 63 additions and 72 deletions

@ -76,7 +76,7 @@ DnsProbeStatus EvaluateResults(DnsProbeRunner::Result system_result,
}
void HistogramProbe(DnsProbeStatus status, base::TimeDelta elapsed) {
DCHECK(chrome_common_net::DnsProbeStatusIsFinished(status));
DCHECK(error_page::DnsProbeStatusIsFinished(status));
UMA_HISTOGRAM_ENUMERATION("DnsProbe.ProbeResult", status,
chrome_common_net::DNS_PROBE_MAX);
@ -198,7 +198,7 @@ void DnsProbeService::OnProbeComplete() {
void DnsProbeService::CallCallbacks() {
DCHECK_EQ(STATE_RESULT_CACHED, state_);
DCHECK(chrome_common_net::DnsProbeStatusIsFinished(cached_result_));
DCHECK(error_page::DnsProbeStatusIsFinished(cached_result_));
DCHECK(!pending_callbacks_.empty());
std::vector<ProbeCallback> callbacks;

@ -24,13 +24,13 @@
#include "url/gurl.h"
using chrome_common_net::DnsProbeStatus;
using chrome_common_net::DnsProbeStatusToString;
using content::BrowserContext;
using content::BrowserThread;
using ui::PageTransition;
using content::RenderViewHost;
using content::WebContents;
using content::WebContentsObserver;
using error_page::DnsProbeStatusToString;
using ui::PageTransition;
DEFINE_WEB_CONTENTS_USER_DATA_KEY(chrome_browser_net::NetErrorTabHelper);
@ -101,7 +101,7 @@ void NetErrorTabHelper::DidStartNavigationToPendingEntry(
// Only record reloads.
if (reload_type != content::NavigationController::NO_RELOAD) {
chrome_common_net::RecordEvent(
error_page::RecordEvent(
chrome_common_net::NETWORK_ERROR_PAGE_BROWSER_INITIATED_RELOAD);
}
}
@ -217,7 +217,7 @@ void NetErrorTabHelper::StartDnsProbe() {
void NetErrorTabHelper::OnDnsProbeFinished(DnsProbeStatus result) {
DCHECK_CURRENTLY_ON(BrowserThread::UI);
DCHECK_EQ(chrome_common_net::DNS_PROBE_STARTED, dns_probe_status_);
DCHECK(chrome_common_net::DnsProbeStatusIsFinished(result));
DCHECK(error_page::DnsProbeStatusIsFinished(result));
DVLOG(1) << "Finished DNS probe with result "
<< DnsProbeStatusToString(result) << ".";

@ -473,7 +473,7 @@ const LocalizedErrorMap* LookupErrorMap(const std::string& error_domain,
return FindErrorMapInArray(http_error_options,
arraysize(http_error_options),
error_code);
} else if (error_domain == chrome_common_net::kDnsProbeErrorDomain) {
} else if (error_domain == error_page::kDnsProbeErrorDomain) {
const LocalizedErrorMap* map =
FindErrorMapInArray(dns_probe_error_options,
arraysize(dns_probe_error_options),
@ -503,7 +503,7 @@ const char* GetIconClassForError(const std::string& error_domain,
if ((error_code == net::ERR_INTERNET_DISCONNECTED &&
error_domain == net::kErrorDomain) ||
(error_code == chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET &&
error_domain == chrome_common_net::kDnsProbeErrorDomain))
error_domain == error_page::kDnsProbeErrorDomain))
return "icon-offline";
return "icon-generic";
@ -615,9 +615,9 @@ void LocalizedError::GetStrings(int error_code,
if (error_domain == net::kErrorDomain) {
// Non-internationalized error string, for debugging Chrome itself.
error_string = base::ASCIIToUTF16(net::ErrorToShortString(error_code));
} else if (error_domain == chrome_common_net::kDnsProbeErrorDomain) {
} else if (error_domain == error_page::kDnsProbeErrorDomain) {
std::string ascii_error_string =
chrome_common_net::DnsProbeStatusToString(error_code);
error_page::DnsProbeStatusToString(error_code);
error_string = base::ASCIIToUTF16(ascii_error_string);
} else {
DCHECK_EQ(LocalizedError::kHttpErrorDomain, error_domain);

@ -42,12 +42,12 @@
using base::JSONWriter;
using chrome_common_net::DnsProbeStatus;
using chrome_common_net::DnsProbeStatusToString;
using content::DocumentState;
using content::kUnreachableWebDataURL;
using content::RenderFrame;
using content::RenderFrameObserver;
using content::RenderThread;
using content::kUnreachableWebDataURL;
using error_page::DnsProbeStatusToString;
using error_page::ErrorPageParams;
using error_page::NetErrorHelperCore;

@ -7,40 +7,40 @@
#include "base/logging.h"
#include "base/metrics/histogram_macros.h"
namespace chrome_common_net {
namespace error_page {
const char kDnsProbeErrorDomain[] = "dnsprobe";
const char* DnsProbeStatusToString(int status) {
switch (status) {
case DNS_PROBE_POSSIBLE:
return "DNS_PROBE_POSSIBLE";
case DNS_PROBE_NOT_RUN:
return "DNS_PROBE_NOT_RUN";
case DNS_PROBE_STARTED:
return "DNS_PROBE_STARTED";
case DNS_PROBE_FINISHED_INCONCLUSIVE:
return "DNS_PROBE_FINISHED_INCONCLUSIVE";
case DNS_PROBE_FINISHED_NO_INTERNET:
return "DNS_PROBE_FINISHED_NO_INTERNET";
case DNS_PROBE_FINISHED_BAD_CONFIG:
return "DNS_PROBE_FINISHED_BAD_CONFIG";
case DNS_PROBE_FINISHED_NXDOMAIN:
return "DNS_PROBE_FINISHED_NXDOMAIN";
default:
NOTREACHED();
return "";
case chrome_common_net::DNS_PROBE_POSSIBLE:
return "DNS_PROBE_POSSIBLE";
case chrome_common_net::DNS_PROBE_NOT_RUN:
return "DNS_PROBE_NOT_RUN";
case chrome_common_net::DNS_PROBE_STARTED:
return "DNS_PROBE_STARTED";
case chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE:
return "DNS_PROBE_FINISHED_INCONCLUSIVE";
case chrome_common_net::DNS_PROBE_FINISHED_NO_INTERNET:
return "DNS_PROBE_FINISHED_NO_INTERNET";
case chrome_common_net::DNS_PROBE_FINISHED_BAD_CONFIG:
return "DNS_PROBE_FINISHED_BAD_CONFIG";
case chrome_common_net::DNS_PROBE_FINISHED_NXDOMAIN:
return "DNS_PROBE_FINISHED_NXDOMAIN";
default:
NOTREACHED();
return "";
}
}
bool DnsProbeStatusIsFinished(DnsProbeStatus status) {
return status >= DNS_PROBE_FINISHED_INCONCLUSIVE &&
status < DNS_PROBE_MAX;
bool DnsProbeStatusIsFinished(chrome_common_net::DnsProbeStatus status) {
return status >= chrome_common_net::DNS_PROBE_FINISHED_INCONCLUSIVE &&
status < chrome_common_net::DNS_PROBE_MAX;
}
void RecordEvent(NetworkErrorPageEvent event) {
void RecordEvent(chrome_common_net::NetworkErrorPageEvent event) {
UMA_HISTOGRAM_ENUMERATION("Net.ErrorPageCounts", event,
NETWORK_ERROR_PAGE_EVENT_MAX);
chrome_common_net::NETWORK_ERROR_PAGE_EVENT_MAX);
}
} // namespace chrome_common_net
} // namespace error_page

@ -83,6 +83,10 @@ enum DnsProbeStatus {
DNS_PROBE_MAX
};
} // namespace chrome_common_net
namespace error_page {
// Returns a string representing |status|. It should be simply the name of
// the value as a string, but don't rely on that. This is presented to the
// user as part of the DNS error page (as the error code, at the bottom),
@ -94,15 +98,15 @@ enum DnsProbeStatus {
const char* DnsProbeStatusToString(int status);
// Returns true if |status| is one of the DNS_PROBE_FINISHED_* statuses.
bool DnsProbeStatusIsFinished(DnsProbeStatus status);
bool DnsProbeStatusIsFinished(chrome_common_net::DnsProbeStatus status);
// Record specific error page events.
void RecordEvent(NetworkErrorPageEvent event);
void RecordEvent(chrome_common_net::NetworkErrorPageEvent event);
// The error domain used to pass DNS probe statuses to the localized error
// code.
extern const char kDnsProbeErrorDomain[];
} // namespace chrome_common_net
} // namespace error_page
#endif // COMPONENTS_ERROR_PAGE_COMMON_NET_ERROR_INFO_H_

@ -570,10 +570,9 @@ void NetErrorHelperCore::OnCommitLoad(FrameType frame_type, const GURL& url) {
pending_error_page_info_->error.unreachableURL) {
DCHECK(navigation_from_button_ == RELOAD_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_SHOW_SAVED_COPY_BUTTON_ERROR);
RecordEvent(navigation_from_button_ == RELOAD_BUTTON ?
chrome_common_net::NETWORK_ERROR_PAGE_RELOAD_BUTTON_ERROR :
chrome_common_net::NETWORK_ERROR_PAGE_SHOW_SAVED_COPY_BUTTON_ERROR);
}
navigation_from_button_ = NO_BUTTON;
@ -601,26 +600,22 @@ void NetErrorHelperCore::OnFinishLoad(FrameType frame_type) {
committed_error_page_info_->is_finished_loading = true;
chrome_common_net::RecordEvent(chrome_common_net::NETWORK_ERROR_PAGE_SHOWN);
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);
RecordEvent(chrome_common_net::NETWORK_ERROR_PAGE_RELOAD_BUTTON_SHOWN);
}
if (committed_error_page_info_->show_saved_copy_button_in_page) {
chrome_common_net::RecordEvent(
RecordEvent(
chrome_common_net::NETWORK_ERROR_PAGE_SHOW_SAVED_COPY_BUTTON_SHOWN);
}
if (committed_error_page_info_->reload_button_in_page &&
committed_error_page_info_->show_saved_copy_button_in_page) {
chrome_common_net::RecordEvent(
chrome_common_net::NETWORK_ERROR_PAGE_BOTH_BUTTONS_SHOWN);
RecordEvent(chrome_common_net::NETWORK_ERROR_PAGE_BOTH_BUTTONS_SHOWN);
}
if (committed_error_page_info_->show_cached_copy_button_in_page) {
chrome_common_net::RecordEvent(
chrome_common_net::NETWORK_ERROR_PAGE_CACHED_COPY_BUTTON_SHOWN);
RecordEvent(chrome_common_net::NETWORK_ERROR_PAGE_CACHED_COPY_BUTTON_SHOWN);
} else if (committed_error_page_info_->show_cached_page_button_in_page) {
chrome_common_net::RecordEvent(
chrome_common_net::NETWORK_ERROR_PAGE_CACHED_PAGE_BUTTON_SHOWN);
RecordEvent(chrome_common_net::NETWORK_ERROR_PAGE_CACHED_PAGE_BUTTON_SHOWN);
}
delegate_->EnablePageHelperFunctions();
@ -834,8 +829,7 @@ blink::WebURLError NetErrorHelperCore::GetUpdatedError(
}
blink::WebURLError updated_error;
updated_error.domain = blink::WebString::fromUTF8(
chrome_common_net::kDnsProbeErrorDomain);
updated_error.domain = blink::WebString::fromUTF8(kDnsProbeErrorDomain);
updated_error.reason = last_probe_status_;
updated_error.unreachableURL = error.unreachableURL;
updated_error.staleCopyInCache = error.staleCopyInCache;
@ -963,21 +957,20 @@ void NetErrorHelperCore::ExecuteButtonPress(bool is_error_page, Button button) {
switch (button) {
case RELOAD_BUTTON:
chrome_common_net::RecordEvent(
chrome_common_net::NETWORK_ERROR_PAGE_RELOAD_BUTTON_CLICKED);
RecordEvent(chrome_common_net::NETWORK_ERROR_PAGE_RELOAD_BUTTON_CLICKED);
if (committed_error_page_info_->show_saved_copy_button_in_page) {
chrome_common_net::RecordEvent(
RecordEvent(
chrome_common_net::NETWORK_ERROR_PAGE_BOTH_BUTTONS_RELOAD_CLICKED);
}
navigation_from_button_ = RELOAD_BUTTON;
Reload();
return;
case SHOW_SAVED_COPY_BUTTON:
chrome_common_net::RecordEvent(
RecordEvent(
chrome_common_net::NETWORK_ERROR_PAGE_SHOW_SAVED_COPY_BUTTON_CLICKED);
navigation_from_button_ = SHOW_SAVED_COPY_BUTTON;
if (committed_error_page_info_->reload_button_in_page) {
chrome_common_net::RecordEvent(chrome_common_net::
RecordEvent(chrome_common_net::
NETWORK_ERROR_PAGE_BOTH_BUTTONS_SHOWN_SAVED_COPY_CLICKED);
}
delegate_->LoadPageFromCache(
@ -985,24 +978,21 @@ void NetErrorHelperCore::ExecuteButtonPress(bool is_error_page, Button button) {
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);
RecordEvent(chrome_common_net::NETWORK_ERROR_PAGE_MORE_BUTTON_CLICKED);
return;
case EASTER_EGG:
chrome_common_net::RecordEvent(
chrome_common_net::NETWORK_ERROR_EASTER_EGG_ACTIVATED);
RecordEvent(chrome_common_net::NETWORK_ERROR_EASTER_EGG_ACTIVATED);
return;
case SHOW_CACHED_COPY_BUTTON:
chrome_common_net::RecordEvent(
RecordEvent(
chrome_common_net::NETWORK_ERROR_PAGE_CACHED_COPY_BUTTON_CLICKED);
return;
case SHOW_CACHED_PAGE_BUTTON:
chrome_common_net::RecordEvent(
RecordEvent(
chrome_common_net::NETWORK_ERROR_PAGE_CACHED_PAGE_BUTTON_CLICKED);
return;
case DIAGNOSE_ERROR:
chrome_common_net::RecordEvent(
chrome_common_net::NETWORK_ERROR_DIAGNOSE_BUTTON_CLICKED);
RecordEvent(chrome_common_net::NETWORK_ERROR_DIAGNOSE_BUTTON_CLICKED);
delegate_->DiagnoseError(
committed_error_page_info_->error.unreachableURL);
return;

@ -30,8 +30,6 @@ namespace {
using blink::WebURLError;
using chrome_common_net::DnsProbeStatus;
using chrome_common_net::DnsProbeStatusToString;
using error_page::ErrorPageParams;
const char kFailedUrl[] = "http://failed/";
const char kFailedHttpsUrl[] = "https://failed/";
@ -120,8 +118,7 @@ std::string ErrorToString(const WebURLError& error, bool is_failed_post) {
WebURLError ProbeError(DnsProbeStatus status) {
WebURLError error;
error.unreachableURL = GURL(kFailedUrl);
error.domain = blink::WebString::fromUTF8(
chrome_common_net::kDnsProbeErrorDomain);
error.domain = blink::WebString::fromUTF8(kDnsProbeErrorDomain);
error.reason = status;
return error;
}