Fix style issues in NaClDomHandlerProxy.

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 45 matching lines @@
   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
+// NaClDomHandler
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-class NaClDOMHandler;
+class NaClDomHandler;
 
 // This class performs a check that the PNaCl path which was returned by
-// PathService is valid. One class instance is created per NaClDOMHandler
+// PathService is valid. One class instance is created per NaClDomHandler
 // and it is destroyed after the check is completed.
-class NaClDOMHandlerProxy : public
-    base::RefCountedThreadSafe<NaClDOMHandlerProxy> {
+class NaClDomHandlerProxy
+    : public base::RefCountedThreadSafe<NaClDomHandlerProxy> {
  public:
-  explicit NaClDOMHandlerProxy(NaClDOMHandler* handler);
+  explicit NaClDomHandlerProxy(NaClDomHandler* handler);
 
   // A helper to check if PNaCl path exists.
   void ValidatePnaclPath();
 
-  void set_handler(NaClDOMHandler* handler) {
-    handler_ = handler;
-  }
+  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);
 
-  virtual ~NaClDOMHandlerProxy() {}
-  friend class base::RefCountedThreadSafe<NaClDOMHandlerProxy>;
+  friend class base::RefCountedThreadSafe<NaClDomHandlerProxy>;
+  virtual ~NaClDomHandlerProxy() {}

[Dan Beam, 2013/05/17 02:05:50]

move these above validatepncalpathcallback()

[yael.aharon1, 2013/05/17 02:20:06]

Done.

 
   // The handler that requested checking PNaCl file path.
-  NaClDOMHandler* handler_;
+  NaClDomHandler* handler_; // weak

[Dan Beam, 2013/05/17 02:05:50]

;  // weak.

(two spaces, .)

[yael.aharon1, 2013/05/17 02:20:06]

Done.

 
-  DISALLOW_COPY_AND_ASSIGN(NaClDOMHandlerProxy);
+  DISALLOW_COPY_AND_ASSIGN(NaClDomHandlerProxy);
 };
 
 // The handler for JavaScript messages for the about:flags page.
-class NaClDOMHandler : public WebUIMessageHandler {
+class NaClDomHandler : public WebUIMessageHandler {
  public:
-  NaClDOMHandler();
-  virtual ~NaClDOMHandler();
+  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
+  // 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_;
+  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_;
+  scoped_refptr<NaClDomHandlerProxy> proxy_;
 
-  DISALLOW_COPY_AND_ASSIGN(NaClDOMHandler);
+  DISALLOW_COPY_AND_ASSIGN(NaClDomHandler);
 };
 
-NaClDOMHandlerProxy::NaClDOMHandlerProxy(NaClDOMHandler* handler)
+NaClDomHandlerProxy::NaClDomHandlerProxy(NaClDomHandler* handler)
     : handler_(handler) {
 }
 
-void NaClDOMHandlerProxy::ValidatePnaclPath() {
+void NaClDomHandlerProxy::ValidatePnaclPath() {
   if (!BrowserThread::CurrentlyOn(BrowserThread::FILE)) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
-        base::Bind(&NaClDOMHandlerProxy::ValidatePnaclPath, this));
+        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);
+  ValidatePnaclPathCallback(
+    got_path && !pnacl_path.empty() && file_util::PathExists(pnacl_path) );

[Dan Beam, 2013/05/17 02:05:50]

nit: s/) )/))/ (remove space)

[yael.aharon1, 2013/05/17 02:20:06]

Done.

 }
 
-void NaClDOMHandlerProxy::ValidatePnaclPathCallback(bool is_valid) {
+void NaClDomHandlerProxy::ValidatePnaclPathCallback(bool is_valid) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&NaClDOMHandlerProxy::ValidatePnaclPathCallback,
+        base::Bind(&NaClDomHandlerProxy::ValidatePnaclPathCallback,
         this, is_valid));
     return;
   }
 
   // Check that handler_ is still valid, it could be set to NULL if navigation
   // happened while checking that the PNaCl file exists.
   if (handler_)
     handler_->DidValidatePnaclPath(is_valid);
 }
 
-NaClDOMHandler::NaClDOMHandler()
+NaClDomHandler::NaClDomHandler()
     : weak_ptr_factory_(this),
       page_has_requested_data_(false),
       has_plugin_info_(false),
       pnacl_path_validated_(false),
       pnacl_path_exists_(false),
-      proxy_(new NaClDOMHandlerProxy(this)) {
+      proxy_(new NaClDomHandlerProxy(this)) {
   PluginService::GetInstance()->GetPlugins(base::Bind(
-      &NaClDOMHandler::OnGotPlugins, weak_ptr_factory_.GetWeakPtr()));
+      &NaClDomHandler::OnGotPlugins, weak_ptr_factory_.GetWeakPtr()));
 }
 
-NaClDOMHandler::~NaClDOMHandler() {
+NaClDomHandler::~NaClDomHandler() {
   if (proxy_)
     proxy_->set_handler(NULL);
 }
 
-void NaClDOMHandler::RegisterMessages() {
+void NaClDomHandler::RegisterMessages() {
   web_ui()->RegisterMessageCallback(
       "requestNaClInfo",
-      base::Bind(&NaClDOMHandler::HandleRequestNaClInfo,
+      base::Bind(&NaClDomHandler::HandleRequestNaClInfo,
                  base::Unretained(this)));
 }
 
 // Helper functions for collecting a list of key-value pairs that will
 // be displayed.
 void AddPair(ListValue* list, const string16& key, const string16& value) {
   DictionaryValue* results = new DictionaryValue();
   results->SetString("key", key);
   results->SetString("value", value);
   list->Append(results);
 }
 
 // Generate an empty data-pair which acts as a line break.
 void AddLineBreak(ListValue* list) {
   AddPair(list, ASCIIToUTF16(""), ASCIIToUTF16(""));
 }
 
 // Check whether a commandline switch is turned on or off.
 void ListFlagStatus(ListValue* list, const std::string& flag_label,
                     const std::string& flag_name) {
   if (CommandLine::ForCurrentProcess()->HasSwitch(flag_name))
     AddPair(list, ASCIIToUTF16(flag_label), ASCIIToUTF16("On"));
   else
     AddPair(list, ASCIIToUTF16(flag_label), ASCIIToUTF16("Off"));
 }
 
-void NaClDOMHandler::HandleRequestNaClInfo(const ListValue* args) {
+void NaClDomHandler::HandleRequestNaClInfo(const ListValue* args) {
   page_has_requested_data_ = true;
   MaybeRespondToPage();
 }
 
-void NaClDOMHandler::OnGotPlugins(
+void NaClDomHandler::OnGotPlugins(
     const std::vector<webkit::WebPluginInfo>& plugins) {
   has_plugin_info_ = true;
   MaybeRespondToPage();
 }
 
-void NaClDOMHandler::PopulatePageInformation(DictionaryValue* naclInfo) {
+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 78 matching lines @@
     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) {
+void NaClDomHandler::DidValidatePnaclPath(bool is_valid) {
   pnacl_path_validated_ = true;
   pnacl_path_exists_ = is_valid;
   MaybeRespondToPage();
 }
 
-void NaClDOMHandler::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());
+  web_ui->AddMessageHandler(new NaClDomHandler());
 
   // Set up the about:nacl source.
   Profile* profile = Profile::FromWebUI(web_ui);
   content::WebUIDataSource::Add(profile, CreateNaClUIHTMLSource());
 }