Revise about: and chrome: url handling.

chrome/browser/browser_about_handler.cc

 // Copyright (c) 2011 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 "chrome/browser/browser_about_handler.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
@@ skipping 18 matching lines @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/memory_details.h"
 #include "chrome/browser/metrics/histogram_synchronizer.h"
 #include "chrome/browser/net/predictor_api.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser_dialogs.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
+#include "chrome/browser/ui/webui/web_ui_util.h"
 #include "chrome/common/about_handler.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/jstemplate_builder.h"
 #include "chrome/common/net/gaia/google_service_auth_error.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/url_constants.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/browser/renderer_host/render_process_host.h"
@@ skipping 47 matching lines @@
 
 // Glue between the callback task and the method in the singleton.
 void AboutTcmallocRendererCallback(base::ProcessId pid,
                                    const std::string& output) {
   AboutTcmallocOutputs::GetInstance()->RendererCallback(pid, output);
 }
 #endif
 
 namespace {
 
-// The (alphabetized) paths used for the about pages.
-// Note: Keep these in sync with url_constants.h
-const char kAppCacheInternalsPath[] = "appcache-internals";
-const char kBlobInternalsPath[] = "blob-internals";
-const char kCreditsPath[] = "credits";
-const char kCachePath[] = "view-http-cache";
+// Add paths here to be included in about:about.
+// These paths will also be suggested by BuiltinProvider.
+const char *kAllAboutPaths[] = {
+  chrome::kChromeUIAboutHost,
+  chrome::kChromeUIAppCacheInternalsHost,
+  chrome::kChromeUIBlobInternalsHost,
 #if defined(OS_WIN)

[sky, 2011/05/27 16:54:40]

nit: All the ifdefs in here make this a bit hard to read. Maybe it would be more
readable if you grouped the conditional ifdefs at the end.

[msw, 2011/05/31 13:34:29]

I was shooting for combined alphabetical order, also avoiding the trailing comma
confusion of #ifdefs at the end :] Would you prefer a platform specific section
at the end of the about:about pages list? 

[sky, 2011/05/31 17:15:36]

I vote for single #ifdef section at the end.

-const char kConflictsPath[] = "conflicts";
+  chrome::kChromeUIConflictsHost,
 #endif
-const char kDnsPath[] = "dns";
-const char kFlagsPath[] = "flags";
-const char kGpuPath[] = "gpu-internals";
-const char kHistogramsPath[] = "histograms";
-const char kMemoryRedirectPath[] = "memory-redirect";
-const char kMemoryPath[] = "memory";
-const char kStatsPath[] = "stats";
-const char kTasksPath[] = "tasks";
-const char kTcmallocPath[] = "tcmalloc";
-const char kTermsPath[] = "terms";
-const char kVersionPath[] = "version";
-const char kAboutPath[] = "about";
-// Not about:* pages, but included to make about:about look nicer
-const char kNetInternalsPath[] = "net-internals";
-const char kPluginsPath[] = "plugins";
-const char kSyncInternalsPath[] = "sync-internals";
+  chrome::kChromeUICreditsHost,
+  chrome::kChromeUIDNSHost,
+  chrome::kChromeUIFlagsHost,
+  chrome::kChromeUIGpuInternalsHost,
+  chrome::kChromeUIHistogramsHost,
+  chrome::kChromeUIMemoryHost,
+  chrome::kChromeUINetInternalsHost,
+#if defined(OS_CHROMEOS)
+  chrome::kChromeUINetworkHost,
+#endif
+  chrome::kChromeUINetworkViewCacheHost,
+#if defined(OS_CHROMEOS)
+  chrome::kChromeUIOSCreditsHost,
+#endif
+  chrome::kChromeUIPluginsHost,
+#if defined(OS_LINUX)
+  chrome::kChromeUISandboxHost,
+#endif
+  chrome::kChromeUIStatsHost,
+  chrome::kChromeUISyncInternalsHost,
+#ifdef TRACK_ALL_TASK_OBJECTS
+  chrome::kChromeUITasksHost,
+#endif
+  chrome::kChromeUITCMallocHost,
+  chrome::kChromeUITermsHost,
+  chrome::kChromeUIVersionHost
+};
 
+// Debug about paths, presented without links in about:about.
+// These paths will not be suggested by BuiltinProvider.
+const char *kDebugAboutPaths[] = {
+  chrome::kChromeUICrashHost,
+  chrome::kChromeUIKillHost,
+  chrome::kChromeUIHangHost,
+  chrome::kChromeUIShorthangHost,
+  chrome::kChromeUIGpuCleanHost,
+  chrome::kChromeUIGpuCrashHost,
+  chrome::kChromeUIGpuHangHost
+};
+
+  // AboutSource handles these about: and chrome: paths.

[sky, 2011/05/27 16:54:40]

nit: match indentation of 146-154, and same comment about grouping #ifdefs at
end.

[msw, 2011/05/31 13:34:29]

indentation fixed, see comment above regarding order.

+  const char *kAboutSourceNames[] = {
+    chrome::kChromeUIAboutHost,
+    chrome::kChromeUICreditsHost,
+    chrome::kChromeUIDNSHost,
+    chrome::kChromeUIHistogramsHost,
 #if defined(OS_LINUX)
-const char kLinuxProxyConfigPath[] = "linux-proxy-config";
-const char kSandboxPath[] = "sandbox";
+    chrome::kChromeUILinuxProxyConfigHost,
 #endif
-
+    chrome::kChromeUIMemoryHost,
+    chrome::kChromeUIMemoryRedirectHost,
 #if defined(OS_CHROMEOS)
-const char kNetworkPath[] = "network";
-const char kOSCreditsPath[] = "os-credits";
-const char kEULAPathFormat[] = "/usr/share/chromeos-assets/eula/%s/eula.html";
+    chrome::kChromeUINetworkHost,
+    chrome::kChromeUIOSCreditsHost,
 #endif
-
-// Add path here to be included in about:about
-const char *kAllAboutPaths[] = {
-  kAboutPath,
-  kAppCacheInternalsPath,
-  kBlobInternalsPath,
-  kCachePath,
-  kCreditsPath,
-#if defined(OS_WIN)
-  kConflictsPath,
+#if defined(OS_LINUX)
+    chrome::kChromeUISandboxHost,
 #endif
-  kDnsPath,
-  kFlagsPath,
-  kGpuPath,
-  kHistogramsPath,
-  kMemoryPath,
-  kNetInternalsPath,
-  kPluginsPath,
-  kStatsPath,
-  kSyncInternalsPath,
+    chrome::kChromeUIStatsHost,
 #ifdef TRACK_ALL_TASK_OBJECTS
-  kTasksPath,
-#endif  // TRACK_ALL_TASK_OBJECTS
-  kTcmallocPath,
-  kTermsPath,
-  kVersionPath,
-#if defined(OS_LINUX)
-  kSandboxPath,
+    chrome::kChromeUITasksHost,
 #endif
-#if defined(OS_CHROMEOS)
-  kNetworkPath,
-  kOSCreditsPath,
+#if defined(USE_TCMALLOC)
+    chrome::kChromeUITCMallocHost,
 #endif
+    chrome::kChromeUITermsHost,
+    chrome::kChromeUIVersionHost
   };
 
-// When you type about:memory, it actually loads an intermediate URL that
-// redirects you to the final page. This avoids the problem where typing
-// "about:memory" on the new tab page or any other page where a process
-// transition would occur to the about URL will cause some confusion.
-//
-// The problem is that during the processing of the memory page, there are two
-// processes active, the original and the destination one. This can create the
-// impression that we're using more resources than we actually are. This
-// redirect solves the problem by eliminating the process transition during the
-// time that about memory is being computed.
-std::string GetAboutMemoryRedirectResponse() {
-  return "<meta http-equiv=\"refresh\" "
-      "content=\"0;chrome://about/memory\">";
-}
-
 class AboutSource : public ChromeURLDataManager::DataSource {
  public:
-  // Creates our datasource.
-  AboutSource();
-  explicit AboutSource(Profile* profile);
+  // Construct a data source for the specified |source_name|.
+  explicit AboutSource(const std::string& source_name, Profile* profile);

[sky, 2011/05/27 16:54:40]

nit: no explicit

[msw, 2011/05/31 13:34:29]

Done.

 
   // Called when the network layer has requested a resource underneath
   // the path we registered.
   virtual void StartDataRequest(const std::string& path,
                                 bool is_incognito,
-                                int request_id);
+                                int request_id) OVERRIDE;
 
-  virtual std::string GetMimeType(const std::string&) const {
+  virtual std::string GetMimeType(const std::string&) const OVERRIDE {
     return "text/html";
   }
 
   // Send the response data.
   void FinishDataRequest(const std::string& html, int request_id);
 
   Profile* profile() { return profile_; }
 
  private:
   virtual ~AboutSource();
 
   Profile* profile_;
 
   DISALLOW_COPY_AND_ASSIGN(AboutSource);
 };
 
+// Register a data source for a known source name. Safe to call multiple times.
+void InitializeAboutDataSource(const std::string& name, Profile* profile) {
+  ChromeURLDataManager* manager = profile->GetChromeURLDataManager();
+  for (size_t i = 0; i < arraysize(kAboutSourceNames); i++) {

[sky, 2011/05/27 16:54:40]

Do you really need this for loop? Seems like it should be in a #if
!defined(NDEBUG)

[msw, 2011/05/31 13:34:29]

This is done to avoid allocating an AboutSource for
chrome://LongUnknownChromeURLThatTheUserEnteredForWhoKnowsWhatReason :)

[sky, 2011/05/31 17:15:36]

Ah, I didn't realize this is invoked for any random URL. Can you update the
comment to indicate 'name' may not be known.

+    if (name == kAboutSourceNames[i]) {
+      manager->AddDataSource(new AboutSource(name, profile));
+      return;
+    }
+  }
+}
+
+// When you type about:memory, it actually loads this intermediate URL that
+// redirects you to the final page. This avoids the problem where typing
+// "about:memory" on the new tab page or any other page where a process
+// transition would occur to the about URL will cause some confusion.
+//
+// The problem is that during the processing of the memory page, there are two
+// processes active, the original and the destination one. This can create the
+// impression that we're using more resources than we actually are. This
+// redirect solves the problem by eliminating the process transition during the
+// time that about memory is being computed.
+std::string GetAboutMemoryRedirectResponse(Profile* profile) {
+  InitializeAboutDataSource(chrome::kChromeUIMemoryRedirectHost, profile);
+  return StringPrintf("<meta http-equiv=\"refresh\" content=\"0;%s\">",
+                      chrome::kChromeUIMemoryRedirectURL);
+}
+
 // Handling about:memory is complicated enough to encapsulate its related
 // methods into a single class. The user should create it (on the heap) and call
 // its |StartFetch()| method.
 class AboutMemoryHandler : public MemoryDetails {
  public:
   AboutMemoryHandler(AboutSource* source, int request_id)
     : source_(source), request_id_(request_id) {}

[sky, 2011/05/27 16:54:40]

nit: if you can't fit the whole constructor on a single line, each member goes
on its own line.

[msw, 2011/05/31 13:34:29]

Done.

 
-
   virtual void OnDetailsAvailable();
 
  private:
   ~AboutMemoryHandler() {}
 
   void BindProcessMetrics(DictionaryValue* data,
                           ProcessMemoryInformation* info);
   void AppendProcess(ListValue* child_data, ProcessMemoryInformation* info);
 
   scoped_refptr<AboutSource> source_;
@@ skipping 49 matching lines @@
 
   void StartOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
         NewRunnableMethod(this, &ChromeOSTermsHandler::LoadFileOnFileThread));
   }
 
   void LoadFileOnFileThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-    std::string path = StringPrintf(kEULAPathFormat, locale_.c_str());
+    std::string path = StringPrintf(chrome::kEULAPathFormat, locale_.c_str());
     if (!file_util::ReadFileToString(FilePath(path), &contents_)) {
       // No EULA for given language - try en-US as default.
-      path = StringPrintf(kEULAPathFormat, "en-US");
+      path = StringPrintf(chrome::kEULAPathFormat, "en-US");
       if (!file_util::ReadFileToString(FilePath(path), &contents_)) {
         // File with EULA not found, ResponseOnUIThread will load EULA from
         // resources if contents_ is empty.
         contents_.clear();
       }
     }
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this, &ChromeOSTermsHandler::ResponseOnUIThread));
   }
