src/chrome/browser/ui/webui/about_ui.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chrome/browser/ui/webui/about_ui.h"
   6
   7 #include <algorithm>
   8 #include <string>
   9 #include <utility>
  10 #include <vector>
  11
  12 #include "base/bind.h"
  13 #include "base/bind_helpers.h"
  14 #include "base/callback.h"
  15 #include "base/command_line.h"
  16 #include "base/file_util.h"
  17 #include "base/i18n/number_formatting.h"
  18 #include "base/json/json_writer.h"
  19 #include "base/memory/singleton.h"
  20 #include "base/metrics/statistics_recorder.h"
  21 #include "base/metrics/stats_table.h"
  22 #include "base/path_service.h"
  23 #include "base/strings/string_number_conversions.h"
  24 #include "base/strings/string_piece.h"
  25 #include "base/strings/string_util.h"
  26 #include "base/strings/stringprintf.h"
  27 #include "base/strings/utf_string_conversions.h"
  28 #include "base/threading/thread.h"
  29 #include "base/values.h"
  30 #include "chrome/browser/about_flags.h"
  31 #include "chrome/browser/browser_process.h"
  32 #include "chrome/browser/defaults.h"
  33 #include "chrome/browser/memory_details.h"
  34 #include "chrome/browser/net/predictor.h"
  35 #include "chrome/browser/profiles/profile.h"
  36 #include "chrome/browser/profiles/profile_manager.h"
  37 #include "chrome/browser/ui/browser_dialogs.h"
  38 #include "chrome/common/chrome_paths.h"
  39 #include "chrome/common/render_messages.h"
  40 #include "chrome/common/url_constants.h"
  41 #include "content/public/browser/browser_thread.h"
  42 #include "content/public/browser/render_process_host.h"
  43 #include "content/public/browser/render_view_host.h"
  44 #include "content/public/browser/url_data_source.h"
  45 #include "content/public/browser/web_contents.h"
  46 #include "content/public/common/content_client.h"
  47 #include "content/public/common/process_type.h"
  48 #include "google_apis/gaia/google_service_auth_error.h"
  49 #include "grit/browser_resources.h"
  50 #include "grit/chromium_strings.h"
  51 #include "grit/generated_resources.h"
  52 #include "grit/locale_settings.h"
  53 #include "net/base/escape.h"
  54 #include "net/base/filename_util.h"
  55 #include "net/base/load_flags.h"
  56 #include "net/http/http_response_headers.h"
  57 #include "net/url_request/url_fetcher.h"
  58 #include "net/url_request/url_request_status.h"
  59 #include "ui/base/l10n/l10n_util.h"
  60 #include "ui/base/resource/resource_bundle.h"
  61 #include "ui/base/webui/jstemplate_builder.h"
  62 #include "ui/base/webui/web_ui_util.h"
  63 #include "url/gurl.h"
  64
  65 #if defined(ENABLE_THEMES)
  66 #include "chrome/browser/ui/webui/theme_source.h"
  67 #endif
  68
  69 #if defined(OS_LINUX) || defined(OS_OPENBSD)
  70 #include "content/public/browser/zygote_host_linux.h"
  71 #include "content/public/common/sandbox_linux.h"
  72 #endif
  73
  74 #if defined(OS_WIN)
  75 #include "chrome/browser/enumerate_modules_model_win.h"
  76 #endif
  77
  78 #if defined(OS_CHROMEOS)
  79 #include "chrome/browser/browser_process_platform_part_chromeos.h"
  80 #include "chrome/browser/chromeos/customization_document.h"
  81 #include "chrome/browser/chromeos/memory/oom_priority_manager.h"
  82 #endif
  83
  84 using base::Time;
  85 using base::TimeDelta;
  86 using content::BrowserThread;
  87 using content::WebContents;
  88
  89 namespace {
  90
  91 const char kCreditsJsPath[] = "credits.js";
  92 const char kKeyboardUtilsPath[] = "keyboard_utils.js";
  93 const char kMemoryJsPath[] = "memory.js";
  94 const char kMemoryCssPath[] = "about_memory.css";
  95 const char kStatsJsPath[] = "stats.js";
  96 const char kStringsJsPath[] = "strings.js";
  97
  98 #if defined(OS_CHROMEOS)
  99 // chrome://terms falls back to offline page after kOnlineTermsTimeoutSec.
 100 const int kOnlineTermsTimeoutSec = 7;
 101 #endif  // defined(OS_CHROMEOS)
 102
 103 // When you type about:memory, it actually loads this intermediate URL that
 104 // redirects you to the final page. This avoids the problem where typing
 105 // "about:memory" on the new tab page or any other page where a process
 106 // transition would occur to the about URL will cause some confusion.
 107 //
 108 // The problem is that during the processing of the memory page, there are two
 109 // processes active, the original and the destination one. This can create the
 110 // impression that we're using more resources than we actually are. This
 111 // redirect solves the problem by eliminating the process transition during the
 112 // time that about memory is being computed.
 113 std::string GetAboutMemoryRedirectResponse(Profile* profile) {
 114   return base::StringPrintf("<meta http-equiv='refresh' content='0;%s'>",
 115                             chrome::kChromeUIMemoryRedirectURL);
 116 }
 117
 118 // Handling about:memory is complicated enough to encapsulate its related
 119 // methods into a single class. The user should create it (on the heap) and call
 120 // its |StartFetch()| method.
 121 class AboutMemoryHandler : public MemoryDetails {
 122  public:
 123   explicit AboutMemoryHandler(
 124       const content::URLDataSource::GotDataCallback& callback)
 125       : callback_(callback) {
 126   }
 127
 128   virtual void OnDetailsAvailable() OVERRIDE;
 129
 130  private:
 131   virtual ~AboutMemoryHandler() {}
 132
 133   void BindProcessMetrics(base::DictionaryValue* data,
 134                           ProcessMemoryInformation* info);
 135   void AppendProcess(base::ListValue* child_data,
 136                      ProcessMemoryInformation* info);
 137
 138   content::URLDataSource::GotDataCallback callback_;
 139
 140   DISALLOW_COPY_AND_ASSIGN(AboutMemoryHandler);
 141 };
 142
 143 #if defined(OS_CHROMEOS)
 144
 145 // Helper class that fetches the online Chrome OS terms. Empty string is
 146 // returned once fetching failed or exceeded |kOnlineTermsTimeoutSec|.
 147 class ChromeOSOnlineTermsHandler : public net::URLFetcherDelegate {
 148  public:
 149   typedef base::Callback<void (ChromeOSOnlineTermsHandler*)> FetchCallback;
 150
 151   explicit ChromeOSOnlineTermsHandler(const FetchCallback& callback,
 152                                       const std::string& locale)
 153       : fetch_callback_(callback) {
 154     std::string eula_URL = base::StringPrintf(chrome::kOnlineEulaURLPath,
 155                                               locale.c_str());
 156     eula_fetcher_.reset(net::URLFetcher::Create(0 /* ID used for testing */,
 157                                                 GURL(eula_URL),
 158                                                 net::URLFetcher::GET,
 159                                                 this));
 160     eula_fetcher_->SetRequestContext(
 161         g_browser_process->system_request_context());
 162     eula_fetcher_->AddExtraRequestHeader("Accept: text/html");
 163     eula_fetcher_->SetLoadFlags(net::LOAD_DO_NOT_SEND_COOKIES |
 164                                 net::LOAD_DO_NOT_SAVE_COOKIES |
 165                                 net::LOAD_DISABLE_CACHE);
 166     eula_fetcher_->Start();
 167     // Abort the download attempt if it takes longer than one minute.
 168     download_timer_.Start(FROM_HERE,
 169                           base::TimeDelta::FromSeconds(kOnlineTermsTimeoutSec),
 170                           this,
 171                           &ChromeOSOnlineTermsHandler::OnDownloadTimeout);
 172   }
 173
 174   void GetResponseResult(std::string* response_string) {
 175     std::string mime_type;
 176     if (!eula_fetcher_ ||
 177         !eula_fetcher_->GetStatus().is_success() ||
 178         eula_fetcher_->GetResponseCode() != 200 ||
 179         !eula_fetcher_->GetResponseHeaders()->GetMimeType(&mime_type) ||
 180         mime_type != "text/html" ||
 181         !eula_fetcher_->GetResponseAsString(response_string)) {
 182       response_string->clear();
 183     }
 184   }
 185
 186  private:
 187   // Prevents allocation on the stack. ChromeOSOnlineTermsHandler should be
 188   // created by 'operator new'. |this| takes care of destruction.
 189   virtual ~ChromeOSOnlineTermsHandler() {}
 190
 191   // net::URLFetcherDelegate:
 192   virtual void OnURLFetchComplete(const net::URLFetcher* source) OVERRIDE {
 193     if (source != eula_fetcher_.get()) {
 194       NOTREACHED() << "Callback from foreign URL fetcher";
 195       return;
 196     }
 197     fetch_callback_.Run(this);
 198     delete this;
 199   }
 200
 201   void OnDownloadTimeout() {
 202     eula_fetcher_.reset();
 203     fetch_callback_.Run(this);
 204     delete this;
 205   }
 206
 207   // Timer that enforces a timeout on the attempt to download the
 208   // ChromeOS Terms.
 209   base::OneShotTimer<ChromeOSOnlineTermsHandler> download_timer_;
 210
 211   // |fetch_callback_| called when fetching succeeded or failed.
 212   FetchCallback fetch_callback_;
 213
 214   // Helper to fetch online eula.
 215   scoped_ptr<net::URLFetcher> eula_fetcher_;
 216
 217   DISALLOW_COPY_AND_ASSIGN(ChromeOSOnlineTermsHandler);
 218 };
 219
 220 class ChromeOSTermsHandler
 221     : public base::RefCountedThreadSafe<ChromeOSTermsHandler> {
 222  public:
 223   static void Start(const std::string& path,
 224                     const content::URLDataSource::GotDataCallback& callback) {
 225     scoped_refptr<ChromeOSTermsHandler> handler(
 226         new ChromeOSTermsHandler(path, callback));
 227     handler->StartOnUIThread();
 228   }
 229
 230  private:
 231   friend class base::RefCountedThreadSafe<ChromeOSTermsHandler>;
 232
 233   ChromeOSTermsHandler(const std::string& path,
 234                        const content::URLDataSource::GotDataCallback& callback)
 235     : path_(path),
 236       callback_(callback),
 237       // Previously we were using "initial locale" http://crbug.com/145142
 238       locale_(g_browser_process->GetApplicationLocale()) {
 239   }
 240
 241   virtual ~ChromeOSTermsHandler() {}
 242
 243   void StartOnUIThread() {
 244     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 245     if (path_ == chrome::kOemEulaURLPath) {
 246       // Load local OEM EULA from the disk.
 247       BrowserThread::PostTask(
 248           BrowserThread::FILE, FROM_HERE,
 249           base::Bind(&ChromeOSTermsHandler::LoadOemEulaFileOnFileThread, this));
 250     } else {
 251       // Try to load online version of ChromeOS terms first.
 252       // ChromeOSOnlineTermsHandler object destroys itself.
 253       new ChromeOSOnlineTermsHandler(
 254           base::Bind(&ChromeOSTermsHandler::OnOnlineEULAFetched, this),
 255           locale_);
 256     }
 257   }
 258
 259   void OnOnlineEULAFetched(ChromeOSOnlineTermsHandler* loader) {
 260     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 261     loader->GetResponseResult(&contents_);
 262     if (contents_.empty()) {
 263       // Load local ChromeOS terms from the file.
 264       BrowserThread::PostTask(
 265           BrowserThread::FILE, FROM_HERE,
 266           base::Bind(&ChromeOSTermsHandler::LoadEulaFileOnFileThread, this));
 267     } else {
 268       ResponseOnUIThread();
 269     }
 270   }
 271
 272   void LoadOemEulaFileOnFileThread() {
 273     DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 274     const chromeos::StartupCustomizationDocument* customization =
 275         chromeos::StartupCustomizationDocument::GetInstance();
 276     if (customization->IsReady()) {
 277       base::FilePath oem_eula_file_path;
 278       if (net::FileURLToFilePath(GURL(customization->GetEULAPage(locale_)),
 279                                  &oem_eula_file_path)) {
 280         if (!base::ReadFileToString(oem_eula_file_path, &contents_)) {
 281           contents_.clear();
 282         }
 283       }
 284     }
 285     BrowserThread::PostTask(
 286         BrowserThread::UI, FROM_HERE,
 287         base::Bind(&ChromeOSTermsHandler::ResponseOnUIThread, this));
 288   }
 289
 290   void LoadEulaFileOnFileThread() {
 291     std::string file_path =
 292         base::StringPrintf(chrome::kEULAPathFormat, locale_.c_str());
 293     if (!base::ReadFileToString(base::FilePath(file_path), &contents_)) {
 294       // No EULA for given language - try en-US as default.
 295       file_path = base::StringPrintf(chrome::kEULAPathFormat, "en-US");
 296       if (!base::ReadFileToString(base::FilePath(file_path), &contents_)) {
 297         // File with EULA not found, ResponseOnUIThread will load EULA from
 298         // resources if contents_ is empty.
 299         contents_.clear();
 300       }
 301     }
 302     BrowserThread::PostTask(
 303         BrowserThread::UI, FROM_HERE,
 304         base::Bind(&ChromeOSTermsHandler::ResponseOnUIThread, this));
 305   }
 306
 307   void ResponseOnUIThread() {
 308     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 309     // If we fail to load Chrome OS EULA from disk, load it from resources.
 310     // Do nothing if OEM EULA load failed.
 311     if (contents_.empty() && path_ != chrome::kOemEulaURLPath)
 312       contents_ = l10n_util::GetStringUTF8(IDS_TERMS_HTML);
 313     callback_.Run(base::RefCountedString::TakeString(&contents_));
 314   }
 315
 316   // Path in the URL.
 317   const std::string path_;
 318
 319   // Callback to run with the response.
 320   content::URLDataSource::GotDataCallback callback_;
 321
 322   // Locale of the EULA.
 323   const std::string locale_;
 324
 325   // EULA contents that was loaded from file.
 326   std::string contents_;
 327
 328   DISALLOW_COPY_AND_ASSIGN(ChromeOSTermsHandler);
 329 };
 330
 331 #endif
 332
 333 }  // namespace
 334
 335 // Individual about handlers ---------------------------------------------------
 336
 337 namespace about_ui {
 338
 339 void AppendHeader(std::string* output, int refresh,
 340                   const std::string& unescaped_title) {
 341   output->append("<!DOCTYPE HTML>\n<html>\n<head>\n");
 342   if (!unescaped_title.empty()) {
 343     output->append("<title>");
 344     output->append(net::EscapeForHTML(unescaped_title));
 345     output->append("</title>\n");
 346   }
 347   output->append("<meta charset='utf-8'>\n");
 348   if (refresh > 0) {
 349     output->append("<meta http-equiv='refresh' content='");
 350     output->append(base::IntToString(refresh));
 351     output->append("'/>\n");
 352   }
 353 }
 354
 355 void AppendBody(std::string *output) {
 356   output->append("</head>\n<body>\n");
 357 }
 358
 359 void AppendFooter(std::string *output) {
 360   output->append("</body>\n</html>\n");
 361 }
 362
 363 }  // namespace about_ui
 364
 365 using about_ui::AppendHeader;
 366 using about_ui::AppendBody;
 367 using about_ui::AppendFooter;
 368
 369 namespace {
 370
 371 std::string ChromeURLs() {
 372   std::string html;
 373   AppendHeader(&html, 0, "Chrome URLs");
 374   AppendBody(&html);
 375   html += "<h2>List of Chrome URLs</h2>\n<ul>\n";
 376   std::vector<std::string> hosts(
 377       chrome::kChromeHostURLs,
 378       chrome::kChromeHostURLs + chrome::kNumberOfChromeHostURLs);
 379   std::sort(hosts.begin(), hosts.end());
 380   for (std::vector<std::string>::const_iterator i = hosts.begin();
 381        i != hosts.end(); ++i)
 382     html += "<li><a href='chrome://" + *i + "/'>chrome://" + *i + "</a></li>\n";
 383   html += "</ul>\n<h2>For Debug</h2>\n"
 384       "<p>The following pages are for debugging purposes only. Because they "
 385       "crash or hang the renderer, they're not linked directly; you can type "
 386       "them into the address bar if you need them.</p>\n<ul>";
 387   for (int i = 0; i < chrome::kNumberOfChromeDebugURLs; i++)
 388     html += "<li>" + std::string(chrome::kChromeDebugURLs[i]) + "</li>\n";
 389   html += "</ul>\n";
 390   AppendFooter(&html);
 391   return html;
 392 }
 393
 394 #if defined(OS_CHROMEOS)
 395
 396 // Html output helper functions
 397
 398 // Helper function to wrap HTML with a tag.
 399 std::string WrapWithTag(const std::string& tag, const std::string& text) {
 400   return "<" + tag + ">" + text + "</" + tag + ">";
 401 }
 402
 403 // Helper function to wrap Html with <td> tag.
 404 std::string WrapWithTD(const std::string& text) {
 405   return "<td>" + text + "</td>";
 406 }
 407
 408 // Helper function to wrap Html with <tr> tag.
 409 std::string WrapWithTR(const std::string& text) {
 410   return "<tr>" + text + "</tr>";
 411 }
 412
 413 std::string AddStringRow(const std::string& name, const std::string& value) {
 414   std::string row;
 415   row.append(WrapWithTD(name));
 416   row.append(WrapWithTD(value));
 417   return WrapWithTR(row);
 418 }
 419
 420 void AddContentSecurityPolicy(std::string* output) {
 421   output->append("<meta http-equiv='Content-Security-Policy' "
 422       "content='default-src 'none';'>");
 423 }
 424
 425 // TODO(stevenjb): L10N AboutDiscards.
 426
 427 std::string AboutDiscardsRun() {
 428   std::string output;
 429   AppendHeader(&output, 0, "About discards");
 430   output.append(
 431       base::StringPrintf("<meta http-equiv='refresh' content='2;%s'>",
 432       chrome::kChromeUIDiscardsURL));
 433   AddContentSecurityPolicy(&output);
 434   output.append(WrapWithTag("p", "Discarding a tab..."));
 435   g_browser_process->platform_part()->
 436       oom_priority_manager()->LogMemoryAndDiscardTab();
 437   AppendFooter(&output);
 438   return output;
 439 }
 440
 441 std::string AboutDiscards(const std::string& path) {
 442   std::string output;
 443   const char kRunCommand[] = "run";
 444   if (path == kRunCommand)
 445     return AboutDiscardsRun();
 446   AppendHeader(&output, 0, "About discards");
 447   AddContentSecurityPolicy(&output);
 448   AppendBody(&output);
 449   output.append("<h3>About discards</h3>");
 450   output.append(
 451       "<p>Tabs sorted from most interesting to least interesting. The least "
 452       "interesting tab may be discarded if we run out of physical memory.</p>");
 453
 454   chromeos::OomPriorityManager* oom =
 455       g_browser_process->platform_part()->oom_priority_manager();
 456   std::vector<base::string16> titles = oom->GetTabTitles();
 457   if (!titles.empty()) {
 458     output.append("<ul>");
 459     std::vector<base::string16>::iterator it = titles.begin();
 460     for ( ; it != titles.end(); ++it) {
 461       std::string title = base::UTF16ToUTF8(*it);
 462       title = net::EscapeForHTML(title);
 463       output.append(WrapWithTag("li", title));
 464     }
 465     output.append("</ul>");
 466   } else {
 467     output.append("<p>None found.  Wait 10 seconds, then refresh.</p>");
 468   }
 469   output.append(base::StringPrintf("%d discards this session. ",
 470                              oom->discard_count()));
 471   output.append(base::StringPrintf("<a href='%s%s'>Discard tab now</a>",
 472                                    chrome::kChromeUIDiscardsURL,
 473                                    kRunCommand));
 474
 475   base::SystemMemoryInfoKB meminfo;
 476   base::GetSystemMemoryInfo(&meminfo);
 477   output.append("<h3>System memory information in MB</h3>");
 478   output.append("<table>");
 479   // Start with summary statistics.
 480   output.append(AddStringRow(
 481       "Total", base::IntToString(meminfo.total / 1024)));
 482   output.append(AddStringRow(
 483       "Free", base::IntToString(meminfo.free / 1024)));
 484   int mem_allocated_kb = meminfo.active_anon + meminfo.inactive_anon;
 485 #if defined(ARCH_CPU_ARM_FAMILY)
 486   // ARM counts allocated graphics memory separately from anonymous.
 487   if (meminfo.gem_size != -1)
 488     mem_allocated_kb += meminfo.gem_size / 1024;
 489 #endif
 490   output.append(AddStringRow(
 491       "Allocated", base::IntToString(mem_allocated_kb / 1024)));
 492   // Add some space, then detailed numbers.
 493   output.append(AddStringRow("&nbsp;", "&nbsp;"));
 494   output.append(AddStringRow(
 495       "Buffered", base::IntToString(meminfo.buffers / 1024)));
 496   output.append(AddStringRow(
 497       "Cached", base::IntToString(meminfo.cached / 1024)));
 498   output.append(AddStringRow(
 499       "Active Anon", base::IntToString(meminfo.active_anon / 1024)));
 500   output.append(AddStringRow(
 501       "Inactive Anon", base::IntToString(meminfo.inactive_anon / 1024)));
 502   output.append(AddStringRow(
 503       "Shared", base::IntToString(meminfo.shmem / 1024)));
 504   output.append(AddStringRow(
 505       "Graphics", base::IntToString(meminfo.gem_size / 1024 / 1024)));
 506   output.append("</table>");
 507
 508   AppendFooter(&output);
 509   return output;
 510 }
 511
 512 #endif  // OS_CHROMEOS
 513
 514 // AboutDnsHandler bounces the request back to the IO thread to collect
 515 // the DNS information.
 516 class AboutDnsHandler : public base::RefCountedThreadSafe<AboutDnsHandler> {
 517  public:
 518   static void Start(Profile* profile,
 519                     const content::URLDataSource::GotDataCallback& callback) {
 520     scoped_refptr<AboutDnsHandler> handler(
 521         new AboutDnsHandler(profile, callback));
 522     handler->StartOnUIThread();
 523   }
 524
 525  private:
 526   friend class base::RefCountedThreadSafe<AboutDnsHandler>;
 527
 528   AboutDnsHandler(Profile* profile,
 529                   const content::URLDataSource::GotDataCallback& callback)
 530       : profile_(profile),
 531         callback_(callback) {
 532     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 533   }
 534
 535   virtual ~AboutDnsHandler() {}
 536
 537   // Calls FinishOnUIThread() on completion.
 538   void StartOnUIThread() {
 539     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 540     chrome_browser_net::Predictor* predictor = profile_->GetNetworkPredictor();
 541     BrowserThread::PostTask(
 542         BrowserThread::IO, FROM_HERE,
 543         base::Bind(&AboutDnsHandler::StartOnIOThread, this, predictor));
 544   }
 545
 546   void StartOnIOThread(chrome_browser_net::Predictor* predictor) {
 547     DCHECK_CURRENTLY_ON(BrowserThread::IO);
 548
 549     std::string data;
 550     AppendHeader(&data, 0, "About DNS");
 551     AppendBody(&data);
 552     chrome_browser_net::Predictor::PredictorGetHtmlInfo(predictor, &data);
 553     AppendFooter(&data);
 554
 555     BrowserThread::PostTask(
 556         BrowserThread::UI, FROM_HERE,
 557         base::Bind(&AboutDnsHandler::FinishOnUIThread, this, data));
 558   }
 559
 560   void FinishOnUIThread(const std::string& data) {
 561     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 562     std::string data_copy(data);
 563     callback_.Run(base::RefCountedString::TakeString(&data_copy));
 564   }
 565
 566   Profile* profile_;
 567
 568   // Callback to run with the response.
 569   content::URLDataSource::GotDataCallback callback_;
 570
 571   DISALLOW_COPY_AND_ASSIGN(AboutDnsHandler);
 572 };
 573
 574 void FinishMemoryDataRequest(
 575     const std::string& path,
 576     const content::URLDataSource::GotDataCallback& callback) {
 577   if (path == kStringsJsPath) {
 578     // The AboutMemoryHandler cleans itself up, but |StartFetch()| will want
 579     // the refcount to be greater than 0.
 580     scoped_refptr<AboutMemoryHandler> handler(new AboutMemoryHandler(callback));
 581     // TODO(jamescook): Maybe this shouldn't update UMA?
 582     handler->StartFetch(MemoryDetails::UPDATE_USER_METRICS);
 583   } else {
 584     int id = IDR_ABOUT_MEMORY_HTML;
 585     if (path == kMemoryJsPath) {
 586       id = IDR_ABOUT_MEMORY_JS;
 587     } else if (path == kMemoryCssPath) {
 588       id = IDR_ABOUT_MEMORY_CSS;
 589     }
 590
 591     std::string result =
 592         ResourceBundle::GetSharedInstance().GetRawDataResource(id).as_string();
 593     callback.Run(base::RefCountedString::TakeString(&result));
 594   }
 595 }
 596
 597 // Handler for filling in the "about:stats" page, as called by the browser's
 598 // About handler processing.
 599 // |query| is roughly the query string of the about:stats URL.
 600 // Returns a string containing the HTML to render for the about:stats page.
 601 // Conditional Output:
 602 //      if |query| is "json", returns a JSON format of all counters.
 603 //      if |query| is "raw", returns plain text of counter deltas.
 604 //      otherwise, returns HTML with pretty JS/HTML to display the data.
 605 std::string AboutStats(const std::string& query) {
 606   // We keep the base::DictionaryValue tree live so that we can do delta
 607   // stats computations across runs.
 608   CR_DEFINE_STATIC_LOCAL(base::DictionaryValue, root, ());
 609   static base::TimeTicks last_sample_time = base::TimeTicks::Now();
 610
 611   base::TimeTicks now = base::TimeTicks::Now();
 612   base::TimeDelta time_since_last_sample = now - last_sample_time;
 613   last_sample_time = now;
 614
 615   base::StatsTable* table = base::StatsTable::current();
 616   if (!table)
 617     return std::string();
 618
 619   // We maintain two lists - one for counters and one for timers.
 620   // Timers actually get stored on both lists.
 621   base::ListValue* counters;
 622   if (!root.GetList("counters", &counters)) {
 623     counters = new base::ListValue();
 624     root.Set("counters", counters);
 625   }
 626
 627   base::ListValue* timers;
 628   if (!root.GetList("timers", &timers)) {
 629     timers = new base::ListValue();
 630     root.Set("timers", timers);
 631   }
 632
 633   // NOTE: Counters start at index 1.
 634   for (int index = 1; index <= table->GetMaxCounters(); index++) {
 635     // Get the counter's full name
 636     std::string full_name = table->GetRowName(index);
 637     if (full_name.length() == 0)
 638       break;
 639     DCHECK_EQ(':', full_name[1]);
 640     char counter_type = full_name[0];
 641     std::string name = full_name.substr(2);
 642
 643     // JSON doesn't allow '.' in names.
 644     size_t pos;
 645     while ((pos = name.find(".")) != std::string::npos)
 646       name.replace(pos, 1, ":");
 647
 648     // Try to see if this name already exists.
 649     base::DictionaryValue* counter = NULL;
 650     for (size_t scan_index = 0;
 651          scan_index < counters->GetSize(); scan_index++) {
 652       base::DictionaryValue* dictionary;
 653       if (counters->GetDictionary(scan_index, &dictionary)) {
 654         std::string scan_name;
 655         if (dictionary->GetString("name", &scan_name) && scan_name == name) {
 656           counter = dictionary;
 657         }
 658       } else {
 659         NOTREACHED();  // Should always be there
 660       }
 661     }
 662
 663     if (counter == NULL) {
 664       counter = new base::DictionaryValue();
 665       counter->SetString("name", name);
 666       counters->Append(counter);
 667     }
 668
 669     switch (counter_type) {
 670       case 'c':
 671         {
 672           int new_value = table->GetRowValue(index);
 673           int prior_value = 0;
 674           int delta = 0;
 675           if (counter->GetInteger("value", &prior_value)) {
 676             delta = new_value - prior_value;
 677           }
 678           counter->SetInteger("value", new_value);
 679           counter->SetInteger("delta", delta);
 680         }
 681         break;
 682       case 'm':
 683         {
 684           // TODO(mbelshe): implement me.
 685         }
 686         break;
 687       case 't':
 688         {
 689           int time = table->GetRowValue(index);
 690           counter->SetInteger("time", time);
 691
 692           // Store this on the timers list as well.
 693           timers->Append(counter);
 694         }
 695         break;
 696       default:
 697         NOTREACHED();
 698     }
 699   }
 700
 701   std::string data;
 702   if (query == "json" || query == kStringsJsPath) {
 703     base::JSONWriter::WriteWithOptions(
 704           &root,
 705           base::JSONWriter::OPTIONS_PRETTY_PRINT,
 706           &data);
 707     if (query == kStringsJsPath)
 708       data = "var templateData = " + data + ";";
 709   } else if (query == "raw") {
 710     // Dump the raw counters which have changed in text format.
 711     data = "<pre>";
 712     data.append(base::StringPrintf("Counter changes in the last %ldms\n",
 713         static_cast<long int>(time_since_last_sample.InMilliseconds())));
 714     for (size_t i = 0; i < counters->GetSize(); ++i) {
 715       base::Value* entry = NULL;
 716       bool rv = counters->Get(i, &entry);
 717       if (!rv)
 718         continue;  // None of these should fail.
 719       base::DictionaryValue* counter =
 720           static_cast<base::DictionaryValue*>(entry);
 721       int delta;
 722       rv = counter->GetInteger("delta", &delta);
 723       if (!rv)
 724         continue;
 725       if (delta > 0) {
 726         std::string name;
 727         rv = counter->GetString("name", &name);
 728         if (!rv)
 729           continue;
 730         int value;
 731         rv = counter->GetInteger("value", &value);
 732         if (!rv)
 733           continue;
 734         data.append(name);
 735         data.append(":");
 736         data.append(base::IntToString(delta));
 737         data.append("\n");
 738       }
 739     }
 740     data.append("</pre>");
 741   } else {
 742     // Get about_stats.html/js from resource bundle.
 743     data = ResourceBundle::GetSharedInstance().GetRawDataResource(
 744         (query == kStatsJsPath ?
 745          IDR_ABOUT_STATS_JS : IDR_ABOUT_STATS_HTML)).as_string();
 746
 747     if (query != kStatsJsPath) {
 748       // Clear the timer list since we stored the data in the timers list
 749       // as well.
 750       for (int index = static_cast<int>(timers->GetSize())-1; index >= 0;
 751            index--) {
 752         scoped_ptr<base::Value> value;
 753         timers->Remove(index, &value);
 754         // We don't care about the value pointer; it's still tracked
 755         // on the counters list.
 756         ignore_result(value.release());
 757       }
 758     }
 759   }
 760
 761   return data;
 762 }
 763
 764 #if defined(OS_LINUX) || defined(OS_OPENBSD)
 765 std::string AboutLinuxProxyConfig() {
 766   std::string data;
 767   AppendHeader(&data, 0,
 768                l10n_util::GetStringUTF8(IDS_ABOUT_LINUX_PROXY_CONFIG_TITLE));
 769   data.append("<style>body { max-width: 70ex; padding: 2ex 5ex; }</style>");
 770   AppendBody(&data);
 771   base::FilePath binary = CommandLine::ForCurrentProcess()->GetProgram();
 772   data.append(l10n_util::GetStringFUTF8(
 773       IDS_ABOUT_LINUX_PROXY_CONFIG_BODY,
 774       l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
 775       base::ASCIIToUTF16(binary.BaseName().value())));
 776   AppendFooter(&data);
 777   return data;
 778 }
 779
 780 void AboutSandboxRow(std::string* data, const std::string& prefix, int name_id,
 781                      bool good) {
 782   data->append("<tr><td>");
 783   data->append(prefix);
 784   data->append(l10n_util::GetStringUTF8(name_id));
 785   if (good) {
 786     data->append("</td><td style='color: green;'>");
 787     data->append(
 788         l10n_util::GetStringUTF8(IDS_CONFIRM_MESSAGEBOX_YES_BUTTON_LABEL));
 789   } else {
 790     data->append("</td><td style='color: red;'>");
 791     data->append(
 792         l10n_util::GetStringUTF8(IDS_CONFIRM_MESSAGEBOX_NO_BUTTON_LABEL));
 793   }
 794   data->append("</td></tr>");
 795 }
 796
 797 std::string AboutSandbox() {
 798   std::string data;
 799   AppendHeader(&data, 0, l10n_util::GetStringUTF8(IDS_ABOUT_SANDBOX_TITLE));
 800   AppendBody(&data);
 801   data.append("<h1>");
 802   data.append(l10n_util::GetStringUTF8(IDS_ABOUT_SANDBOX_TITLE));
 803   data.append("</h1>");
 804
 805   // Get expected sandboxing status of renderers.
 806   const int status = content::ZygoteHost::GetInstance()->GetSandboxStatus();
 807
 808   data.append("<table>");
 809
 810   AboutSandboxRow(&data,
 811                   std::string(),
 812                   IDS_ABOUT_SANDBOX_SUID_SANDBOX,
 813                   status & content::kSandboxLinuxSUID);
 814   AboutSandboxRow(&data, "&nbsp;&nbsp;", IDS_ABOUT_SANDBOX_PID_NAMESPACES,
 815                   status & content::kSandboxLinuxPIDNS);
 816   AboutSandboxRow(&data, "&nbsp;&nbsp;", IDS_ABOUT_SANDBOX_NET_NAMESPACES,
 817                   status & content::kSandboxLinuxNetNS);
 818   AboutSandboxRow(&data,
 819                   std::string(),
 820                   IDS_ABOUT_SANDBOX_SECCOMP_BPF_SANDBOX,
 821                   status & content::kSandboxLinuxSeccompBPF);
 822   AboutSandboxRow(&data,
 823                   std::string(),
 824                   IDS_ABOUT_SANDBOX_YAMA_LSM,
 825                   status & content::kSandboxLinuxYama);
 826
 827   data.append("</table>");
 828
 829   // The setuid sandbox is required as our first-layer sandbox.
 830   bool good_layer1 = status & content::kSandboxLinuxSUID &&
 831                      status & content::kSandboxLinuxPIDNS &&
 832                      status & content::kSandboxLinuxNetNS;
 833   // A second-layer sandbox is also required to be adequately sandboxed.
 834   bool good_layer2 = status & content::kSandboxLinuxSeccompBPF;
 835   bool good = good_layer1 && good_layer2;
 836
 837   if (good) {
 838     data.append("<p style='color: green'>");
 839     data.append(l10n_util::GetStringUTF8(IDS_ABOUT_SANDBOX_OK));
 840   } else {
 841     data.append("<p style='color: red'>");
 842     data.append(l10n_util::GetStringUTF8(IDS_ABOUT_SANDBOX_BAD));
 843   }
 844   data.append("</p>");
 845
 846   AppendFooter(&data);
 847   return data;
 848 }
 849 #endif
 850
 851 // AboutMemoryHandler ----------------------------------------------------------
 852
 853 // Helper for AboutMemory to bind results from a ProcessMetrics object
 854 // to a DictionaryValue. Fills ws_usage and comm_usage so that the objects
 855 // can be used in caller's scope (e.g for appending to a net total).
 856 void AboutMemoryHandler::BindProcessMetrics(base::DictionaryValue* data,
 857                                             ProcessMemoryInformation* info) {
 858   DCHECK(data && info);
 859
 860   // Bind metrics to dictionary.
 861   data->SetInteger("ws_priv", static_cast<int>(info->working_set.priv));
 862   data->SetInteger("ws_shareable",
 863     static_cast<int>(info->working_set.shareable));
 864   data->SetInteger("ws_shared", static_cast<int>(info->working_set.shared));
 865   data->SetInteger("comm_priv", static_cast<int>(info->committed.priv));
 866   data->SetInteger("comm_map", static_cast<int>(info->committed.mapped));
 867   data->SetInteger("comm_image", static_cast<int>(info->committed.image));
 868   data->SetInteger("pid", info->pid);
 869   data->SetString("version", info->version);
 870   data->SetInteger("processes", info->num_processes);
 871 }
 872
 873 // Helper for AboutMemory to append memory usage information for all
 874 // sub-processes (i.e. renderers, plugins) used by Chrome.
 875 void AboutMemoryHandler::AppendProcess(base::ListValue* child_data,
 876                                        ProcessMemoryInformation* info) {
 877   DCHECK(child_data && info);
 878
 879   // Append a new DictionaryValue for this renderer to our list.
 880   base::DictionaryValue* child = new base::DictionaryValue();
 881   child_data->Append(child);
 882   BindProcessMetrics(child, info);
 883
 884   std::string child_label(
 885       ProcessMemoryInformation::GetFullTypeNameInEnglish(info->process_type,
 886                                                          info->renderer_type));
 887   if (info->is_diagnostics)
 888     child_label.append(" (diagnostics)");
 889   child->SetString("child_name", child_label);
 890   base::ListValue* titles = new base::ListValue();
 891   child->Set("titles", titles);
 892   for (size_t i = 0; i < info->titles.size(); ++i)
 893     titles->Append(new base::StringValue(info->titles[i]));
 894 }
 895
 896 void AboutMemoryHandler::OnDetailsAvailable() {
 897   // the root of the JSON hierarchy for about:memory jstemplate
 898   scoped_ptr<base::DictionaryValue> root(new base::DictionaryValue);
 899   base::ListValue* browsers = new base::ListValue();
 900   root->Set("browsers", browsers);
 901
 902   const std::vector<ProcessData>& browser_processes = processes();
 903
 904   // Aggregate per-process data into browser summary data.
 905   base::string16 log_string;
 906   for (size_t index = 0; index < browser_processes.size(); index++) {
 907     if (browser_processes[index].processes.empty())
 908       continue;
 909
 910     // Sum the information for the processes within this browser.
 911     ProcessMemoryInformation aggregate;
 912     ProcessMemoryInformationList::const_iterator iterator;
 913     iterator = browser_processes[index].processes.begin();
 914     aggregate.pid = iterator->pid;
 915     aggregate.version = iterator->version;
 916     while (iterator != browser_processes[index].processes.end()) {
 917       if (!iterator->is_diagnostics ||
 918           browser_processes[index].processes.size() == 1) {
 919         aggregate.working_set.priv += iterator->working_set.priv;
 920         aggregate.working_set.shared += iterator->working_set.shared;
 921         aggregate.working_set.shareable += iterator->working_set.shareable;
 922         aggregate.committed.priv += iterator->committed.priv;
 923         aggregate.committed.mapped += iterator->committed.mapped;
 924         aggregate.committed.image += iterator->committed.image;
 925         aggregate.num_processes++;
 926       }
 927       ++iterator;
 928     }
 929     base::DictionaryValue* browser_data = new base::DictionaryValue();
 930     browsers->Append(browser_data);
 931     browser_data->SetString("name", browser_processes[index].name);
 932
 933     BindProcessMetrics(browser_data, &aggregate);
 934
 935     // We log memory info as we record it.
 936     if (!log_string.empty())
 937       log_string += base::ASCIIToUTF16(", ");
 938     log_string += browser_processes[index].name + base::ASCIIToUTF16(", ") +
 939                   base::Int64ToString16(aggregate.working_set.priv) +
 940                   base::ASCIIToUTF16(", ") +
 941                   base::Int64ToString16(aggregate.working_set.shared) +
 942                   base::ASCIIToUTF16(", ") +
 943                   base::Int64ToString16(aggregate.working_set.shareable);
 944   }
 945   if (!log_string.empty())
 946     VLOG(1) << "memory: " << log_string;
 947
 948   // Set the browser & renderer detailed process data.
 949   base::DictionaryValue* browser_data = new base::DictionaryValue();
 950   root->Set("browzr_data", browser_data);
 951   base::ListValue* child_data = new base::ListValue();
 952   root->Set("child_data", child_data);
 953
 954   ProcessData process = browser_processes[0];  // Chrome is the first browser.
 955   root->SetString("current_browser_name", process.name);
 956
 957   for (size_t index = 0; index < process.processes.size(); index++) {
 958     if (process.processes[index].process_type == content::PROCESS_TYPE_BROWSER)
 959       BindProcessMetrics(browser_data, &process.processes[index]);
 960     else
 961       AppendProcess(child_data, &process.processes[index]);
 962   }
 963
 964   root->SetBoolean("show_other_browsers",
 965       browser_defaults::kShowOtherBrowsersInAboutMemory);
 966
 967   base::DictionaryValue load_time_data;
 968   load_time_data.SetString(
 969       "summary_desc",
 970       l10n_util::GetStringUTF16(IDS_MEMORY_USAGE_SUMMARY_DESC));
 971   webui::SetFontAndTextDirection(&load_time_data);
 972   load_time_data.Set("jstemplateData", root.release());
 973
 974   webui::UseVersion2 version2;
 975   std::string data;
 976   webui::AppendJsonJS(&load_time_data, &data);
 977   callback_.Run(base::RefCountedString::TakeString(&data));
 978 }
 979
 980 }  // namespace
 981
 982 // AboutUIHTMLSource ----------------------------------------------------------
 983
 984 AboutUIHTMLSource::AboutUIHTMLSource(const std::string& source_name,
 985                                      Profile* profile)
 986     : source_name_(source_name),
 987       profile_(profile) {}
 988
 989 AboutUIHTMLSource::~AboutUIHTMLSource() {}
 990
 991 std::string AboutUIHTMLSource::GetSource() const {
 992   return source_name_;
 993 }
 994
 995 void AboutUIHTMLSource::StartDataRequest(
 996     const std::string& path,
 997     int render_process_id,
 998     int render_frame_id,
 999     const content::URLDataSource::GotDataCallback& callback) {
1000   std::string response;
1001   // Add your data source here, in alphabetical order.
1002   if (source_name_ == chrome::kChromeUIChromeURLsHost) {
1003     response = ChromeURLs();
1004   } else if (source_name_ == chrome::kChromeUICreditsHost) {
1005     int idr = IDR_CREDITS_HTML;
1006     if (path == kCreditsJsPath)
1007       idr = IDR_CREDITS_JS;
1008     else if (path == kKeyboardUtilsPath)
1009       idr = IDR_KEYBOARD_UTILS_JS;
1010
1011     response = ResourceBundle::GetSharedInstance().GetRawDataResource(
1012         idr).as_string();
1013 #if defined(OS_CHROMEOS)
1014   } else if (source_name_ == chrome::kChromeUIDiscardsHost) {
1015     response = AboutDiscards(path);
1016 #endif
1017   } else if (source_name_ == chrome::kChromeUIDNSHost) {
1018     AboutDnsHandler::Start(profile(), callback);
1019     return;
1020 #if defined(OS_LINUX) || defined(OS_OPENBSD)
1021   } else if (source_name_ == chrome::kChromeUILinuxProxyConfigHost) {
1022     response = AboutLinuxProxyConfig();
1023 #endif
1024   } else if (source_name_ == chrome::kChromeUIMemoryHost) {
1025     response = GetAboutMemoryRedirectResponse(profile());
1026   } else if (source_name_ == chrome::kChromeUIMemoryRedirectHost) {
1027     FinishMemoryDataRequest(path, callback);
1028     return;
1029 #if defined(OS_CHROMEOS)
1030   } else if (source_name_ == chrome::kChromeUIOSCreditsHost) {
1031     int idr = IDR_OS_CREDITS_HTML;
1032     if (path == kKeyboardUtilsPath)
1033       idr = IDR_KEYBOARD_UTILS_JS;
1034     response = ResourceBundle::GetSharedInstance().GetRawDataResource(
1035         idr).as_string();
1036 #endif
1037 #if defined(OS_LINUX) || defined(OS_OPENBSD)
1038   } else if (source_name_ == chrome::kChromeUISandboxHost) {
1039     response = AboutSandbox();
1040 #endif
1041   } else if (source_name_ == chrome::kChromeUIStatsHost) {
1042     response = AboutStats(path);
1043   } else if (source_name_ == chrome::kChromeUITermsHost) {
1044 #if defined(OS_CHROMEOS)
1045     ChromeOSTermsHandler::Start(path, callback);
1046     return;
1047 #else
1048     response = l10n_util::GetStringUTF8(IDS_TERMS_HTML);
1049 #endif
1050   }
1051
1052   FinishDataRequest(response, callback);
1053 }
1054
1055 void AboutUIHTMLSource::FinishDataRequest(
1056     const std::string& html,
1057     const content::URLDataSource::GotDataCallback& callback) {
1058   std::string html_copy(html);
1059   callback.Run(base::RefCountedString::TakeString(&html_copy));
1060 }
1061
1062 std::string AboutUIHTMLSource::GetMimeType(const std::string& path) const {
1063   if (path == kCreditsJsPath     ||
1064       path == kKeyboardUtilsPath ||
1065       path == kStatsJsPath       ||
1066       path == kStringsJsPath     ||
1067       path == kMemoryJsPath) {
1068     return "application/javascript";
1069   }
1070   return "text/html";
1071 }
1072
1073 bool AboutUIHTMLSource::ShouldAddContentSecurityPolicy() const {
1074 #if defined(OS_CHROMEOS)
1075   if (source_name_ == chrome::kChromeUIOSCreditsHost)
1076     return false;
1077 #endif
1078   return content::URLDataSource::ShouldAddContentSecurityPolicy();
1079 }
1080
1081 bool AboutUIHTMLSource::ShouldDenyXFrameOptions() const {
1082 #if defined(OS_CHROMEOS)
1083   if (source_name_ == chrome::kChromeUITermsHost) {
1084     // chrome://terms page is embedded in iframe to chrome://oobe.
1085     return false;
1086   }
1087 #endif
1088   return content::URLDataSource::ShouldDenyXFrameOptions();
1089 }
1090
1091 AboutUI::AboutUI(content::WebUI* web_ui, const std::string& name)
1092     : WebUIController(web_ui) {
1093   Profile* profile = Profile::FromWebUI(web_ui);
1094
1095 #if defined(ENABLE_THEMES)
1096   // Set up the chrome://theme/ source.
1097   ThemeSource* theme = new ThemeSource(profile);
1098   content::URLDataSource::Add(profile, theme);
1099 #endif
1100
1101   content::URLDataSource::Add(profile, new AboutUIHTMLSource(name, profile));
1102 }