Apply CSP to chrome: and about: pages

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 88 matching lines @@
 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/.
 // These paths will also be suggested by BuiltinProvider.
-const char* kChromePaths[] = {
+const char* const kChromePaths[] = {
   chrome::kChromeUIAppCacheInternalsHost,
   chrome::kChromeUIBlobInternalsHost,
   chrome::kChromeUIChromeURLsHost,
   chrome::kChromeUICrashesHost,
   chrome::kChromeUICreditsHost,
   chrome::kChromeUIDNSHost,
   chrome::kChromeUIFlagsHost,
   chrome::kChromeUIFlashHost,
   chrome::kChromeUIGpuInternalsHost,
   chrome::kChromeUIHistogramsHost,
@@ skipping 18 matching lines @@
 #endif
 #if defined(OS_CHROMEOS)
   chrome::kChromeUINetworkHost,
   chrome::kChromeUICryptohomeHost,
   chrome::kChromeUIOSCreditsHost,
 #endif
 };
 
 // Debug paths, presented without links in chrome://about.
 // These paths will not be suggested by BuiltinProvider.
-const char* kDebugChromePaths[] = {
+const char* const kDebugChromePaths[] = {
   chrome::kChromeUICrashHost,
   chrome::kChromeUIKillHost,
   chrome::kChromeUIHangHost,
   chrome::kChromeUIShorthangHost,
   chrome::kChromeUIGpuCleanHost,
   chrome::kChromeUIGpuCrashHost,
   chrome::kChromeUIGpuHangHost
 };
 
 // AboutSource handles these chrome:// paths.
-const char *kAboutSourceNames[] = {
+const char* const kAboutSourceNames[] = {
   chrome::kChromeUIChromeURLsHost,
   chrome::kChromeUICreditsHost,
   chrome::kChromeUIDNSHost,
   chrome::kChromeUIHistogramsHost,
   chrome::kChromeUIMemoryHost,
   chrome::kChromeUIMemoryRedirectHost,
   chrome::kChromeUIStatsHost,
   chrome::kChromeUITermsHost,
   chrome::kChromeUIVersionHost,
 #ifdef TRACK_ALL_TASK_OBJECTS
   chrome::kChromeUITasksHost,
 #endif
 #if defined(USE_TCMALLOC)
   chrome::kChromeUITCMallocHost,
 #endif
 #if defined(OS_LINUX)
   chrome::kChromeUILinuxProxyConfigHost,
   chrome::kChromeUISandboxHost,
 #endif
 #if defined(OS_CHROMEOS)
   chrome::kChromeUINetworkHost,
   chrome::kChromeUICryptohomeHost,
   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";
+
+}  // namespace

[jar (doing other things), 2011/06/27 18:50:19]

I find this jumping in and out of annonymous namespaces confusing (it is hard to
tell what has external linkage, and what doesn't).

Can you see a way to reorder to make this easier to follow?  Perhaps put the
class definition at a different point?  Other??  Should it be a todo, so that
you don't overcomplicate this CL?

+
 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&) const OVERRIDE {
-    return "text/html";
-  }
+  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);
 };
 
+namespace {
+
 // Register a data source for a known source name. Safe to call multiple times.
 // |name| may be an unkown host (e.g. "chrome://foo/"); only handle known hosts.
 void InitializeAboutDataSource(const std::string& name, Profile* profile) {
   ChromeURLDataManager* manager = profile->GetChromeURLDataManager();
   for (size_t i = 0; i < arraysize(kAboutSourceNames); i++) {
     if (name == kAboutSourceNames[i]) {
       manager->AddDataSource(new AboutSource(name, profile));
       return;
     }
   }
@@ skipping 128 matching lines @@
 
   std::string contents_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeOSTermsHandler);
 };
 
 #endif
 
 // Individual about handlers ---------------------------------------------------
 
+namespace {
+
+void AppendHeader(std::string* output, int refresh,
+                  const std::string& unescaped_title) {
+  output->append("<!DOCTYPE HTML>\n<html>\n<head>\n");
+  if (!unescaped_title.empty()) {
+    output->append("<title>");
+    output->append(EscapeForHTML(unescaped_title));
+    output->append("</title>\n");
+  }
+  output->append(
+      "<meta charset=\"utf-8\">\n<meta http-equiv=\"X-WebKit-CSP\" "
+      "content=\"object-src 'none'; script-src 'self' 'unsafe-eval'\">\n");
+  if (refresh > 0) {
+    output->append("<meta http-equiv=\"refresh\" content=\"");
+    output->append(base::IntToString(refresh));
+    output->append("\"/>\n");
+  }
+}
+
+void AppendBody(std::string *output) {
+  output->append("</head>\n<body>\n");
+}
+
+void AppendFooter(std::string *output) {
+  output->append("</body>\n</html>\n");
+}
+
 std::string ChromeURLs() {
-  std::string html("<html><head><title>Chrome URLs</title></head>\n"
-      "<body><h2>List of Chrome URLs</h2>\n<ul>");
+  std::string html;
+  AppendHeader(&html, 0, "Chrome URLs");
+  AppendBody(&html);
+  html += "<h2>List of Chrome URLs</h2>\n<ul>\n";
   std::vector<std::string> paths(ChromePaths());
   for (std::vector<std::string>::const_iterator i = paths.begin();
        i != paths.end(); ++i)
     html += "<li><a href='chrome://" + *i + "/'>chrome://" + *i + "</a></li>\n";
   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(kDebugChromePaths); i++)
     html += "<li>chrome://" + std::string(kDebugChromePaths[i]) + "</li>\n";
-  html += "</ul>\n</body></html>";
+  html += "</ul>\n";
+  AppendFooter(&html);
   return html;
 }
 
 #if defined(OS_CHROMEOS)
 
-namespace {
 // Html output helper functions
 // TODO(stevenjb): L10N this.
 
 // Helper function to wrap Html with <th> tag.
 std::string WrapWithTH(const std::string& text) {
   return "<th>" + text + "</th>";
 }
 
 // Helper function to wrap Html with <td> tag.
 std::string WrapWithTD(const std::string& text) {
   return "<td>" + text + "</td>";
 }
 
 // Helper function to wrap Html with <tr> tag.
 std::string WrapWithTR(const std::string& text) {
   return "<tr>" + text + "</tr>";
 }
 
-std::string AboutHeader(int refresh, const std::string& name) {
-  std::string output;
-  output.append("<head>");
-  output.append("<title>About " + name + "</title>");
-  if (refresh > 0)
-    output.append("<meta http-equiv=\"refresh\" content=\"" +
-                  base::IntToString(refresh) + "\"/>");
-  output.append("</head>");
-  return output;
-}
-
-std::string AboutRefresh(int refresh, const std::string& name) {
-  std::string output;
+void AppendRefresh(std::string *output, int refresh, const std::string& name) {
   if (refresh > 0) {
-    output.append("(Auto-refreshing page every " +
-                  base::IntToString(refresh) + "s)");
+    output->append("(Auto-refreshing page every ");
+    output->append(base::IntToString(refresh));
+    output->append("s)");
   } else {
-    output.append("(To auto-refresh this page: about:" + name
-                  + "/&lt;secs&gt;)");
+    output->append("(To auto-refresh this page: about:");
+    output->append(name);
+    output->append("/&lt;secs&gt;)");
   }
-  return output;
 }
 
 // Helper function to create an Html table header for a Network.
 std::string ToHtmlTableHeader(const chromeos::Network* network) {
   std::string str =
       WrapWithTH("Name") +
       WrapWithTH("Active") +
       WrapWithTH("State");
   if (network->type() == chromeos::TYPE_WIFI ||
       network->type() == chromeos::TYPE_CELLULAR) {
@@ skipping 61 matching lines @@
   }
   str += WrapWithTD(network->failed() ? network->GetErrorString() : "");
   str += WrapWithTD(network->ip_address());
   return WrapWithTR(str);
 }
 
 std::string GetNetworkHtmlInfo(int refresh) {
   chromeos::NetworkLibrary* cros =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   std::string output;
-  output.append("<html>");
-  output.append(AboutHeader(refresh, "Network"));
-  output.append("<body>");
-  output.append(AboutRefresh(refresh, "network"));
+  AppendHeader(&output, refresh, "About Network");
+  AppendBody(&output);
+  AppendRefresh(&output, refresh, "network");
 
   if (cros->ethernet_enabled()) {
     output.append("<h3>Ethernet:</h3><table border=1>");
     const chromeos::EthernetNetwork* ethernet = cros->ethernet_network();
     if (ethernet) {
       output.append(ToHtmlTableHeader(ethernet));
       output.append(ToHtmlTableRow(ethernet));
     }
   }
 
@@ skipping 35 matching lines @@
     const chromeos::WifiNetworkVector& remembered_wifi_networks =
         cros->remembered_wifi_networks();
     for (size_t i = 0; i < remembered_wifi_networks.size(); ++i) {
       if (i == 0)
         output.append(
             ToHtmlTableHeader(remembered_wifi_networks[i]));
       output.append(ToHtmlTableRow(remembered_wifi_networks[i]));
     }
   }
 
-  output.append("</table></body></html>");
+  output.append("</table>");
+  AppendFooter(&output);
   return output;
 }
 
 std::string AboutNetwork(const std::string& query) {
   int refresh;
   base::StringToInt(query, &refresh);
   return GetNetworkHtmlInfo(refresh);
 }
 
 std::string AddBoolRow(const std::string& name, bool value) {
   std::string row;
   row.append(WrapWithTD(name));
   row.append(WrapWithTD(value ? "true" : "false"));
   return WrapWithTR(row);
 }
 
 std::string AddStringRow(const std::string& name, const std::string& value) {
   std::string row;
   row.append(WrapWithTD(name));
   row.append(WrapWithTD(value));
   return WrapWithTR(row);
 }
 
 std::string GetCryptohomeHtmlInfo(int refresh) {
   chromeos::CryptohomeLibrary* cryptohome =
       chromeos::CrosLibrary::Get()->GetCryptohomeLibrary();
   std::string output;
-  output.append("<html>");
-  output.append(AboutHeader(refresh, "Cryptohome"));
-  output.append("<body>");
-  output.append(AboutRefresh(refresh, "cryptohome"));
+  AppendHeader(&output, refresh, "About Cryptohome");
+  AppendBody(&output);
+  AppendRefresh(&output, refresh, "cryptohome");
 
   output.append("<h3>CryptohomeLibrary:</h3>");
   output.append("<table>");
   output.append(AddBoolRow("IsMounted", cryptohome->IsMounted()));
   output.append(AddBoolRow("TpmIsReady", cryptohome->TpmIsReady()));
   output.append(AddBoolRow("TpmIsEnabled", cryptohome->TpmIsEnabled()));
   output.append(AddBoolRow("TpmIsOwned", cryptohome->TpmIsOwned()));
   output.append(AddBoolRow("TpmIsBeingOwned", cryptohome->TpmIsBeingOwned()));
   output.append(AddBoolRow("Pkcs11IsTpmTokenReady",
                            cryptohome->Pkcs11IsTpmTokenReady()));
   output.append("</table>");
 
   std::string token_name, user_pin;
   crypto::GetTPMTokenInfo(&token_name, &user_pin);
   output.append("<h3>crypto:</h3>");
   output.append("<table>");
   output.append(AddBoolRow("IsTPMTokenReady", crypto::IsTPMTokenReady()));
   output.append(AddStringRow("token_name", token_name));
   output.append(AddStringRow("user_pin", std::string(user_pin.length(), '*')));
   output.append("</table>");
+  AppendFooter(&output);
 
-  output.append("</body>");
-  output.append("</html>");
   return output;
 }
 
 std::string AboutCryptohome(const std::string& query) {
   int refresh;
   base::StringToInt(query, &refresh);
   return GetCryptohomeHtmlInfo(refresh);
 }
 
+#endif  // OS_CHROMEOS
+
 }  // namespace
-#endif
 
 // 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) {
     scoped_refptr<AboutDnsHandler> handler(
         new AboutDnsHandler(source, request_id));
     handler->StartOnUIThread();
   }
