Move remaining about: handlers to webUI.

chrome/browser/ui/webui/about_ui.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 "chrome/browser/ui/webui/about_ui.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/i18n/number_formatting.h"
 #include "base/json/json_writer.h"
 #include "base/memory/singleton.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_table.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/about_flags.h"
+#include "chrome/browser/browser_about_handler.h"
 #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.h"
 #include "chrome/browser/net/url_fixer_upper.h"
 #include "chrome/browser/plugin_prefs.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/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/gpu/gpu_process_host_ui_shim.h"
 #include "content/browser/plugin_service.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/sensors/sensors_provider.h"
+#include "content/browser/tab_contents/tab_contents.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/common/content_client.h"
 #include "crypto/nss_util.h"
 #include "googleurl/src/gurl.h"
 #include "grit/browser_resources.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "net/base/escape.h"
@@ skipping 21 matching lines @@
 #endif
 
 #if defined(USE_TCMALLOC)
 #include "third_party/tcmalloc/chromium/src/google/malloc_extension.h"
 #endif
 
 using base::Time;
 using base::TimeDelta;
 using content::BrowserThread;
 
-#if defined(USE_TCMALLOC)
-// static
-AboutTcmallocOutputs* AboutTcmallocOutputs::GetInstance() {
-  return Singleton<AboutTcmallocOutputs>::get();
-}
-
-AboutTcmallocOutputs::AboutTcmallocOutputs() {}
-
-AboutTcmallocOutputs::~AboutTcmallocOutputs() {}
-
-// 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 {
 
-// Add paths here to be included in chrome://chrome-urls (about:about).
-// These paths will also be suggested by BuiltinProvider.
-const char* const kChromePaths[] = {
-  chrome::kChromeUIAppCacheInternalsHost,
-  chrome::kChromeUIBlobInternalsHost,
-  chrome::kChromeUIBookmarksHost,
-  chrome::kChromeUICacheHost,
-  chrome::kChromeUIChromeURLsHost,
-  chrome::kChromeUICrashesHost,
-  chrome::kChromeUICreditsHost,
-  chrome::kChromeUIDNSHost,
-  chrome::kChromeUIDownloadsHost,
-  chrome::kChromeUIExtensionsHost,
-  chrome::kChromeUIFlagsHost,
-  chrome::kChromeUIFlashHost,
-  chrome::kChromeUIGpuInternalsHost,
-  chrome::kChromeUIHistogramsHost,
-  chrome::kChromeUIHistoryHost,
-  chrome::kChromeUIIPCHost,
-  chrome::kChromeUIMediaInternalsHost,
-  chrome::kChromeUIMemoryHost,
-  chrome::kChromeUINetInternalsHost,
-  chrome::kChromeUINetworkViewCacheHost,
-  chrome::kChromeUINewTabHost,
-  chrome::kChromeUIPluginsHost,
-  chrome::kChromeUIPrintHost,
-  chrome::kChromeUIProfilerHost,
-  chrome::kChromeUIQuotaInternalsHost,
-  chrome::kChromeUISessionsHost,
-  chrome::kChromeUISettingsHost,
-  chrome::kChromeUIStatsHost,
-  chrome::kChromeUISyncInternalsHost,
-  chrome::kChromeUITaskManagerHost,
-  chrome::kChromeUITCMallocHost,
-  chrome::kChromeUITermsHost,
-  chrome::kChromeUITracingHost,
-  chrome::kChromeUIVersionHost,
-  chrome::kChromeUIWorkersHost,
-#if defined(OS_WIN)
-  chrome::kChromeUIConflictsHost,
-#endif
-#if defined(OS_LINUX) || defined(OS_OPENBSD)
-  chrome::kChromeUILinuxProxyConfigHost,
-  chrome::kChromeUISandboxHost,
-#endif
-#if defined(OS_CHROMEOS)
-  chrome::kChromeUIActiveDownloadsHost,
-  chrome::kChromeUIChooseMobileNetworkHost,
-  chrome::kChromeUICryptohomeHost,
-  chrome::kChromeUIDiscardsHost,
-  chrome::kChromeUIImageBurnerHost,
-  chrome::kChromeUIKeyboardOverlayHost,
-  chrome::kChromeUILoginHost,
-  chrome::kChromeUINetworkHost,
-  chrome::kChromeUIOobeHost,
-  chrome::kChromeUIOSCreditsHost,
-  chrome::kChromeUIProxySettingsHost,
-  chrome::kChromeUISystemInfoHost,
-#endif
-};
-
-// AboutSource handles these chrome:// paths.
-const char* const kAboutSourceNames[] = {
-  chrome::kChromeUIChromeURLsHost,
-  chrome::kChromeUICreditsHost,
-  chrome::kChromeUIDNSHost,
-  chrome::kChromeUIHistogramsHost,
-  chrome::kChromeUIMemoryHost,
-  chrome::kChromeUIMemoryRedirectHost,
-  chrome::kChromeUIStatsHost,
-  chrome::kChromeUITaskManagerHost,
-  chrome::kChromeUITermsHost,
-  chrome::kChromeUIVersionHost,
-#if defined(USE_TCMALLOC)
-  chrome::kChromeUITCMallocHost,
-#endif
-#if defined(OS_LINUX) || defined(OS_OPENBSD)
-  chrome::kChromeUILinuxProxyConfigHost,
-  chrome::kChromeUISandboxHost,
-#endif
-#if defined(OS_CHROMEOS)
-  chrome::kChromeUICryptohomeHost,
-  chrome::kChromeUIDiscardsHost,
-  chrome::kChromeUINetworkHost,
-  chrome::kChromeUIOSCreditsHost,
-#endif
-};
-
 const char kCreditsJsPath[] = "credits.js";
 const char kMemoryJsPath[] = "memory.js";
 const char kStatsJsPath[] = "stats.js";
 const char kStringsJsPath[] = "strings.js";
 const char kVersionJsPath[] = "version.js";
 
