Add more information to about:version and "About Chromium" dialog

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 172 matching lines @@
 // time that about memory is being computed.
 std::string GetAboutMemoryRedirectResponse() {
   return "<meta http-equiv=\"refresh\" "
       "content=\"0;chrome://about/memory\">";
 }
 
 class AboutSource : public ChromeURLDataManager::DataSource {
  public:
   // Creates our datasource.
   AboutSource();
+  explicit AboutSource(Profile* profile);
 
   // 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);
 
   virtual std::string GetMimeType(const std::string&) const {
     return "text/html";
   }
 
   // Send the response data.
   void FinishDataRequest(const std::string& html, int request_id);
 
+  Profile* GetProfile() { return profile_; }
+
  private:
   virtual ~AboutSource();
 
+  Profile* profile_;
+
   DISALLOW_COPY_AND_ASSIGN(AboutSource);
 };
 
 // Handling about:memory is complicated enough to encapsulate its related
 // methods into a single class. The user should create it (on the heap) and call
 // its |StartFetch()| method.
 class AboutMemoryHandler : public MemoryDetails {
  public:
   AboutMemoryHandler(AboutSource* source, int request_id)
     : source_(source), request_id_(request_id) {}
@@ skipping 676 matching lines @@
     data.append("<p style=\"color: red\">");
     data.append(l10n_util::GetStringUTF8(IDS_ABOUT_SANDBOX_BAD));
   }
   data.append("</p>");
 
   data.append("</body></html>\n");
   return data;
 }
 #endif
 
-std::string AboutVersion(DictionaryValue* localized_strings) {
+std::string AboutVersion(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;
   std::string js_engine = "JavaScriptCore";
 #endif
 
   localized_strings->SetString("name",
       l10n_util::GetStringUTF16(IDS_PRODUCT_NAME));
   localized_strings->SetString("version", version_info.Version());
   localized_strings->SetString("version_modifier",
                                platform_util::GetVersionStringModifier());
+  localized_strings->SetString("os_name",
+                               l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_OS));
+  localized_strings->SetString("os_type", version_info.OSType());
+  localized_strings->SetString("webkit_name",
+                               l10n_util::GetStringUTF16(
+                                   IDS_ABOUT_VERSION_WEBKIT));
+  localized_strings->SetString("webkit_version", webkit_version);
+  localized_strings->SetString("js_name",
+                               l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_JS));
   localized_strings->SetString("js_engine", js_engine);
   localized_strings->SetString("js_version", js_version);
-  localized_strings->SetString("webkit_version", webkit_version);
   localized_strings->SetString("company",
       l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_COMPANY_NAME));
   localized_strings->SetString("copyright",
       l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_COPYRIGHT));
   localized_strings->SetString("cl", version_info.LastChange());
   localized_strings->SetString("official",
       l10n_util::GetStringUTF16(
           version_info.IsOfficialBuild() ?
               IDS_ABOUT_VERSION_OFFICIAL
             : IDS_ABOUT_VERSION_UNOFFICIAL));
@@ skipping 10 matching lines @@
   std::string command_line = "";
   typedef std::vector<std::string> ArgvList;
   const ArgvList& argv = CommandLine::ForCurrentProcess()->argv();
   for (ArgvList::const_iterator iter = argv.begin(); iter != argv.end(); iter++)
     command_line += " " + *iter;
   // TODO(viettrungluu): |command_line| could really have any encoding, whereas
   // below we assumes it's UTF-8.
   localized_strings->SetString("command_line", command_line);
 #endif
 
+  // Allow IO temporarily since the following operation will complete quickly
+  bool io_allowed = base::ThreadRestrictions::SetIOAllowed(true);

[Evan Martin, 2011/04/22 22:36:41]

I don't like this.  Why not just not call AbsolutePath?

+  localized_strings->SetString("executable_path_name",
+      l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_EXECUTABLE_PATH));
+  FilePath executable_path = CommandLine::ForCurrentProcess()->GetProgram();
+  if (file_util::AbsolutePath(&executable_path)) {
+    localized_strings->SetString("executable_path", executable_path.value());
+  } else {
+    localized_strings->SetString("executable_path", "No such file");
+  }
+  localized_strings->SetString("profile_path_name",
+      l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_PROFILE_PATH));
+  if (profile) {
+    FilePath profile_path = profile->GetPath();
+    if (file_util::AbsolutePath(&profile_path)) {
+      localized_strings->SetString("profile_path", profile_path.value());
+    } else {
+      localized_strings->SetString("profile_path", "No such file");
+    }
+  } else {
+    localized_strings->SetString("profile_path", "No such file");
+  }
+  base::ThreadRestrictions::SetIOAllowed(io_allowed);
+
   base::StringPiece version_html(
       ResourceBundle::GetSharedInstance().GetRawDataResource(
           IDR_ABOUT_VERSION_HTML));
 
   return jstemplate_builder::GetTemplatesHtml(
       version_html, localized_strings, "t" /* template root node id */);
 }
 
 std::string VersionNumberToString(uint32 value) {
   int hi = (value >> 8) & 0xff;
   int low = value & 0xff;
   return base::IntToString(hi) + "." + base::IntToString(low);
 }
 
 // AboutSource -----------------------------------------------------------------
 
 AboutSource::AboutSource()
     : DataSource(chrome::kAboutScheme, MessageLoop::current()) {
 }
 