@@ skipping 10 matching lines @@
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         NewRunnableMethod(this, &AboutDnsHandler::StartOnIOThread));
   }
 
   void StartOnIOThread() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 
     std::string data;
+    AppendHeader(&data, 0, "About DNS");
+    AppendBody(&data);
     chrome_browser_net::PredictorGetHtmlInfo(&data);
+    AppendFooter(&data);
 
     BrowserThread::PostTask(
         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_;
 
   // ID identifying the request.
   int request_id_;
 
   DISALLOW_COPY_AND_ASSIGN(AboutDnsHandler);
 };
 
 #if defined(USE_TCMALLOC)
 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");
+  AppendHeader(&data, 0, "About tcmalloc");
+  AppendBody(&data);
   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();
        oit != outputs->end();
        oit++) {
     data.append("<tr><td bgcolor=\"yellow\">");
     data.append(oit->first);
     data.append("</td></tr>\n");
     data.append("<tr><td><pre>\n");
     data.append(oit->second);
     data.append("</pre></td></tr>\n");
   }
   data.append("</table>\n");
-  data.append("</body></html>\n");
+  AppendFooter(&data);
 
   // Reset our collector singleton.
   outputs->clear();
 
   // Populate the collector with stats from the local browser process
   // and send off requests to all the renderer processes.
   char buffer[1024 * 32];
   MallocExtension::instance()->GetStats(buffer, sizeof(buffer));
   std::string browser("Browser");
   AboutTcmallocOutputs::GetInstance()->SetOutput(browser, buffer);
   RenderProcessHost::iterator it(RenderProcessHost::AllHostsIterator());
   while (!it.IsAtEnd()) {
     it.GetCurrentValue()->Send(new ViewMsg_GetRendererTcmalloc);
     it.Advance();
   }
 
   return data;
 }
 #endif
 
 std::string AboutHistograms(const std::string& query) {
   TimeDelta wait_time = TimeDelta::FromMilliseconds(10000);
 
   HistogramSynchronizer* current_synchronizer =
       HistogramSynchronizer::CurrentSynchronizer();
   DCHECK(current_synchronizer != NULL);
   current_synchronizer->FetchRendererHistogramsSynchronously(wait_time);
 
+  std::string unescaped_query;
+  std::string unescaped_title("About Histograms");
+  if (!query.empty()) {
+    unescaped_query = UnescapeURLComponent(query, UnescapeRule::NORMAL);
+    unescaped_title += " - " + unescaped_query;
+  }
+
   std::string data;
-  base::StatisticsRecorder::WriteHTMLGraph(query, &data);
+  AppendHeader(&data, 0, unescaped_title);
+  AppendBody(&data);
+  base::StatisticsRecorder::WriteHTMLGraph(unescaped_query, &data);
+  AppendFooter(&data);
   return data;
 }
 
