Read pnacl version from common .json file instead of using dirname.

chrome/browser/ui/webui/nacl_ui.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/nacl_ui.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
+#include "base/json/json_file_value_serializer.h"
 #include "base/memory/weak_ptr.h"
 #include "base/path_service.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/plugins/plugin_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 46 matching lines @@
 
 // The handler for JavaScript messages for the about:flags page.
 class NaClDomHandler : public WebUIMessageHandler {
  public:
   NaClDomHandler();
   virtual ~NaClDomHandler();
 
   // WebUIMessageHandler implementation.
   virtual void RegisterMessages() OVERRIDE;
 
+ private:
   // Callback for the "requestNaClInfo" message.
   void HandleRequestNaClInfo(const ListValue* args);
 
   // Callback for the NaCl plugin information.
   void OnGotPlugins(const std::vector<content::WebPluginInfo>& plugins);
 
   // A helper callback that receives the result of checking if PNaCl path
-  // exists. |is_valid| is true if the PNaCl path that was returned by
-  // PathService is valid, and false otherwise.
-  void DidValidatePnaclPath(bool* is_valid);
+  // exists and checking the PNaCl |version|. |is_valid| is true if the PNaCl
+  // path that was returned by PathService is valid, and false otherwise.
+  void DidCheckPathAndVersion(bool* is_valid, std::string* version);
 
- private:
   // Called when enough information is gathered to return data back to the page.
   void MaybeRespondToPage();
 
   // Helper for MaybeRespondToPage -- called after enough information
   // is gathered.
   void PopulatePageInformation(DictionaryValue* naclInfo);
 
   // Factory for the creating refs in callbacks.
   base::WeakPtrFactory<NaClDomHandler> weak_ptr_factory_;
 
   // Returns whether the specified plugin is enabled.
   bool isPluginEnabled(size_t plugin_index);
 
   // Adds information regarding the operating system and chrome version to list.
   void AddOperatingSystemInfo(ListValue* list);
 
   // Adds the list of plugins for NaCl to list.
   void AddPluginList(ListValue* list);
 
-  // Adds the information relevant to PNaCl (e.g., enablement, paths) to list.
+  // Adds the information relevant to PNaCl (e.g., enablement, paths, version)
+  // to the list.
   void AddPnaclInfo(ListValue* list);
 
   // Adds the information relevant to NaCl to list.
   void AddNaClInfo(ListValue* list);
 
   // Whether the page has requested data.
   bool page_has_requested_data_;
 
   // Whether the plugin information is ready.
   bool has_plugin_info_;
 
   // Whether PNaCl path was validated. PathService can return a path
   // that does not exists, so it needs to be validated.
   bool pnacl_path_validated_;
   bool pnacl_path_exists_;
+  std::string pnacl_version_string_;
 
   DISALLOW_COPY_AND_ASSIGN(NaClDomHandler);
 };
 
 NaClDomHandler::NaClDomHandler()
     : weak_ptr_factory_(this),
       page_has_requested_data_(false),
       has_plugin_info_(false),
       pnacl_path_validated_(false),
       pnacl_path_exists_(false) {
@@ skipping 121 matching lines @@
   base::FilePath pnacl_path;
   bool got_path = PathService::Get(chrome::DIR_PNACL_COMPONENT, &pnacl_path);
   if (!got_path || pnacl_path.empty() || !pnacl_path_exists_) {
     AddPair(list,
             ASCIIToUTF16("PNaCl translator"),
             ASCIIToUTF16("Not installed"));
   } else {
     AddPair(list,
             ASCIIToUTF16("PNaCl translator path"),
             pnacl_path.LossyDisplayName());
-    // Version string is part of the directory name:
-    // pnacl/<version>/_platform_specific/<arch>/[files]
-    // Keep in sync with pnacl_component_installer.cc.
     AddPair(list,
             ASCIIToUTF16("PNaCl translator version"),
-            pnacl_path.DirName().DirName().BaseName().LossyDisplayName());
+            ASCIIToUTF16(pnacl_version_string_));
   }
   AddLineBreak(list);
 }
 
 void NaClDomHandler::AddNaClInfo(ListValue* list) {
   string16 nacl_enabled_string = ASCIIToUTF16("Disabled");
   if (isPluginEnabled(0) &&
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnableNaCl)) {
     nacl_enabled_string = ASCIIToUTF16("Enabled by flag '--enable-nacl'");
   }
   AddPair(list,
           ASCIIToUTF16("Native Client (non-portable, outside web store)"),
           nacl_enabled_string);
   AddLineBreak(list);
 }
 
 void NaClDomHandler::HandleRequestNaClInfo(const ListValue* args) {
   page_has_requested_data_ = true;
-  // Force re-validation of pnacl's path in the next call to
+  // Force re-validation of PNaCl's path in the next call to
   // MaybeRespondToPage(), in case PNaCl went from not-installed
   // to installed since the request.
   pnacl_path_validated_ = false;
   MaybeRespondToPage();
 }
 
 void NaClDomHandler::OnGotPlugins(
     const std::vector<content::WebPluginInfo>& plugins) {
   has_plugin_info_ = true;
   MaybeRespondToPage();
 }
 
 void NaClDomHandler::PopulatePageInformation(DictionaryValue* naclInfo) {
   DCHECK(pnacl_path_validated_);
   // Store Key-Value pairs of about-information.
   scoped_ptr<ListValue> list(new ListValue());
   // Display the operating system and chrome version information.
   AddOperatingSystemInfo(list.get());
   // Display the list of plugins serving NaCl.
   AddPluginList(list.get());
   // Display information relevant to PNaCl.
   AddPnaclInfo(list.get());
   // Display information relevant to NaCl (non-portable.
   AddNaClInfo(list.get());
   // naclInfo will take ownership of list, and clean it up on destruction.
   naclInfo->Set("naclInfo", list.release());
 }
 
