Refactor the about:version code out of about_ui.

chrome/browser/ui/webui/version_handler.cc

+// Copyright (c) 2012 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/ui/webui/version_handler.h"
+
+#include "base/command_line.h"
+#include "base/file_util.h"
+#include "base/metrics/field_trial.h"
+#include "base/string_split.h"
+#include "base/utf_string_conversions.h"
+#include "chrome/browser/plugin_prefs.h"
+#include "chrome/browser/profiles/profile.h"
+#include "content/public/browser/browser_thread.h"
+#include "content/public/browser/plugin_service.h"
+#include "content/public/browser/web_ui.h"
+#include "googleurl/src/gurl.h"
+#include "grit/generated_resources.h"
+#include "ui/base/l10n/l10n_util.h"
+
+#if defined(OS_CHROMEOS)
+#include "chrome/browser/chromeos/version_loader.h"
+#endif
+
+namespace {
+
+#if defined(OS_CHROMEOS)
+// ChromeOSAboutVersionHandler is responsible for loading the Chrome OS
+// version.
+// ChromeOSAboutVersionHandler handles deleting itself once the version has
+// been obtained and AboutUIHTMLSource notified.
+class ChromeOSAboutVersionHandler {

[Evan Stade, 2012/09/14 09:18:02]

I don't think this should be its own class; it should be a specialization of
VersionHandler and should get its own file.

[SteveT, 2012/09/14 14:48:15]

Done.

+ public:
+  explicit ChromeOSAboutVersionHandler(content::WebUI* web_ui);
+
+  // Callback from chromeos::VersionLoader giving the version.
+  void OnVersion(chromeos::VersionLoader::Handle handle,
+                 const std::string& version);
+
+ private:
+  // The WebUI instance to respond to.
+  content::WebUI* web_ui_;
+
+  // Handles asynchronously loading the version.
+  chromeos::VersionLoader loader_;
+
+  // Used to request the version.
+  CancelableRequestConsumer consumer_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChromeOSAboutVersionHandler);
+};
+
+ChromeOSAboutVersionHandler::ChromeOSAboutVersionHandler(content::WebUI* web_ui)
+    : web_ui_(web_ui) {
+  loader_.GetVersion(&consumer_,
+                     base::Bind(&ChromeOSAboutVersionHandler::OnVersion,
+                                base::Unretained(this)),
+                     chromeos::VersionLoader::VERSION_FULL);
+}
+
+void ChromeOSAboutVersionHandler::OnVersion(
+    chromeos::VersionLoader::Handle handle,
+    const std::string& version) {
+  scoped_ptr<StringValue> arg(Value::CreateStringValue(version));
+  LOG(INFO) << "Returning OS VERSION: " << version;
+  web_ui_->CallJavascriptFunction("returnOsVersion", *arg);
+
+  // CancelableRequestProvider isn't happy when it's deleted and servicing a
+  // task, so we delay the deletion.
+  MessageLoop::current()->DeleteSoon(FROM_HERE, this);
+}
+#endif
+
+// Retrieves the executable path on the FILE thread.
+void GetFilePaths(FilePath profile_path,
+                  std::string* exec_path_out,

[Evan Stade, 2012/09/14 09:18:02]

instead of passing in member variables as outparams, make this a class method

[SteveT, 2012/09/14 14:48:15]

Kept this as a standalone helper method and ensured that we safely request the
file paths on FILE.

+                  std::string* profile_path_out) {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::FILE));
+
+  FilePath executable_path = CommandLine::ForCurrentProcess()->GetProgram();
+  if (file_util::AbsolutePath(&executable_path))
+#if defined(OS_WIN)
+    *exec_path_out = WideToUTF8(executable_path.value());

[Evan Stade, 2012/09/14 09:18:02]

it would be easier to just do LossyDisplayName() (indeed, these paths are meant
for display)

[SteveT, 2012/09/14 14:48:15]

Done.