-void AboutMemory(AboutSource* source, int request_id) {
-  // 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();
+void AboutMemory(const std::string& path, AboutSource* source, int request_id) {
+  if (path == kStringsJsPath) {
+    // 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);
+  }
 }
 
 #ifdef TRACK_ALL_TASK_OBJECTS
 static std::string AboutObjects(const std::string& query) {
+  std::string unescaped_title("About Histograms");
+  if (!query.empty()) {
+    unescaped_title += " - ";
+    unescaped_title += UnescapeURLComponent(query, UnescapeRule::NORMAL);
+  }
   std::string data;
+  AppendHeader(&data, 0, unescaped_title);
+  AppendBody(&data);
   tracked_objects::ThreadData::WriteHTML(query, &data);
+  AppendFooter(&data);
   return data;
 }
 #endif  // TRACK_ALL_TASK_OBJECTS
 
 // Handler for filling in the "about:stats" page, as called by the browser's
 // About handler processing.
 // |query| is roughly the query string of the about:stats URL.
 // Returns a string containing the HTML to render for the about:stats page.
 // Conditional Output:
 //      if |query| is "json", returns a JSON format of all counters.
@@ skipping 89 matching lines @@
           // Store this on the timers list as well.
           timers->Append(counter);
         }
         break;
       default:
         NOTREACHED();
     }
   }
 
   std::string data;