-class AboutSource : public ChromeURLDataManager::DataSource {
- public:
-  // Construct a data source for the specified |source_name|.
-  AboutSource(const std::string& source_name, Profile* profile);
-
-  // 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) OVERRIDE;
-
-  virtual std::string GetMimeType(const std::string& path) const OVERRIDE;
-
-  // 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);
-};
-
 // 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)
+  AboutMemoryHandler(AboutUIHTMLSource* source, int request_id)
       : source_(source),
         request_id_(request_id) {
   }
 
   virtual void OnDetailsAvailable() OVERRIDE;
 
  private:
   ~AboutMemoryHandler() {}
 
   void BindProcessMetrics(DictionaryValue* data,
                           ProcessMemoryInformation* info);
   void AppendProcess(ListValue* child_data, ProcessMemoryInformation* info);
 
-  scoped_refptr<AboutSource> source_;
+  scoped_refptr<AboutUIHTMLSource> source_;
   int request_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AboutMemoryHandler);
 };
 
 #if defined(OS_CHROMEOS)
 // ChromeOSAboutVersionHandler is responsible for loading the Chrome OS
 // version.
 // ChromeOSAboutVersionHandler handles deleting itself once the version has
-// been obtained and AboutSource notified.
+// been obtained and AboutUIHTMLSource notified.
 class ChromeOSAboutVersionHandler {
  public:
-  ChromeOSAboutVersionHandler(AboutSource* source, int request_id);
+  ChromeOSAboutVersionHandler(AboutUIHTMLSource* source, int request_id);
 
   // Callback from chromeos::VersionLoader giving the version.
   void OnVersion(chromeos::VersionLoader::Handle handle,
                  std::string version);
 
  private:
   // Where the results are fed to.
-  scoped_refptr<AboutSource> source_;
+  scoped_refptr<AboutUIHTMLSource> source_;
 
   // ID identifying the request.
   int request_id_;
 
   // Handles asynchronously loading the version.
   chromeos::VersionLoader loader_;
 
   // Used to request the version.
   CancelableRequestConsumer consumer_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeOSAboutVersionHandler);
 };
 
 class ChromeOSTermsHandler
     : public base::RefCountedThreadSafe<ChromeOSTermsHandler> {
  public:
-  static void Start(AboutSource* source,
+  static void Start(AboutUIHTMLSource* source,
                     const std::string& path,
                     int request_id) {
     scoped_refptr<ChromeOSTermsHandler> handler(
         new ChromeOSTermsHandler(source, path, request_id));
     handler->StartOnUIThread();
   }
 
  private:
-  ChromeOSTermsHandler(AboutSource* source,
+  ChromeOSTermsHandler(AboutUIHTMLSource* source,
                        const std::string& path,
                        int request_id)
     : source_(source),
       path_(path),
       request_id_(request_id),
       locale_(chromeos::WizardController::GetInitialLocale()) {
   }
 
   void StartOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 39 matching lines @@
     // If we fail to load Chrome OS EULA from disk, load it from resources.
     // Do nothing if OEM EULA load failed.
     if (contents_.empty() && path_ != chrome::kOemEulaURLPath) {
       contents_ = ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_TERMS_HTML).as_string();
     }
     source_->FinishDataRequest(contents_, request_id_);
   }
 
   // Where the results are fed to.
-  scoped_refptr<AboutSource> source_;
+  scoped_refptr<AboutUIHTMLSource> source_;
 
   // Path in the URL.
   std::string path_;
 
   // ID identifying the request.
   int request_id_;
 
   // Locale of the EULA.
   std::string locale_;
 
@@ skipping 354 matching lines @@
   AppendFooter(&output);
   return output;
 }
 
 #endif  // OS_CHROMEOS
 
 // AboutDnsHandler bounces the request back to the IO thread to collect
 // the DNS information.
 class AboutDnsHandler : public base::RefCountedThreadSafe<AboutDnsHandler> {
  public:
-  static void Start(AboutSource* source, int request_id) {
+  static void Start(AboutUIHTMLSource* source, int request_id) {
     scoped_refptr<AboutDnsHandler> handler(
         new AboutDnsHandler(source, request_id));
     handler->StartOnUIThread();
   }
 
  private:
-  AboutDnsHandler(AboutSource* source, int request_id)
+  AboutDnsHandler(AboutUIHTMLSource* source, int request_id)
       : source_(source),
         request_id_(request_id) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   }
 
   // Calls FinishOnUIThread() on completion.
   void StartOnUIThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     chrome_browser_net::Predictor* predictor =
         source_->profile()->GetNetworkPredictor();
@@ skipping 15 matching lines @@
         BrowserThread::UI, FROM_HERE,
         NewRunnableMethod(this, &AboutDnsHandler::FinishOnUIThread, data));
   }
 
   void FinishOnUIThread(const std::string& data) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     source_->FinishDataRequest(data, request_id_);
   }
 
   // Where the results are fed to.