@@ skipping 23 matching lines @@
 #endif
 
 // Individual about handlers ---------------------------------------------------
 
 std::string AboutAbout() {
   std::string html("<html><head><title>About Pages</title></head>\n"
       "<body><h2>List of About pages</h2>\n<ul>");
   std::vector<std::string> paths(AboutPaths());
   for (std::vector<std::string>::const_iterator i = paths.begin();
        i != paths.end(); ++i) {
-    html += "<li><a href='chrome://";
-    if ((*i != kAppCacheInternalsPath) &&
-        (*i != kBlobInternalsPath) &&
-        (*i != kCachePath) &&
-  #if defined(OS_WIN)
-        (*i != kConflictsPath) &&
-  #endif
-        (*i != kFlagsPath) &&
-        (*i != kGpuPath) &&
-        (*i != kNetInternalsPath) &&
-        (*i != kPluginsPath)) {
-      html += "about/";
-    }
-    html += *i + "/'>about:" + *i + "</a></li>\n";
+    html += "<li><a href='chrome://" + *i + "/'>about:" + *i + "</a></li>\n";
   }
-  const char *debug[] = { "crash", "kill", "hang", "shorthang",
-                          "gpuclean", "gpucrash", "gpuhang" };
   html += "</ul>\n<h2>For Debug</h2>\n"
       "<p>The following pages are for debugging purposes only. Because they "
       "crash or hang the renderer, they're not linked directly; you can type "
       "them into the address bar if you need them.</p>\n<ul>";
-  for (size_t i = 0; i < arraysize(debug); i++)
-    html += "<li>about:" + std::string(debug[i]) + "</li>\n";
+  for (size_t i = 0; i < arraysize(kDebugAboutPaths); i++)
+    html += "<li>about:" + std::string(kDebugAboutPaths[i]) + "</li>\n";
   html += "</ul>\n</body></html>";
   return html;
 }
 
 #if defined(OS_CHROMEOS)
 
 // Html output helper functions
 // TODO(stevenjb): L10N this.
 
 // Helper function to wrap Html with <th> tag.