-  if (query == "json") {
+  if (query == "json" || query == kStringsJsPath) {
     base::JSONWriter::WriteWithOptionalEscape(&root, true, false, &data);
+    if (query == kStringsJsPath)
+      data = "var templateData = " + data + ";";
   } else if (query == "raw") {
     // Dump the raw counters which have changed in text format.
     data = "<pre>";
     data.append(StringPrintf("Counter changes in the last %ldms\n",
         static_cast<long int>(time_since_last_sample.InMilliseconds())));
     for (size_t i = 0; i < counters->GetSize(); ++i) {
       Value* entry = NULL;
       bool rv = counters->Get(i, &entry);
       if (!rv)
         continue;  // None of these should fail.
@@ skipping 12 matching lines @@
         if (!rv)
           continue;
         data.append(name);
         data.append(":");
         data.append(base::IntToString(delta));
         data.append("\n");
       }
     }
     data.append("</pre>");
   } else {
-    // Get about_stats.html and process a pretty page.
-    static const base::StringPiece stats_html(
-        ResourceBundle::GetSharedInstance().GetRawDataResource(
-            IDR_ABOUT_STATS_HTML));
+    // Get about_stats.html/js from resource bundle.
+    data = ResourceBundle::GetSharedInstance().GetRawDataResource(
+        (query == kStatsJsPath ? IDR_ABOUT_STATS_JS : IDR_ABOUT_STATS_HTML)).
+        as_string();
 
-    // Create jstemplate and return.
-    data = jstemplate_builder::GetTemplateHtml(
-        stats_html, &root, "t" /* template root node id */);
-
-    // Clear the timer list since we stored the data in the timers list as well.
-    for (int index = static_cast<int>(timers->GetSize())-1; index >= 0;
-         index--) {
-      Value* value;
-      timers->Remove(index, &value);
-      // We don't care about the value pointer; it's still tracked
-      // on the counters list.
+    if (query != kStatsJsPath) {
+      // Clear the timer list since we stored the data in the timers list
+      // as well.
+      for (int index = static_cast<int>(timers->GetSize())-1; index >= 0;
+           index--) {
+        Value* value;
+        timers->Remove(index, &value);
+        // We don't care about the value pointer; it's still tracked
+        // on the counters list.
+      }
     }
   }
 
   return data;
 }
 
 #if defined(OS_LINUX)
 std::string AboutLinuxProxyConfig() {
   std::string data;
-  data.append("<!DOCTYPE HTML>\n");
-  data.append("<html><head><meta charset=\"utf-8\"><title>");
-  data.append(l10n_util::GetStringUTF8(IDS_ABOUT_LINUX_PROXY_CONFIG_TITLE));
-  data.append("</title>");
+  AppendHeader(&data, 0,
+               l10n_util::GetStringUTF8(IDS_ABOUT_LINUX_PROXY_CONFIG_TITLE));
   data.append("<style>body { max-width: 70ex; padding: 2ex 5ex; }</style>");
-  data.append("</head><body>\n");
+  AppendBody(&data);
   FilePath binary = CommandLine::ForCurrentProcess()->GetProgram();
   data.append(l10n_util::GetStringFUTF8(
-                  IDS_ABOUT_LINUX_PROXY_CONFIG_BODY,
-                  l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
-                  ASCIIToUTF16(binary.BaseName().value())));
-  data.append("</body></html>\n");
+      IDS_ABOUT_LINUX_PROXY_CONFIG_BODY,
+      l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
+      ASCIIToUTF16(binary.BaseName().value())));
+  AppendFooter(&data);
   return data;
 }
 
 void AboutSandboxRow(std::string* data, const std::string& prefix, int name_id,
                      bool good) {
   data->append("<tr><td>");
   data->append(prefix);
   data->append(l10n_util::GetStringUTF8(name_id));
   if (good) {
     data->append("</td><td style=\"color: green;\">");
     data->append(
         l10n_util::GetStringUTF8(IDS_CONFIRM_MESSAGEBOX_YES_BUTTON_LABEL));
   } else {
     data->append("</td><td style=\"color: red;\">");
     data->append(
         l10n_util::GetStringUTF8(IDS_CONFIRM_MESSAGEBOX_NO_BUTTON_LABEL));
   }
   data->append("</td></tr>");
 }
 
 std::string AboutSandbox() {
   std::string data;
-  data.append("<!DOCTYPE HTML>\n");
-  data.append("<html><head><meta charset=\"utf-8\"><title>");
-  data.append(l10n_util::GetStringUTF8(IDS_ABOUT_SANDBOX_TITLE));
-  data.append("</title>");
-  data.append("</head><body>\n");
+  AppendHeader(&data, 0, l10n_util::GetStringUTF8(IDS_ABOUT_SANDBOX_TITLE));
+  AppendBody(&data);
   data.append("<h1>");
   data.append(l10n_util::GetStringUTF8(IDS_ABOUT_SANDBOX_TITLE));
   data.append("</h1>");
 
   const int status = ZygoteHost::GetInstance()->sandbox_status();
 
   data.append("<table>");
 
   AboutSandboxRow(&data, "", IDS_ABOUT_SANDBOX_SUID_SANDBOX,
                   status & ZygoteHost::kSandboxSUID);
@@ skipping 11 matching lines @@
               (status & ZygoteHost::kSandboxSeccomp);
   if (good) {
     data.append("<p style=\"color: green\">");
     data.append(l10n_util::GetStringUTF8(IDS_ABOUT_SANDBOX_OK));
   } else {
     data.append("<p style=\"color: red\">");
     data.append(l10n_util::GetStringUTF8(IDS_ABOUT_SANDBOX_BAD));
   }
   data.append("</p>");
 
-  data.append("</body></html>\n");
+  AppendFooter(&data);
   return data;
 }
 #endif
 