-  scoped_refptr<AboutSource> source_;
+  scoped_refptr<AboutUIHTMLSource> source_;
 
   // ID identifying the request.
   int request_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AboutDnsHandler);
 };
 
 #if defined(USE_TCMALLOC)
 std::string AboutTcmalloc() {
   std::string data;
@@ skipping 60 matching lines @@
   }
 
   std::string data;
   AppendHeader(&data, 0, unescaped_title);
   AppendBody(&data);
   base::StatisticsRecorder::WriteHTMLGraph(unescaped_query, &data);
   AppendFooter(&data);
   return data;
 }
 
-void AboutMemory(const std::string& path, AboutSource* source, int request_id) {
+void AboutMemory(const std::string& path, AboutUIHTMLSource* source,
+                 int request_id) {
   if (path == kStringsJsPath) {
-    // The AboutMemoryHandler cleans itself up, but |StartFetch()| will want the
-    // refcount to be greater than 0.
+    // The AboutMemoryHandler cleans itself up, but |StartFetch()| will want
+    // the refcount to be greater than 0.
     scoped_refptr<AboutMemoryHandler>
         handler(new AboutMemoryHandler(source, request_id));
     handler->StartFetch();
   } else {
     source->FinishDataRequest(
         ResourceBundle::GetSharedInstance().GetRawDataResource(
             path == kMemoryJsPath ? IDR_ABOUT_MEMORY_JS :
                 IDR_ABOUT_MEMORY_HTML).as_string(), request_id);
   }
 }
@@ skipping 335 matching lines @@
     localized_strings->SetString("profile_path",
         l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_PATH_NOTFOUND));
   }
 
   std::string data;
   jstemplate_builder::AppendJsonJS(localized_strings, &data);
   return data;
 }
 
 // Used as a callback for PluginService::GetPlugins().