-void NaClDomHandler::DidValidatePnaclPath(bool* is_valid) {
+void NaClDomHandler::DidCheckPathAndVersion(bool* is_valid,
+                                            std::string* version) {
   pnacl_path_validated_ = true;
   pnacl_path_exists_ = *is_valid;
+  pnacl_version_string_ = *version;
   MaybeRespondToPage();
 }
 
-void ValidatePnaclPath(bool* is_valid) {
+void CheckVersion(const base::FilePath& pnacl_path, std::string* version) {
+  base::FilePath pnacl_json_path =
+      pnacl_path.Append(FILE_PATH_LITERAL("pnacl_public_pnacl_json"));
+  JSONFileValueSerializer serializer(pnacl_json_path);
+  std::string error;
+  scoped_ptr<base::Value> root(serializer.Deserialize(NULL, &error));
+  if (!root || !root->IsType(base::Value::TYPE_DICTIONARY))
+    return;
+
+  // Now try to get the field. This may leave version empty if the
+  // the "get" fails (no key, or wrong type).
+  static_cast<base::DictionaryValue*>(root.get())->
+      GetStringASCII("pnacl-version", version);
+}
+
+void CheckPathAndVersion(bool* is_valid, std::string* version) {
   base::FilePath pnacl_path;
   bool got_path = PathService::Get(chrome::DIR_PNACL_COMPONENT, &pnacl_path);
   *is_valid = got_path && !pnacl_path.empty() && base::PathExists(pnacl_path);
+  if (*is_valid)
+    CheckVersion(pnacl_path, version);
 }
 
 void NaClDomHandler::MaybeRespondToPage() {
   // Don't reply until everything is ready.  The page will show a 'loading'
   // message until then.
   if (!page_has_requested_data_ || !has_plugin_info_)
     return;
 
   if (!pnacl_path_validated_) {
     bool* is_valid = new bool;
+    std::string* version_string = new std::string;
     BrowserThread::PostBlockingPoolTaskAndReply(
         FROM_HERE,
-        base::Bind(&ValidatePnaclPath, is_valid),
-        base::Bind(&NaClDomHandler::DidValidatePnaclPath,
+        base::Bind(&CheckPathAndVersion, is_valid, version_string),
+        base::Bind(&NaClDomHandler::DidCheckPathAndVersion,
                    weak_ptr_factory_.GetWeakPtr(),
-                   base::Owned(is_valid)));
+                   base::Owned(is_valid),
+                   base::Owned(version_string)));
     return;
   }
 
   DictionaryValue naclInfo;
   PopulatePageInformation(&naclInfo);
   web_ui()->CallJavascriptFunction("nacl.returnNaClInfo", naclInfo);
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 //
 // NaClUI
 //
 ///////////////////////////////////////////////////////////////////////////////
 
 NaClUI::NaClUI(content::WebUI* web_ui) : WebUIController(web_ui) {
   content::RecordAction(UserMetricsAction("ViewAboutNaCl"));
 
   web_ui->AddMessageHandler(new NaClDomHandler());
 
   // Set up the about:nacl source.
   Profile* profile = Profile::FromWebUI(web_ui);
   content::WebUIDataSource::Add(profile, CreateNaClUIHTMLSource());
 }