NetLogEventParameter to Callback refactoring 9.

net/socket/nss_ssl_util.cc

Index: net/socket/nss_ssl_util.cc
===================================================================
--- net/socket/nss_ssl_util.cc	(revision 142108)
+++ net/socket/nss_ssl_util.cc	(working copy)
@@ -11,6 +11,7 @@
 
 #include <string>
 
+#include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/singleton.h"
@@ -220,41 +221,30 @@
   }
 }
 
-// Extra parameters to attach to the NetLog when we receive an error in response
-// to a call to an NSS function.  Used instead of SSLErrorParams with
-// events of type TYPE_SSL_NSS_ERROR.  Automatically looks up last PR error.
-class SSLFailedNSSFunctionParams : public NetLog::EventParameters {
- public:
-  // |param| is ignored if it has a length of 0.
-  SSLFailedNSSFunctionParams(const std::string& function,
-                             const std::string& param)
-      : function_(function), param_(param), ssl_lib_error_(PR_GetError()) {
-  }
+// Returns parameters to attach to the NetLog when we receive an error in
+// response to a call to an NSS function.  Used instead of
+// NetLogSSLErrorCallback with events of type TYPE_SSL_NSS_ERROR.
+// Automatically looks up last PR error.
+Value* NetLogSSLFailedNSSFunctionCallback(
+    const char* function,
+    const char* param,
+    NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("function", function);
+  if (param[0] != '\0')
+    dict->SetString("param", param);
+  dict->SetInteger("ssl_lib_error", PR_GetError());

[eroman, 2012/06/14 17:45:50]

Please take PR_GetError() as a parameter.

My concern with deferring the PR_GetError() is that there is potentially a bunch
of code that runs before this is reached (i.e. other NetLog observers).

If any of that code were to have sideffects that changed the last PR_GetError(),
we could get an unexpected result here! Probably won't happen, but no need to
take that risk.

[mmenke, 2012/06/14 18:03:45]

Done.

I did think about that.  Then I thought that any observer using the network
stack would probably lock while writing to the NetLog, anyways.

+  return dict;
+}
 
-  virtual Value* ToValue() const {
-    DictionaryValue* dict = new DictionaryValue();
-    dict->SetString("function", function_);
-    if (!param_.empty())
-      dict->SetString("param", param_);
-    dict->SetInteger("ssl_lib_error", ssl_lib_error_);
-    return dict;
-  }
-
- protected:
-  virtual ~SSLFailedNSSFunctionParams() {}
-
- private:
-  const std::string function_;
-  const std::string param_;
-  const PRErrorCode ssl_lib_error_;
-};
-
 void LogFailedNSSFunction(const BoundNetLog& net_log,
                           const char* function,
                           const char* param) {
+  DCHECK(function);
+  DCHECK(param);
   net_log.AddEvent(
       NetLog::TYPE_SSL_NSS_ERROR,
-      make_scoped_refptr(new SSLFailedNSSFunctionParams(function, param)));
+      base::Bind(&NetLogSSLFailedNSSFunctionCallback, function, param));
 }
 
 }  // namespace net