-std::string AboutVersion(DictionaryValue* localized_strings, Profile* profile) {
+std::string AboutVersionStaticContent(const std::string& query) {
+  return ResourceBundle::GetSharedInstance().GetRawDataResource(
+      query ==  kVersionJsPath ?
+      IDR_ABOUT_VERSION_JS :
+      IDR_ABOUT_VERSION_HTML).as_string();
+}
+
+std::string AboutVersionStrings(DictionaryValue* localized_strings,
+                                Profile* profile) {
   localized_strings->SetString("title",
       l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_TITLE));
   chrome::VersionInfo version_info;
 
   std::string webkit_version = webkit_glue::GetWebKitVersion();
 #ifdef CHROME_V8
   std::string js_version(v8::V8::GetVersion());
   std::string js_engine = "V8";
 #else
   std::string js_version = webkit_version;
@@ skipping 79 matching lines @@
       localized_strings->SetString("profile_path", profile_path.value());
     } else {
       localized_strings->SetString("profile_path",
           l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_PATH_NOTFOUND));
     }
   } else {
     localized_strings->SetString("profile_path",
         l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_PATH_NOTFOUND));
   }
 
-  base::StringPiece version_html(
-      ResourceBundle::GetSharedInstance().GetRawDataResource(
-          IDR_ABOUT_VERSION_HTML));
+  std::string data;
+  jstemplate_builder::AppendJsonJS(localized_strings, &data);
+  return data;
+}
 
