NetLogEventParameter to Callback refactoring 7.

net/proxy/proxy_resolver_js_bindings.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 "net/proxy/proxy_resolver_js_bindings.h"
 
+#include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "net/base/address_list.h"
 #include "net/base/host_cache.h"
 #include "net/base/host_resolver.h"
 #include "net/base/net_errors.h"
 #include "net/base/net_log.h"
 #include "net/base/net_util.h"
 #include "net/proxy/proxy_resolver_error_observer.h"
 #include "net/proxy/proxy_resolver_request_context.h"
 #include "net/proxy/sync_host_resolver.h"
 
 namespace net {
 
 namespace {
 
 // TTL for the per-request DNS cache. Applies to both successful and failed
 // DNS resolutions.
 const unsigned kCacheEntryTTLSeconds = 5 * 60;
 
-// Event parameters for a PAC error message (line number + message).
-class ErrorNetlogParams : public NetLog::EventParameters {
- public:
-  ErrorNetlogParams(int line_number,
-                    const string16& message)
-      : line_number_(line_number),
-        message_(message) {
-  }
+// Returns event parameters for a PAC error message (line number + message).
+Value* NetLogErrorCallback(int line_number,
+                           const string16* message,
+                           NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetInteger("line_number", line_number);
+  dict->SetString("message", *message);
+  return dict;
+}
 
-  virtual Value* ToValue() const OVERRIDE {
-    DictionaryValue* dict = new DictionaryValue();
-    dict->SetInteger("line_number", line_number_);
-    dict->SetString("message", message_);
-    return dict;
-  }
-
- protected:
-  virtual ~ErrorNetlogParams() {}
-
- private:
-  const int line_number_;
-  const string16 message_;
-
-  DISALLOW_COPY_AND_ASSIGN(ErrorNetlogParams);
-};
-
-// Event parameters for a PAC alert().
-class AlertNetlogParams : public NetLog::EventParameters {
- public:
-  explicit AlertNetlogParams(const string16& message) : message_(message) {}
-
-  virtual Value* ToValue() const OVERRIDE {
-    DictionaryValue* dict = new DictionaryValue();
-    dict->SetString("message", message_);
-    return dict;
-  }
-
- protected:
-  virtual ~AlertNetlogParams() {}
-
- private:
-  const string16 message_;
-
-  DISALLOW_COPY_AND_ASSIGN(AlertNetlogParams);
-};
+// Returns event parameters for a PAC alert().
+Value* NetLogAlertCallback(const string16* message,
+                           NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("message", *message);
+  return dict;
+}
 
 // ProxyResolverJSBindings implementation.
 class DefaultJSBindings : public ProxyResolverJSBindings {
  public:
   DefaultJSBindings(SyncHostResolver* host_resolver,
                     NetLog* net_log,
                     ProxyResolverErrorObserver* error_observer)
       : host_resolver_(host_resolver),
         net_log_(net_log),
         error_observer_(error_observer) {
   }
 
   // Handler for "alert(message)".
   virtual void Alert(const string16& message) OVERRIDE {
     VLOG(1) << "PAC-alert: " << message;
 
     // Send to the NetLog.
-    LogEventToCurrentRequestAndGlobally(NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
-                                        new AlertNetlogParams(message));
+    LogEventToCurrentRequestAndGlobally(
+        NetLog::TYPE_PAC_JAVASCRIPT_ALERT,
+        base::Bind(&NetLogAlertCallback, &message));

[eroman, 2012/06/13 18:55:33]

Perhaps this can just use a generic NetLogString16Callback.

Only difference from the existing const std::string* flavor is that this is a
string16.

[mmenke, 2012/06/13 20:27:58]

Done.

   }
 
   // Handler for "myIpAddress()".
   // TODO(eroman): Perhaps enumerate the interfaces directly, using
   // getifaddrs().
   virtual bool MyIpAddress(std::string* first_ip_address) OVERRIDE {
     LogEventToCurrentRequest(NetLog::PHASE_BEGIN,
-                             NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS,
-                             NULL);
+                             NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS);
 
     bool ok = MyIpAddressImpl(first_ip_address);
 
     LogEventToCurrentRequest(NetLog::PHASE_END,
-                             NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS,
-                             NULL);
+                             NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS);
     return ok;
   }
 
   // Handler for "myIpAddressEx()".
   virtual bool MyIpAddressEx(std::string* ip_address_list) OVERRIDE {
     LogEventToCurrentRequest(NetLog::PHASE_BEGIN,
-                             NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS_EX,
-                             NULL);
+                             NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS_EX);
 
     bool ok = MyIpAddressExImpl(ip_address_list);
 
     LogEventToCurrentRequest(NetLog::PHASE_END,
-                             NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS_EX,
-                             NULL);
+                             NetLog::TYPE_PAC_JAVASCRIPT_MY_IP_ADDRESS_EX);
     return ok;
   }
 
   // Handler for "dnsResolve(host)".
   virtual bool DnsResolve(const std::string& host,
                           std::string* first_ip_address) OVERRIDE {
     LogEventToCurrentRequest(NetLog::PHASE_BEGIN,
-                             NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE,
-                             NULL);
+                             NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE);
 
     bool ok = DnsResolveImpl(host, first_ip_address);
 
     LogEventToCurrentRequest(NetLog::PHASE_END,
-                             NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE,
-                             NULL);
+                             NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE);
     return ok;
   }
 
   // Handler for "dnsResolveEx(host)".
   virtual bool DnsResolveEx(const std::string& host,
                             std::string* ip_address_list) OVERRIDE {
     LogEventToCurrentRequest(NetLog::PHASE_BEGIN,
-                             NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE_EX,
-                             NULL);
+                             NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE_EX);
 
     bool ok = DnsResolveExImpl(host, ip_address_list);
 
     LogEventToCurrentRequest(NetLog::PHASE_END,
-                             NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE_EX,
-                             NULL);
+                             NetLog::TYPE_PAC_JAVASCRIPT_DNS_RESOLVE_EX);
     return ok;
   }
 
   // Handler for when an error is encountered. |line_number| may be -1.
   virtual void OnError(int line_number, const string16& message) OVERRIDE {
     // Send to the chrome log.
     if (line_number == -1)
       VLOG(1) << "PAC-error: " << message;
     else
       VLOG(1) << "PAC-error: " << "line: " << line_number << ": " << message;
 
     // Send the error to the NetLog.
     LogEventToCurrentRequestAndGlobally(
         NetLog::TYPE_PAC_JAVASCRIPT_ERROR,
-        new ErrorNetlogParams(line_number, message));
+        base::Bind(&NetLogErrorCallback, line_number, &message));
 
     if (error_observer_.get())
       error_observer_->OnPACScriptError(line_number, message);
   }
 
   virtual void Shutdown() OVERRIDE {
     host_resolver_->Shutdown();
   }
 
  private:
@@ skipping 105 matching lines @@
 
   // May return NULL.
   const BoundNetLog* GetNetLogForCurrentRequest() {
     if (!current_request_context())
       return NULL;
     return current_request_context()->net_log;
   }
 
   void LogEventToCurrentRequest(
       NetLog::EventPhase phase,
+      NetLog::EventType type) {
+    const BoundNetLog* net_log = GetNetLogForCurrentRequest();
+    if (net_log)
+      net_log->AddEntry(type, phase);
+  }
+
+  void LogEventToCurrentRequest(
+      NetLog::EventPhase phase,
       NetLog::EventType type,
-      scoped_refptr<NetLog::EventParameters> params) {
+      const NetLog::ParametersCallback& parameters_callback) {
     const BoundNetLog* net_log = GetNetLogForCurrentRequest();
     if (net_log)
-      net_log->AddEntry(type, phase, params);
+      net_log->AddEntry(type, phase, parameters_callback);
   }
 
   void LogEventToCurrentRequestAndGlobally(
       NetLog::EventType type,
-      scoped_refptr<NetLog::EventParameters> params) {
-    LogEventToCurrentRequest(NetLog::PHASE_NONE, type, params);
+      const NetLog::ParametersCallback& parameters_callback) {
+    LogEventToCurrentRequest(NetLog::PHASE_NONE, type, parameters_callback);
 
     // Emit to the global NetLog event stream.
     if (net_log_)
-      net_log_->AddGlobalEntry(type, params);
+      net_log_->AddGlobalEntry(type, parameters_callback);
   }
 
   scoped_ptr<SyncHostResolver> host_resolver_;
   NetLog* net_log_;
   scoped_ptr<ProxyResolverErrorObserver> error_observer_;
   DISALLOW_COPY_AND_ASSIGN(DefaultJSBindings);
 };
 
 }  // namespace
 
 // static
 ProxyResolverJSBindings* ProxyResolverJSBindings::CreateDefault(
     SyncHostResolver* host_resolver,
     NetLog* net_log,
     ProxyResolverErrorObserver* error_observer) {
   return new DefaultJSBindings(host_resolver, net_log, error_observer);
 }
 
 }  // namespace net