@@ skipping 213 matching lines @@
   // Where the results are fed to.
   scoped_refptr<AboutSource> source_;
 
   // ID identifying the request.
   int request_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AboutDnsHandler);
 };
 
 #if defined(USE_TCMALLOC)
-std::string AboutTcmalloc(const std::string& query) {
+std::string AboutTcmalloc() {
   std::string data;
   AboutTcmallocOutputsType* outputs =
       AboutTcmallocOutputs::GetInstance()->outputs();
 
   // Display any stats for which we sent off requests the last time.
   data.append("<html><head><title>About tcmalloc</title></head><body>\n");
   data.append("<p>Stats as of last page load;");
   data.append("reload to get stats as of this page load.</p>\n");
   data.append("<table width=\"100%\">\n");
   for (AboutTcmallocOutputsType::const_iterator oit = outputs->begin();
@@ skipping 399 matching lines @@
   base::StringPiece version_html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_ABOUT_VERSION_HTML));
 
   return jstemplate_builder::GetTemplatesHtml(
       version_html, localized_strings, "t" /* template root node id */);
 }
 
 // AboutSource -----------------------------------------------------------------
 
-AboutSource::AboutSource()
-    : DataSource(chrome::kAboutScheme, MessageLoop::current()) {
-}
-
-AboutSource::AboutSource(Profile* profile)
-    : DataSource(chrome::kAboutScheme, MessageLoop::current()),
+AboutSource::AboutSource(const std::string& source_name, Profile* profile)
+    : DataSource(source_name, MessageLoop::current()),
       profile_(profile) {
 }
 
 AboutSource::~AboutSource() {
 }
 