-  return jstemplate_builder::GetTemplatesHtml(
-      version_html, localized_strings, "t" /* template root node id */);
-}
+}  // namespace
 
 // AboutSource -----------------------------------------------------------------
 
 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,
                                    bool is_incognito,
                                    int request_id) {
   std::string response;
   std::string host = source_name();
   if (host == chrome::kChromeUIDNSHost) {
     AboutDnsHandler::Start(this, request_id);
     return;
   } 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);
+    AboutMemory(path, this, request_id);
     return;
 #ifdef TRACK_ALL_TASK_OBJECTS
   } else if (host == chrome::kChromeUITasksHost) {
     response = AboutObjects(path);
 #endif
   } else if (host == chrome::kChromeUIStatsHost) {
     response = AboutStats(path);
 #if defined(USE_TCMALLOC)
   } else if (host == chrome::kChromeUITCMallocHost) {
     response = AboutTcmalloc();
 #endif
   } else if (host == chrome::kChromeUIVersionHost) {
+    if (path == kStringsJsPath) {
 #if defined(OS_CHROMEOS)
-    new ChromeOSAboutVersionHandler(this, request_id);
-    return;
+      new ChromeOSAboutVersionHandler(this, request_id);
+      return;
 #else
-    DictionaryValue localized_strings;
-    localized_strings.SetString("os_version", "");
-    response = AboutVersion(&localized_strings, profile_);
+      DictionaryValue localized_strings;
+      localized_strings.SetString("os_version", "");
+      response = AboutVersionStrings(&localized_strings, profile_);
 #endif
+    } else {
+      response = AboutVersionStaticContent(path);
+    }
   } else if (host == chrome::kChromeUICreditsHost) {
+    int idr = (path == kCreditsJsPath) ? IDR_CREDITS_JS : IDR_CREDITS_HTML;
     response = ResourceBundle::GetSharedInstance().GetRawDataResource(
-        IDR_CREDITS_HTML).as_string();
+        idr).as_string();
   } else if (host == chrome::kChromeUIChromeURLsHost) {
     response = ChromeURLs();
 #if defined(OS_CHROMEOS)
   } else if (host == chrome::kChromeUIOSCreditsHost) {
     response = ResourceBundle::GetSharedInstance().GetRawDataResource(
         IDR_OS_CREDITS_HTML).as_string();
   } else if (host == chrome::kChromeUINetworkHost) {
     response = AboutNetwork(path);
   } else if (host == chrome::kChromeUICryptohomeHost) {
     response = AboutCryptohome(path);
@@ skipping 17 matching lines @@
   FinishDataRequest(response, request_id);
 }
 
 void AboutSource::FinishDataRequest(const std::string& html, int request_id) {
   scoped_refptr<RefCountedBytes> html_bytes(new RefCountedBytes);
   html_bytes->data.resize(html.size());
   std::copy(html.begin(), html.end(), html_bytes->data.begin());
   SendResponse(request_id, html_bytes);
 }
 