-void HandleAboutVersionStrings(AboutSource* source,
+void HandleAboutVersionStrings(AboutUIHTMLSource* source,
                                int request_id,
                                const std::vector<webkit::WebPluginInfo>&) {
 #if defined(OS_CHROMEOS)
   new ChromeOSAboutVersionHandler(source, request_id);
 #else
   DictionaryValue localized_strings;
   localized_strings.SetString("os_version", "");
   source->FinishDataRequest(
       AboutVersionStrings(&localized_strings, source->profile()),
       request_id);
@@ skipping 27 matching lines @@
 void AboutMemoryHandler::AppendProcess(ListValue* child_data,
                                        ProcessMemoryInformation* info) {
   DCHECK(child_data && info);
 
   // Append a new DictionaryValue for this renderer to our list.
   DictionaryValue* child = new DictionaryValue();
   child_data->Append(child);
   BindProcessMetrics(child, info);
 
   std::string child_label(
-      ChildProcessInfo::GetFullTypeNameInEnglish(info->type,
-                                                 info->renderer_type));
+      ProcessMemoryInformation::GetFullTypeNameInEnglish(info->type,
+                                                         info->renderer_type));
   if (info->is_diagnostics)
     child_label.append(" (diagnostics)");
   child->SetString("child_name", child_label);
   ListValue* titles = new ListValue();
   child->Set("titles", titles);
   for (size_t i = 0; i < info->titles.size(); ++i)
     titles->Append(new StringValue(info->titles[i]));
 }
 
 
@@ skipping 74 matching lines @@
 
   std::string data;
   jstemplate_builder::AppendJsonJS(&root, &data);
   source_->FinishDataRequest(data, request_id_);
 }
 
 #if defined(OS_CHROMEOS)
 // ChromeOSAboutVersionHandler  -----------------------------------------------
 
 ChromeOSAboutVersionHandler::ChromeOSAboutVersionHandler(
-    AboutSource* source,
+    AboutUIHTMLSource* source,
     int request_id)
     : source_(source),
       request_id_(request_id) {
   loader_.GetVersion(&consumer_,
                      base::Bind(&ChromeOSAboutVersionHandler::OnVersion,
                                 base::Unretained(this)),
                      chromeos::VersionLoader::VERSION_FULL);
 }
 
 void ChromeOSAboutVersionHandler::OnVersion(
     chromeos::VersionLoader::Handle handle,
     std::string version) {
   DictionaryValue localized_strings;
   localized_strings.SetString("os_version", version);
   source_->FinishDataRequest(AboutVersionStrings(
       &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
 
 }  // namespace
 
-// AboutSource -----------------------------------------------------------------
+// AboutUIHTMLSource ----------------------------------------------------------
 
-AboutSource::AboutSource(const std::string& source_name, Profile* profile)
+AboutUIHTMLSource::AboutUIHTMLSource(const std::string& source_name,
+                                     Profile* profile)
     : DataSource(source_name, MessageLoop::current()),
       profile_(profile) {
 }
 
-AboutSource::~AboutSource() {
+AboutUIHTMLSource::~AboutUIHTMLSource() {
 }
 
-void AboutSource::StartDataRequest(const std::string& path,
+void AboutUIHTMLSource::StartDataRequest(const std::string& path,
                                    bool is_incognito,
                                    int request_id) {
   std::string response;
   std::string host = source_name();
   // Add your data source here, in alphabetical order.
   if (host == chrome::kChromeUIChromeURLsHost) {
     response = ChromeURLs();
   } else if (host == chrome::kChromeUICreditsHost) {
     int idr = (path == kCreditsJsPath) ? IDR_CREDITS_JS : IDR_CREDITS_HTML;
     response = ResourceBundle::GetSharedInstance().GetRawDataResource(
@@ skipping 52 matching lines @@
                      make_scoped_refptr(this), request_id));
       return;
     } else {
       response = AboutVersionStaticContent(path);
     }
   }
 
   FinishDataRequest(response, request_id);
 }
 
-void AboutSource::FinishDataRequest(const std::string& html, int request_id) {
+void AboutUIHTMLSource::FinishDataRequest(const std::string& html,
+                                          int request_id) {
   std::string html_copy(html);
   SendResponse(request_id, base::RefCountedString::TakeString(&html_copy));
 }
 
-std::string AboutSource::GetMimeType(const std::string& path) const {
+std::string AboutUIHTMLSource::GetMimeType(const std::string& path) const {
   if (path == kCreditsJsPath ||
       path == kStatsJsPath   ||
       path == kStringsJsPath ||
       path == kVersionJsPath ||
       path == kMemoryJsPath) {
     return "application/javascript";
   }
   return "text/html";
 }
 
-// -----------------------------------------------------------------------------
-
-void InitializeAboutDataSource(const std::string& name,
-                               content::BrowserContext* browser_context) {
-  Profile* profile = static_cast<Profile*>(browser_context);
-  ChromeURLDataManager* manager = profile->GetChromeURLDataManager();
-  for (size_t i = 0; i < arraysize(kAboutSourceNames); i++) {
-    if (name == kAboutSourceNames[i]) {
-      manager->AddDataSource(new AboutSource(name, profile));
-      return;
-    }
-  }
+AboutUI::AboutUI(TabContents* contents, const std::string& name)
+    : ChromeWebUI(contents) {
+  Profile* profile = Profile::FromBrowserContext(contents->browser_context());
+  ChromeURLDataManager::DataSource* source =
+      new AboutUIHTMLSource(name, profile);
+  if (source)
+    profile->GetChromeURLDataManager()->AddDataSource(source);
 }
-
-bool WillHandleBrowserAboutURL(GURL* url,
-                               content::BrowserContext* browser_context) {
-  // TODO(msw): Eliminate "about:*" constants and literals from code and tests,
-  //            then hopefully we can remove this forced fixup.
-  *url = URLFixerUpper::FixupURL(url->possibly_invalid_spec(), std::string());
-
-  // Check that about: URLs are fixed up to chrome: by URLFixerUpper::FixupURL.
-  DCHECK((*url == GURL(chrome::kAboutBlankURL)) ||
-         !url->SchemeIs(chrome::kAboutScheme));
-
-  // Only handle chrome://foo/, URLFixerUpper::FixupURL translates about:foo.
-  // TAB_CONTENTS_WEB handles about:blank, which frames are allowed to access.
-  if (!url->SchemeIs(chrome::kChromeUIScheme))
-    return false;
-
-  // Circumvent processing URLs that the renderer process will handle.
-  if (chrome_about_handler::WillHandle(*url))
-    return false;
-
-  std::string host(url->host());
-  std::string path;
-  // Replace about with chrome-urls.
-  if (host == chrome::kChromeUIAboutHost)
-    host = chrome::kChromeUIChromeURLsHost;
-  // 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;
-  // Redirect chrome://extensions to chrome://settings/extensions.
-  } else if (host == chrome::kChromeUIExtensionsHost) {
-    host = chrome::kChromeUISettingsHost;
-    path = chrome::kExtensionsSubPage;
-  }
-  GURL::Replacements replacements;
-  replacements.SetHostStr(host);
-  if (!path.empty())
-    replacements.SetPathStr(path);
-  *url = url->ReplaceComponents(replacements);
-
-  // Handle URLs to crash the browser or wreck the gpu process.
-  if (host == chrome::kChromeUIBrowserCrashHost) {
-    // Induce an intentional crash in the browser process.
-    CHECK(false);
-  } else if (host == chrome::kChromeUIGpuCleanHost) {
-    GpuProcessHostUIShim* shim = GpuProcessHostUIShim::FromID(0);
-    if (shim)
-      shim->SimulateRemoveAllContext();
-  } else if (host == chrome::kChromeUIGpuCrashHost) {
-    GpuProcessHostUIShim* shim = GpuProcessHostUIShim::FromID(0);
-    if (shim)
-      shim->SimulateCrash();
-  } else if (host == chrome::kChromeUIGpuHangHost) {
-    GpuProcessHostUIShim* shim = GpuProcessHostUIShim::FromID(0);
-    if (shim)
-      shim->SimulateHang();
-#if defined(OS_CHROMEOS)
-  } else if (host == chrome::kChromeUIRotateHost) {
-    sensors::ScreenOrientation change;
-    std::string query(url->query());
-    if (query == "left") {
-      change.upward = sensors::ScreenOrientation::LEFT;
-    } else if (query == "right") {
-      change.upward = sensors::ScreenOrientation::RIGHT;
-    } else if (query == "top") {
-      change.upward = sensors::ScreenOrientation::TOP;
-    } else if (query == "bottom") {
-      change.upward = sensors::ScreenOrientation::BOTTOM;
-    } else {
-      NOTREACHED() << "Unknown orientation";
-    }
-    sensors::Provider::GetInstance()->ScreenOrientationChanged(change);
-    // Nothing to communicate to the user, so show a blank page.
-    host = chrome::kChromeUIBlankHost;
-    *url = GURL(chrome::kChromeUIBlankHost);
-#endif
-  }
-
-  // Initialize any potentially corresponding AboutSource handler.
-  InitializeAboutDataSource(host, browser_context);
-  return true;
-}
-
-bool HandleNonNavigationAboutURL(const GURL& url) {
-  // chrome://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)) {
-    // 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> ChromePaths() {
-  std::vector<std::string> paths;
-  paths.reserve(arraysize(kChromePaths));
-  for (size_t i = 0; i < arraysize(kChromePaths); i++)
-    paths.push_back(kChromePaths[i]);
-  return paths;
-}