+#else
+    *exec_path_out = executable_path.value();
+#endif
+  else
+    *exec_path_out = l10n_util::GetStringUTF8(IDS_ABOUT_VERSION_PATH_NOTFOUND);
+
+  if (!profile_path.empty() && file_util::AbsolutePath(&profile_path)) {
+#if defined(OS_WIN)
+    *profile_path_out = WideToUTF8(profile_path.value());
+#else
+    *profile_path_out = profile_path.value();
+#endif
+  } else {
+    *profile_path_out =
+        l10n_util::GetStringUTF8(IDS_ABOUT_VERSION_PATH_NOTFOUND);
+  }
+}
+
+}  // namespace
+
+VersionHandler::VersionHandler()
+    : weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
+}
+
+VersionHandler::~VersionHandler() {
+}
+
+void VersionHandler::RegisterMessages() {
+  web_ui()->RegisterMessageCallback(
+      "requestVersionInfo",
+      base::Bind(&VersionHandler::HandleRequestVersionInfo,
+      base::Unretained(this)));
+}
+
+void VersionHandler::HandleRequestVersionInfo(const ListValue* args) {
+#if defined(OS_CHROMEOS)
+  new ChromeOSAboutVersionHandler(web_ui());

[Evan Stade, 2012/09/14 09:18:02]

what is going on here?

[Evan Stade, 2012/09/14 09:19:27]

ignore this

+#endif
+
+  // The Flash version information is needed in the response, so make sure
+  // the plugins are loaded.
+  content::PluginService::GetInstance()->GetPlugins(
+      base::Bind(&VersionHandler::OnGotPlugins,
+          weak_ptr_factory_.GetWeakPtr()));
+
+  FilePath profile_path;
+  Profile* profile = Profile::FromWebUI(web_ui());
+  if (profile) {
+    profile_path = profile->GetPath();
+  } else {
+    scoped_ptr<StringValue> profile_path(
+        Value::CreateStringValue(
+            l10n_util::GetStringUTF16(IDS_ABOUT_VERSION_PATH_NOTFOUND)));
+    web_ui()->CallJavascriptFunction("returnProfilePath", *profile_path);
+  }
+
+  // Grab the executable path on the FILE thread. It is returned in
+  // OnFilePath.
+  content::BrowserThread::PostTaskAndReply(content::BrowserThread::FILE,
+      FROM_HERE, base::Bind(&GetFilePaths, profile_path, &executable_path_,
+          &profile_path_),
+      base::Bind(&VersionHandler::OnGotFilePaths,
+          weak_ptr_factory_.GetWeakPtr()));
+
+  // Respond with the variations info immediately.
+  scoped_ptr<ListValue> variations_list(new ListValue());
+#if !defined(NDEBUG)

[Evan Stade, 2012/09/14 09:18:02]

it seems like this should be disabled for official builds, not release builds
(might want to ping author)

[SteveT, 2012/09/14 14:48:15]

I was the author :)

We decided that we want to show this in DEBUG builds, and an alternate UI for
RELEASE builds (which I would like to work on immediately after this is
committed).

+  std::string variation_state;
+  base::FieldTrialList::StatesToString(&variation_state);
+
+  std::vector<std::string> tokens;
+  base::SplitString(variation_state,
+                    base::FieldTrialList::kPersistentStringSeparator,
+                    &tokens);
+  // Since StatesToString appends a separator at the end, SplitString will
+  // append an extra empty string in the vector. Drop it. There should
+  // always be an even number of tokens left.
+  tokens.pop_back();
+  DCHECK_EQ(0U, tokens.size() % 2);
+
+  // |variations| is used to store the formatted strings that will be passed to
+  // the Javascript through |variations_list|.
+  std::vector<std::string> variations;
+  for (size_t i = 0; i < tokens.size(); i += 2)
+    variations.push_back(tokens[i] + ":" + tokens[i + 1]);
+
+  for (std::vector<std::string>::const_iterator it = variations.begin();
+      it != variations.end(); ++it) {
+    variations_list->Append(Value::CreateStringValue(*it));
+  }
+#endif
+  // In release mode, this will return an empty list to clear the section.
+  web_ui()->CallJavascriptFunction("returnVariationInfo",
+                                   *variations_list.release());
+}
+
+void VersionHandler::OnGotFilePaths() {
+  DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
+
+  scoped_ptr<StringValue> exec_path(Value::CreateStringValue(executable_path_));
+  scoped_ptr<StringValue> profile_path(Value::CreateStringValue(profile_path_));
+  web_ui()->CallJavascriptFunction("returnExecutablePath", *exec_path);
+  web_ui()->CallJavascriptFunction("returnProfilePath", *profile_path);

[Evan Stade, 2012/09/14 09:18:02]

any particular reason these are two separate js calls?

[SteveT, 2012/09/14 14:48:15]

In the case where the profile was not yet available (L131), we want to
immediately return the profile path as IDS_ABOUT_VERSION_PATH_NOTFOUND so we
need a separate JS call that can handle the profile path alone.

+}
+
+void VersionHandler::OnGotPlugins(
+    const std::vector<webkit::WebPluginInfo>& plugins) {
+#if !defined(OS_ANDROID)
+  // Obtain the version of the first enabled Flash plugin.
+  std::vector<webkit::WebPluginInfo> info_array;
+  content::PluginService::GetInstance()->GetPluginInfoArray(
+      GURL(), "application/x-shockwave-flash", false, &info_array, NULL);
+  string16 flash_version =
+      l10n_util::GetStringUTF16(IDS_PLUGINS_DISABLED_PLUGIN);
+  PluginPrefs* plugin_prefs =
+      PluginPrefs::GetForProfile(Profile::FromWebUI(web_ui()));
+  if (plugin_prefs) {
+    for (size_t i = 0; i < info_array.size(); ++i) {
+      if (plugin_prefs->IsPluginEnabled(info_array[i])) {
+        flash_version = info_array[i].version;
+        break;
+      }
+    }
+  }
+
+  scoped_ptr<StringValue> arg(Value::CreateStringValue(flash_version));
+  web_ui()->CallJavascriptFunction("returnFlashVersion", *arg);
+#endif
+}