+std::string AboutSource::GetMimeType(const std::string& path) const {
+  if (path == kCreditsJsPath ||
+      path == kStatsJsPath   ||
+      path == kStringsJsPath ||
+      path == kVersionJsPath ||
+      path == kMemoryJsPath) {
+    return "application/javascript";
+  }
+  return "text/html";
+}
+
+namespace {

[jar (doing other things), 2011/06/27 18:50:19]

Where is the matching curly?

+
 // 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) {
   DCHECK(data && info);
 
   // Bind metrics to dictionary.
@@ skipping 101 matching lines @@
   for (size_t index = 0; index < process.processes.size(); index++) {
     if (process.processes[index].type == ChildProcessInfo::BROWSER_PROCESS)
       BindProcessMetrics(browser_data, &process.processes[index]);
     else
       AppendProcess(child_data, &process.processes[index]);
   }
 
   root.SetBoolean("show_other_browsers",
       browser_defaults::kShowOtherBrowsersInAboutMemory);
 
-  // Get about_memory.html
-  static const base::StringPiece memory_html(
-      ResourceBundle::GetSharedInstance().GetRawDataResource(
-          IDR_ABOUT_MEMORY_HTML));
-
-  // Create jstemplate and return.
-  std::string template_html = jstemplate_builder::GetTemplateHtml(
-      memory_html, &root, "t" /* template root node id */);
-
-  source_->FinishDataRequest(template_html, request_id_);
+  std::string data;
+  jstemplate_builder::AppendJsonJS(&root, &data);
+  source_->FinishDataRequest(data, request_id_);
 }
 
 #if defined(OS_CHROMEOS)
 // ChromeOSAboutVersionHandler  -----------------------------------------------
 
-ChromeOSAboutVersionHandler::ChromeOSAboutVersionHandler(AboutSource* source,
-                                                         int request_id)
+ChromeOSAboutVersionHandler::ChromeOSAboutVersionHandler(
+    AboutSource* source,
+    int request_id)
     : source_(source),
       request_id_(request_id) {
   loader_.EnablePlatformVersions(true);
   loader_.GetVersion(&consumer_,
                      NewCallback(this, &ChromeOSAboutVersionHandler::OnVersion),
                      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(AboutVersion(&localized_strings,
-                                          source_->profile()), request_id_);
+  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
 
@@ skipping 71 matching lines @@
   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;
 }