chrome://nacl asserts

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"
@@ skipping 22 matching lines @@
 #include "grit/generated_resources.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "webkit/plugins/webplugininfo.h"
 
 #if defined(OS_WIN)
 #include "base/win/windows_version.h"
 #endif
 
+using content::BrowserThread;
 using content::PluginService;
 using content::UserMetricsAction;
 using content::WebUIMessageHandler;
 
 namespace {
 
 content::WebUIDataSource* CreateNaClUIHTMLSource() {
   content::WebUIDataSource* source =
       content::WebUIDataSource::Create(chrome::kChromeUINaClHost);
 
   source->SetUseJsonJSFormatV2();
   source->AddLocalizedString("loadingMessage", IDS_NACL_LOADING_MESSAGE);
   source->AddLocalizedString("naclLongTitle", IDS_NACL_TITLE_MESSAGE);
   source->SetJsonPath("strings.js");
   source->AddResourcePath("about_nacl.css", IDR_ABOUT_NACL_CSS);
   source->AddResourcePath("about_nacl.js", IDR_ABOUT_NACL_JS);
   source->SetDefaultResource(IDR_ABOUT_NACL_HTML);
   return source;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // NaClDOMHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 
+class NaClDOMHandler;
+
+class NaClDOMHandlerProxy : public
+    base::RefCountedThreadSafe<NaClDOMHandlerProxy> {
+ public:
+  explicit NaClDOMHandlerProxy(NaClDOMHandler* handler);
+
+  // A helper to check if PNaCl path exists.
+  void ValidatePnaclPath();
+
+  void set_handler(NaClDOMHandler* handler) {
+    handler_ = handler;
+  }
+
+ private:
+  // A helper callback that receives the result of checking if PNaCl path
+  // exists.
+  void ValidatePnaclPathCallback(bool is_valid);
+
+  // The handler that requested checking PNaCl file path.
+  NaClDOMHandler* handler_;
+
+  DISALLOW_COPY_AND_ASSIGN(NaClDOMHandlerProxy);
+};
+
 // The handler for JavaScript messages for the about:flags page.
 class NaClDOMHandler : public WebUIMessageHandler {
  public:
   NaClDOMHandler();
   virtual ~NaClDOMHandler();
 
   // WebUIMessageHandler implementation.
   virtual void RegisterMessages() OVERRIDE;
 
   // Callback for the "requestNaClInfo" message.
   void HandleRequestNaClInfo(const ListValue* args);
 
   // Callback for the NaCl plugin information.
   void OnGotPlugins(const std::vector<webkit::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);
+
  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_;
 
   // 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_;
+
+  // A proxy for handling cross threads messages.
+  scoped_refptr<NaClDOMHandlerProxy> proxy_;
+
   DISALLOW_COPY_AND_ASSIGN(NaClDOMHandler);
 };
 
+NaClDOMHandlerProxy::NaClDOMHandlerProxy(NaClDOMHandler* handler)
+    : handler_(handler) {
+}
+
+void NaClDOMHandlerProxy::ValidatePnaclPath() {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
+    BrowserThread::PostTask(
+        BrowserThread::FILE, FROM_HERE,
+        base::Bind(&NaClDOMHandlerProxy::ValidatePnaclPath, this));
+    return;
+  }
+
+  bool is_valid = true;
+  base::FilePath pnacl_path;
+  bool got_path = PathService::Get(chrome::DIR_PNACL_COMPONENT, &pnacl_path);
+  // The PathService may return an empty string if PNaCl is not yet installed.
+  // However, do not trust that the path returned by the PathService exists.
+  // Check for existence here.
+  if (!got_path || pnacl_path.empty() || !file_util::PathExists(pnacl_path)) {
+    is_valid = false;
+  }
+  ValidatePnaclPathCallback(is_valid);
+}
+
+void NaClDOMHandlerProxy::ValidatePnaclPathCallback(bool is_valid) {
+  if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&NaClDOMHandlerProxy::ValidatePnaclPathCallback,
+        this, is_valid));
+    return;
+  }
+
+  if (handler_)

[James Hawkins, 2013/05/16 17:42:18]

nit: Document why this check is required.

[yael.aharon1, 2013/05/16 17:53:05]

Done.

+    handler_->DidValidatePnaclPath(is_valid);
+}
+
 NaClDOMHandler::NaClDOMHandler()
     : weak_ptr_factory_(this),
       page_has_requested_data_(false),
-      has_plugin_info_(false) {
+      has_plugin_info_(false),
+      pnacl_path_validated_(false),
+      pnacl_path_exists_(false),
+      proxy_(new NaClDOMHandlerProxy(this)) {
   PluginService::GetInstance()->GetPlugins(base::Bind(
       &NaClDOMHandler::OnGotPlugins, weak_ptr_factory_.GetWeakPtr()));
 }
 
 NaClDOMHandler::~NaClDOMHandler() {
+  if (proxy_) {
+    proxy_->set_handler(NULL);
+  }
 }
 
 void NaClDOMHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "requestNaClInfo",
       base::Bind(&NaClDOMHandler::HandleRequestNaClInfo,
                  base::Unretained(this)));
 }
 
 // Helper functions for collecting a list of key-value pairs that will
@@ skipping 24 matching lines @@
   MaybeRespondToPage();
 }
 
 void NaClDOMHandler::OnGotPlugins(
     const std::vector<webkit::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());
 
   // Obtain the Chrome version info.
   chrome::VersionInfo version_info;
   AddPair(list.get(),
           l10n_util::GetStringUTF16(IDS_PRODUCT_NAME),
           ASCIIToUTF16(version_info.Version() + " (" +
                        chrome::VersionInfo::GetVersionStringModifier() + ")"));
 
@@ skipping 59 matching lines @@
   }
 
   // Check that commandline flags are enabled.
   ListFlagStatus(list.get(), "Flag '--enable-nacl'", switches::kEnableNaCl);
 
   AddLineBreak(list.get());
 
   // Obtain the version of the PNaCl translator.
   base::FilePath pnacl_path;
   bool got_path = PathService::Get(chrome::DIR_PNACL_COMPONENT, &pnacl_path);
-  // The PathService may return an empty string if PNaCl is not yet installed.
-  // However, do not trust that the path returned by the PathService exists.
-  // Check for existence here.
-  if (!got_path || pnacl_path.empty() || !file_util::PathExists(pnacl_path)) {
+  if (!got_path || pnacl_path.empty() || !pnacl_path_exists_) {
     AddPair(list.get(),
             ASCIIToUTF16("PNaCl translator"),
             ASCIIToUTF16("Not installed"));
   } else {
     AddPair(list.get(),
             ASCIIToUTF16("PNaCl translator path"),
             pnacl_path.LossyDisplayName());
     AddPair(list.get(),
             ASCIIToUTF16("PNaCl translator version"),
             pnacl_path.BaseName().LossyDisplayName());
   }
 
   ListFlagStatus(list.get(), "Flag '--enable-pnacl'", switches::kEnablePnacl);
   // naclInfo will take ownership of list, and clean it up on destruction.
   naclInfo->Set("naclInfo", list.release());
 }
 
+void NaClDOMHandler::DidValidatePnaclPath(bool is_valid) {
+  pnacl_path_validated_ = true;
+  pnacl_path_exists_ = is_valid;
+  MaybeRespondToPage();
+}
+
 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_) {
+    DCHECK(proxy_);
+    proxy_->ValidatePnaclPath();
+    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());
 }