-void AboutSource::StartDataRequest(const std::string& path_raw,
-    bool is_incognito, int request_id) {
-  std::string path = path_raw;
-  std::string info;
-  if (path.find("/") != std::string::npos) {
-    size_t pos = path.find("/");
-    info = path.substr(pos + 1, path.length() - (pos + 1));
-    path = path.substr(0, pos);
-  }
-  path = StringToLowerASCII(path);
-
+void AboutSource::StartDataRequest(const std::string& path,
+                                   bool is_incognito,
+                                   int request_id) {
   std::string response;
-  if (path == kDnsPath) {
+  std::string host = source_name();
+  if (host == chrome::kChromeUIDNSHost) {
     AboutDnsHandler::Start(this, request_id);
     return;
-  } else if (path == kHistogramsPath) {
-    response = AboutHistograms(info);
-  } else if (path == kMemoryPath) {
+  } else if (host == chrome::kChromeUIHistogramsHost) {
+    response = AboutHistograms(path);
+  } else if (host == chrome::kChromeUIMemoryHost) {
+    response = GetAboutMemoryRedirectResponse(profile());
+  } else if (host == chrome::kChromeUIMemoryRedirectHost) {
     AboutMemory(this, request_id);
     return;
-  } else if (path == kMemoryRedirectPath) {
-    response = GetAboutMemoryRedirectResponse();
 #ifdef TRACK_ALL_TASK_OBJECTS
-  } else if (path == kTasksPath) {
-    response = AboutObjects(info);
+  } else if (host == chrome::kChromeUITasksHost) {
+    response = AboutObjects(path);
 #endif
-  } else if (path == kStatsPath) {
-    response = AboutStats(info);
+  } else if (host == chrome::kChromeUIStatsHost) {
+    response = AboutStats(path);
 #if defined(USE_TCMALLOC)
-  } else if (path == kTcmallocPath) {
-    response = AboutTcmalloc(info);
+  } else if (host == chrome::kChromeUITCMallocHost) {
+    response = AboutTcmalloc();
 #endif
-  } else if (path == kVersionPath || path.empty()) {
+  } else if (host == chrome::kChromeUIVersionHost) {
 #if defined(OS_CHROMEOS)
     new ChromeOSAboutVersionHandler(this, request_id);
     return;
 #else
     DictionaryValue localized_strings;
     localized_strings.SetString("os_version", "");
     response = AboutVersion(&localized_strings, profile_);
 #endif
-  } else if (path == kCreditsPath) {
+  } else if (host == chrome::kChromeUICreditsHost) {
     response = ResourceBundle::GetSharedInstance().GetRawDataResource(
         IDR_CREDITS_HTML).as_string();
-  } else if (path == kAboutPath) {
+  } else if (host == chrome::kChromeUIAboutHost) {
     response = AboutAbout();
 #if defined(OS_CHROMEOS)
-  } else if (path == kOSCreditsPath) {
+  } else if (host == chrome::kChromeUIOSCreditsHost) {
     response = ResourceBundle::GetSharedInstance().GetRawDataResource(
         IDR_OS_CREDITS_HTML).as_string();
-  } else if (path == kNetworkPath) {
-    response = AboutNetwork(info);
+  } else if (host == chrome::kChromeUINetworkHost) {
+    response = AboutNetwork(path);
 #endif
-  } else if (path == kTermsPath) {
+  } else if (host == chrome::kChromeUITermsHost) {
 #if defined(OS_CHROMEOS)
     ChromeOSTermsHandler::Start(this, request_id);
     return;
 #else
     response = ResourceBundle::GetSharedInstance().GetRawDataResource(
         IDR_TERMS_HTML).as_string();
 #endif
 #if defined(OS_LINUX)
-  } else if (path == kLinuxProxyConfigPath) {
+  } else if (host == chrome::kChromeUILinuxProxyConfigHost) {
     response = AboutLinuxProxyConfig();
-  } else if (path == kSandboxPath) {
+  } else if (host == chrome::kChromeUISandboxHost) {
     response = AboutSandbox();
 #endif
   }
 
   FinishDataRequest(response, request_id);
 }
 
-void AboutSource::FinishDataRequest(const std::string& response,
-                                    int request_id) {
+void AboutSource::FinishDataRequest(const std::string& html, int request_id) {
   scoped_refptr<RefCountedBytes> html_bytes(new RefCountedBytes);
-  html_bytes->data.resize(response.size());
-  std::copy(response.begin(), response.end(), html_bytes->data.begin());
+  html_bytes->data.resize(html.size());
+  std::copy(html.begin(), html.end(), html_bytes->data.begin());
   SendResponse(request_id, html_bytes);
 }
 
 // AboutMemoryHandler ----------------------------------------------------------
 
 // Helper for AboutMemory to bind results from a ProcessMetrics object
 // to a DictionaryValue. Fills ws_usage and comm_usage so that the objects
 // can be used in caller's scope (e.g for appending to a net total).
 void AboutMemoryHandler::BindProcessMetrics(DictionaryValue* data,
                                             ProcessMemoryInformation* info) {
@@ skipping 143 matching lines @@
   source_->FinishDataRequest(AboutVersion(&localized_strings,
                                           source_->profile()), request_id_);
 
   // CancelableRequestProvider isn't happy when it's deleted and servicing a
   // task, so we delay the deletion.
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 #endif
 
-// Returns true if |url|'s spec starts with |about_specifier|, and is
-// terminated by the start of a path.
-bool StartsWithAboutSpecifier(const GURL& url, const char* about_specifier) {
-  return StartsWithASCII(url.spec(), about_specifier, true) &&
-         (url.spec().size() == strlen(about_specifier) ||
-          url.spec()[strlen(about_specifier)] == '/');
-}
-
-// Transforms a URL of the form "about:foo/XXX" to <url_prefix> + "XXX".
-GURL RemapAboutURL(const std::string& url_prefix, const GURL& url) {
-  std::string path;
-  size_t split = url.spec().find('/');
-  if (split != std::string::npos)
-    path = url.spec().substr(split + 1);
-  return GURL(url_prefix + path);
-}
-
 }  // namespace
 
 // -----------------------------------------------------------------------------
 
 bool WillHandleBrowserAboutURL(GURL* url, Profile* profile) {
-  // We only handle about: schemes.
-  if (!url->SchemeIs(chrome::kAboutScheme))
+  if (!web_ui_util::IsChromeURL(*url))
     return false;
 
   // about:blank is special. Frames are allowed to access about:blank,
   // but they are not allowed to access other types of about pages.
   // Just ignore the about:blank and let the TAB_CONTENTS_WEB handle it.
   if (LowerCaseEqualsASCII(url->spec(), chrome::kAboutBlankURL))
     return false;
 
-  // Rewrite about:cache/* URLs to chrome://view-http-cache/*
-  if (StartsWithAboutSpecifier(*url, chrome::kAboutCacheURL)) {
-    *url = RemapAboutURL(chrome::kNetworkViewCacheURL, *url);
-    return true;
-  }
-
-#if defined(OS_WIN)
-  // Rewrite about:conflicts/* URLs to chrome://conflicts/*
-  if (StartsWithAboutSpecifier(*url, chrome::kAboutConflicts)) {
-    *url = GURL(chrome::kChromeUIConflictsURL);
-    return true;
-  }
-#endif
-
-  // Rewrite about:flags to chrome://flags/.
-  if (LowerCaseEqualsASCII(url->spec(), chrome::kAboutFlagsURL)) {
-    *url = GURL(chrome::kChromeUIFlagsURL);
-    return true;
-  }
-
-  // Rewrite about:net-internals/* URLs to chrome://net-internals/*
-  if (StartsWithAboutSpecifier(*url, chrome::kAboutNetInternalsURL)) {
-    *url = RemapAboutURL(chrome::kNetworkViewInternalsURL, *url);
-    return true;
-  }
-
-  // Rewrite about:gpu/* URLs to chrome://gpu-internals/*
-  if (StartsWithAboutSpecifier(*url, chrome::kAboutGpuURL)) {
-    *url = RemapAboutURL(chrome::kGpuInternalsURL, *url);
-    return true;
-  }
-
-  // Rewrite about:appcache-internals/* URLs to chrome://appcache/*
-  if (StartsWithAboutSpecifier(*url, chrome::kAboutAppCacheInternalsURL)) {
-    *url = RemapAboutURL(chrome::kAppCacheViewInternalsURL, *url);
-    return true;
-  }
-
-  // Rewrite about:sync-internals/* URLs (and about:sync, too, for
-  // legacy reasons) to chrome://sync-internals/*
-  if (StartsWithAboutSpecifier(*url, chrome::kAboutSyncInternalsURL) ||
-      StartsWithAboutSpecifier(*url, chrome::kAboutSyncURL)) {
-    *url = RemapAboutURL(chrome::kSyncViewInternalsURL, *url);
-    return true;
-  }
-
-  // Rewrite about:plugins to chrome://plugins/.
-  if (LowerCaseEqualsASCII(url->spec(), chrome::kAboutPluginsURL)) {
-    *url = GURL(chrome::kChromeUIPluginsURL);
-    return true;
-  }
-
-  // Handle URL to crash the browser process.
-  if (LowerCaseEqualsASCII(url->spec(), chrome::kAboutBrowserCrash)) {
-    // Induce an intentional crash in the browser process.
-    int* bad_pointer = NULL;
-    *bad_pointer = 42;
-    return true;
-  }
-
-  // Handle URLs to wreck the gpu process.
-  if (LowerCaseEqualsASCII(url->spec(), chrome::kAboutGpuCleanURL)) {
-    GpuProcessHost::SendOnIO(
-        0, content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH, new GpuMsg_Clean());
-  }
-  if (LowerCaseEqualsASCII(url->spec(), chrome::kAboutGpuCrashURL)) {
-    GpuProcessHost::SendOnIO(
-        0, content::CAUSE_FOR_GPU_LAUNCH_ABOUT_GPUCRASH, new GpuMsg_Crash());
-  }
-  if (LowerCaseEqualsASCII(url->spec(), chrome::kAboutGpuHangURL)) {
-    GpuProcessHost::SendOnIO(
-        0, content::CAUSE_FOR_GPU_LAUNCH_ABOUT_GPUHANG, new GpuMsg_Hang());
-  }
-
   // There are a few about: URLs that we hand over to the renderer. If the
   // renderer wants them, don't do any rewriting.
   if (chrome_about_handler::WillHandle(*url))
     return false;
 
-  // Anything else requires our special handler; make sure it's initialized.
-  InitializeAboutDataSource(profile);
+  // Get the URL 'host', which GURL does not correctly parse for "scheme:host".
+  std::string host(StringToLowerASCII(web_ui_util::GetChromeURLHost(*url)));
 
-  // Special case about:memory to go through a redirect before ending up on
-  // the final page. See GetAboutMemoryRedirectResponse above for why.
-  if (LowerCaseEqualsASCII(url->path(), kMemoryPath)) {
-    *url = GURL("chrome://about/memory-redirect");
+  // Replace default ("") with version.
+  if (host == chrome::kChromeUIDefaultHost)
+    host = chrome::kChromeUIVersionHost;
+  // Replace cache with view-http-cache.
+  if (host == chrome::kChromeUICacheHost)
+    host = chrome::kChromeUINetworkViewCacheHost;
+  // Replace gpu with gpu-internals.
+  else if (host == chrome::kChromeUIGpuHost)
+    host = chrome::kChromeUIGpuInternalsHost;
+  // Replace sync with sync-internals (for legacy reasons).
+  else if (host == chrome::kChromeUISyncHost)
+    host = chrome::kChromeUISyncInternalsHost;
+
+  // Handle URLs to crash the browser or wreck the gpu process.
+  if (host == chrome::kChromeUIBrowserCrashHost) {
+    // Induce an intentional crash in the browser process.
+    int* bad_pointer = NULL;
+    *bad_pointer = 42;
     return true;
+  } else if (host == chrome::kChromeUIGpuCleanHost) {
+    GpuProcessHost::SendOnIO(
+        0, content::CAUSE_FOR_GPU_LAUNCH_NO_LAUNCH, new GpuMsg_Clean());
+  } else if (host == chrome::kChromeUIGpuCrashHost) {
+    GpuProcessHost::SendOnIO(
+        0, content::CAUSE_FOR_GPU_LAUNCH_ABOUT_GPUCRASH, new GpuMsg_Crash());
+  } else if (host == chrome::kChromeUIGpuHangHost) {
+    GpuProcessHost::SendOnIO(
+        0, content::CAUSE_FOR_GPU_LAUNCH_ABOUT_GPUHANG, new GpuMsg_Hang());
   }
 
-  // Rewrite the about URL to use chrome:. WebKit treats all about URLS the
-  // same (blank page), so if we want to display content, we need another
-  // scheme.
-  std::string about_url = "chrome://about/";
-  about_url.append(url->path());
-  *url = GURL(about_url);
+  // Initialize any potentially corresponding AboutSource handler.
+  InitializeAboutDataSource(host, profile);
+
+  // Use the chrome: scheme instead of about:. WebKit treats all about: URLS as
+  // about:blank, so if we want to display content, we need another scheme.
+  std::string new_url(chrome::kChromeUIScheme);
+  new_url.append(chrome::kStandardSchemeSeparator);
+  *url = GURL(new_url.append(host).append(web_ui_util::GetChromeURLPath(*url)));
   return true;
 }
 
-void InitializeAboutDataSource(Profile* profile) {
-  profile->GetChromeURLDataManager()->AddDataSource(new AboutSource(profile));
-}
-
-// This function gets called with the fixed-up chrome: URLs, so we have to
-// compare against those instead of "about:blah".
 bool HandleNonNavigationAboutURL(const GURL& url) {
   // about:ipc is currently buggy, so we disable it for official builds.
 #if !defined(OFFICIAL_BUILD)
 
 #if (defined(OS_MACOSX) || defined(OS_WIN)) && defined(IPC_MESSAGE_LOG_ENABLED)
-  if (LowerCaseEqualsASCII(url.spec(), chrome::kChromeUIIPCURL)) {
+  if (web_ui_util::HostEquals(url, chrome::kChromeUIIPCHost)) {
     // Run the dialog. This will re-use the existing one if it's already up.
     browser::ShowAboutIPCDialog();
     return true;
   }
 #endif
 
 #endif  // OFFICIAL_BUILD
 
   return false;
 }
 
 std::vector<std::string> AboutPaths() {
   std::vector<std::string> paths;
   paths.reserve(arraysize(kAllAboutPaths));
   for (size_t i = 0; i < arraysize(kAllAboutPaths); i++)
     paths.push_back(kAllAboutPaths[i]);
   return paths;
 }