+AboutSource::AboutSource(Profile* profile)
+    : DataSource(chrome::kAboutScheme, MessageLoop::current()),
+      profile_(profile) {
+}
+
 AboutSource::~AboutSource() {
 }
 
 void AboutSource::StartDataRequest(const std::string& path_raw,
     bool is_incognito, int request_id) {
   std::string path = path_raw;
   std::string info;
   if (path.find("/") != std::string::npos) {
     size_t pos = path.find("/");
     info = path.substr(pos + 1, path.length() - (pos + 1));
@@ skipping 20 matching lines @@
     response = AboutStats(info);
 #if defined(USE_TCMALLOC)
   } else if (path == kTcmallocPath) {
     response = AboutTcmalloc(info);
 #endif
   } else if (path == kVersionPath || path.empty()) {
 #if defined(OS_CHROMEOS)
     new ChromeOSAboutVersionHandler(this, request_id);
     return;
 #else
-    DictionaryValue value;
-    response = AboutVersion(&value);
+    DictionaryValue localized_strings;
+    localized_strings.SetString("os_version", "");
+    response = AboutVersion(&localized_strings, profile_);
 #endif
   } else if (path == kCreditsPath) {
     response = ResourceBundle::GetSharedInstance().GetRawDataResource(
         IDR_CREDITS_HTML).as_string();
   } else if (path == kAboutPath) {
     response = AboutAbout();
 #if defined(OS_CHROMEOS)
   } else if (path == kOSCreditsPath) {
     response = ResourceBundle::GetSharedInstance().GetRawDataResource(
         IDR_OS_CREDITS_HTML).as_string();
@@ skipping 169 matching lines @@
       request_id_(request_id) {
   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_name",
-                              l10n_util::GetStringUTF16(IDS_PRODUCT_OS_NAME));
   localized_strings.SetString("os_version", version);
-  localized_strings.SetBoolean("is_chrome_os", true);
-  source_->FinishDataRequest(AboutVersion(&localized_strings), request_id_);
+  source_->FinishDataRequest(AboutVersion(&localized_strings,
+                                          source_->GetProfile()), request_id_);
 
   // CancelableRequestProvider isn't happy when it's deleted and servicing a
   // task, so we delay the deletion.
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 #endif
 
 // Returns true if |url|'s spec starts with |about_specifier|, and is
 // terminated by the start of a path.
@@ skipping 125 matching lines @@
   // Rewrite the about URL to use chrome:. WebKit treats all about URLS the
   // same (blank page), so if we want to display content, we need another
   // scheme.
   std::string about_url = "chrome://about/";
   about_url.append(url->path());
   *url = GURL(about_url);
   return true;
 }
 
 void InitializeAboutDataSource(Profile* profile) {
-  profile->GetChromeURLDataManager()->AddDataSource(new AboutSource());
+  profile->GetChromeURLDataManager()->AddDataSource(new AboutSource(profile));
 }
 
 // This function gets called with the fixed-up chrome: URLs, so we have to
 // compare against those instead of "about:blah".
 bool HandleNonNavigationAboutURL(const GURL& url) {
   // about:ipc is currently buggy, so we disable it for official builds.
 #if !defined(OFFICIAL_BUILD)
 
 #if (defined(OS_MACOSX) || defined(OS_WIN)) && defined(IPC_MESSAGE_LOG_ENABLED)
   if (LowerCaseEqualsASCII(url.spec(), chrome::kChromeUIIPCURL)) {
     // Run the dialog. This will re-use the existing one if it's already up.
     browser::ShowAboutIPCDialog();
     return true;
   }
 #endif
 
 #endif  // OFFICIAL_BUILD
 
   return false;
 }
 
 std::vector<std::string> AboutPaths() {
   std::vector<std::string> paths;
   paths.reserve(arraysize(kAllAboutPaths));
   for (size_t i = 0; i < arraysize(kAllAboutPaths); i++)
     paths.push_back(kAllAboutPaths[i]);
   return paths;
 }