NetLogEventParameter to Callback refactoring 7.

net/proxy/proxy_service.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_service.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
@@ skipping 315 matching lines @@
 
   static bool IsSupported() {
 #if defined(OS_WIN) || defined(OS_MACOSX)
     return true;
 #else
     return false;
 #endif
   }
 };
 
-// NetLog parameter to describe a proxy configuration change.
-class ProxyConfigChangedNetLogParam : public NetLog::EventParameters {
- public:
-  ProxyConfigChangedNetLogParam(const ProxyConfig& old_config,
-                                const ProxyConfig& new_config)
-      : old_config_(old_config),
-        new_config_(new_config) {
+// Returns NetLog parameter describing a proxy configuration change.
+Value* NetLogProxyConfigChangedCallback(const ProxyConfig* old_config,
+                                        const ProxyConfig* new_config,
+                                        NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  // The "old_config" is optional -- the first notification will not have
+  // any "previous" configuration.
+  if (old_config->is_valid())
+    dict->Set("old_config", old_config->ToValue());
+  dict->Set("new_config", new_config->ToValue());
+  return dict;
+}
+
+Value* NetLogBadProxyListCallback(const ProxyRetryInfoMap* retry_info,
+                                  NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  ListValue* list = new ListValue();
+
+  for (ProxyRetryInfoMap::const_iterator iter = retry_info->begin();
+       iter != retry_info->end(); ++iter) {
+    list->Append(Value::CreateStringValue(iter->first));
   }
-
-  virtual Value* ToValue() const OVERRIDE {
-    DictionaryValue* dict = new DictionaryValue();
-    // The "old_config" is optional -- the first notification will not have
-    // any "previous" configuration.
-    if (old_config_.is_valid())
-      dict->Set("old_config", old_config_.ToValue());
-    dict->Set("new_config", new_config_.ToValue());
-    return dict;
-  }
-
- protected:
-  virtual ~ProxyConfigChangedNetLogParam() {}
-
- private:
-  const ProxyConfig old_config_;
-  const ProxyConfig new_config_;
-  DISALLOW_COPY_AND_ASSIGN(ProxyConfigChangedNetLogParam);
-};
-
-class BadProxyListNetLogParam : public NetLog::EventParameters {
- public:
-  BadProxyListNetLogParam(const ProxyRetryInfoMap& retry_info) {
-    proxy_list_.reserve(retry_info.size());
-    for (ProxyRetryInfoMap::const_iterator iter = retry_info.begin();
-         iter != retry_info.end(); ++iter) {
-      proxy_list_.push_back(iter->first);
-    }
-  }
-
-  virtual Value* ToValue() const OVERRIDE {
-    DictionaryValue* dict = new DictionaryValue();
-    ListValue* list = new ListValue();
-    for (std::vector<std::string>::const_iterator iter = proxy_list_.begin();
-         iter != proxy_list_.end(); ++iter)
-      list->Append(Value::CreateStringValue(*iter));
-    dict->Set("bad_proxy_list", list);
-    return dict;
-  }
-
- protected:
-  virtual ~BadProxyListNetLogParam() {}
-
- private:
-  std::vector<std::string> proxy_list_;
-  DISALLOW_COPY_AND_ASSIGN(BadProxyListNetLogParam);
-};
+  dict->Set("bad_proxy_list", list);
+  return dict;
+}
 
 #if defined(OS_CHROMEOS)
 class UnsetProxyConfigService : public ProxyConfigService {
  public:
   UnsetProxyConfigService() {}
   virtual ~UnsetProxyConfigService() {}
 
   virtual void AddObserver(Observer* observer) {}
   virtual void RemoveObserver(Observer* observer) {}
   virtual ConfigAvailability GetLatestProxyConfig(ProxyConfig* config) {
@@ skipping 438 matching lines @@
 
   void CancelResolveJob() {
     DCHECK(is_started());
     // The request may already be running in the resolver.
     resolver()->CancelRequest(resolve_job_);
     resolve_job_ = NULL;
     DCHECK(!is_started());
   }
 
   void Cancel() {
-    net_log_.AddEvent(NetLog::TYPE_CANCELLED, NULL);
+    net_log_.AddEvent(NetLog::TYPE_CANCELLED);
 
     if (is_started())
       CancelResolveJob();
 
     // Mark as cancelled, to prevent accessing this again later.
     service_ = NULL;
     user_callback_.Reset();
     results_ = NULL;
 
-    net_log_.EndEvent(NetLog::TYPE_PROXY_SERVICE, NULL);
+    net_log_.EndEvent(NetLog::TYPE_PROXY_SERVICE);
   }
 
   // Returns true if Cancel() has been called.
   bool was_cancelled() const {
     return user_callback_.is_null();
   }
 
   // Helper to call after ProxyResolver completion (both synchronous and
   // asynchronous). Fixes up the result that is to be returned to user.
   int QueryDidComplete(int result_code) {
@@ skipping 182 matching lines @@
 }
 
 int ProxyService::ResolveProxy(const GURL& raw_url,
                                ProxyInfo* result,
                                const net::CompletionCallback& callback,
                                PacRequest** pac_request,
                                const BoundNetLog& net_log) {
   DCHECK(CalledOnValidThread());
   DCHECK(!callback.is_null());
 
-  net_log.BeginEvent(NetLog::TYPE_PROXY_SERVICE, NULL);
+  net_log.BeginEvent(NetLog::TYPE_PROXY_SERVICE);
 
   // Notify our polling-based dependencies that a resolve is taking place.
   // This way they can schedule their polls in response to network activity.
   config_service_->OnLazyPoll();
   if (script_poller_.get())
      script_poller_->OnLazyPoll();
 
   if (current_state_ == STATE_NONE)
     ApplyProxyConfigIfAvailable();
 
   // Strip away any reference fragments and the username/password, as they
   // are not relevant to proxy resolution.
   GURL url = SimplifyUrlForRequest(raw_url);
 
   // Check if the request can be completed right away. (This is the case when
   // using a direct connection for example).
   int rv = TryToCompleteSynchronously(url, result);
   if (rv != ERR_IO_PENDING)
     return DidFinishResolvingProxy(result, rv, net_log);
 
   scoped_refptr<PacRequest> req(
       new PacRequest(this, url, result, callback, net_log));
 
   if (current_state_ == STATE_READY) {
     // Start the resolve request.
     rv = req->Start();
     if (rv != ERR_IO_PENDING)
       return req->QueryDidComplete(rv);
   } else {
-    req->net_log()->BeginEvent(NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC,
-                               NULL);
+    req->net_log()->BeginEvent(NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
   }
 
   DCHECK_EQ(ERR_IO_PENDING, rv);
   DCHECK(!ContainsPendingRequest(req));
   pending_requests_.push_back(req);
 
   // Completion will be notified through |callback|, unless the caller cancels
   // the request using |pac_request|.
   if (pac_request)
     *pac_request = req.get();
@@ skipping 38 matching lines @@
 
 void ProxyService::SuspendAllPendingRequests() {
   for (PendingRequests::iterator it = pending_requests_.begin();
        it != pending_requests_.end();
        ++it) {
     PacRequest* req = it->get();
     if (req->is_started()) {
       req->CancelResolveJob();
 
       req->net_log()->BeginEvent(
-          NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC, NULL);
+          NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
     }
   }
 }
 
 void ProxyService::SetReady() {
   DCHECK(!init_proxy_resolver_.get());
   current_state_ = STATE_READY;
 
   // Make a copy in case |this| is deleted during the synchronous completion
   // of one of the requests. If |this| is deleted then all of the PacRequest
   // instances will be Cancel()-ed.
   PendingRequests pending_copy = pending_requests_;
 
   for (PendingRequests::iterator it = pending_copy.begin();
        it != pending_copy.end();
        ++it) {
     PacRequest* req = it->get();
     if (!req->is_started() && !req->was_cancelled()) {
-      req->net_log()->EndEvent(NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC,
-                               NULL);
+      req->net_log()->EndEvent(NetLog::TYPE_PROXY_SERVICE_WAITING_FOR_INIT_PAC);
 
       // Note that we re-check for synchronous completion, in case we are
       // no longer using a ProxyResolver (can happen if we fell-back to manual).
       req->StartAndCompleteCheckingForSynchronous();
     }
   }
 }
 
 void ProxyService::ApplyProxyConfigIfAvailable() {
   DCHECK_EQ(STATE_NONE, current_state_);
@@ skipping 109 matching lines @@
        iter != new_retry_info.end(); ++iter) {
     ProxyRetryInfoMap::iterator existing = proxy_retry_info_.find(iter->first);
     if (existing == proxy_retry_info_.end())
       proxy_retry_info_[iter->first] = iter->second;
     else if (existing->second.bad_until < iter->second.bad_until)
       existing->second.bad_until = iter->second.bad_until;
   }
   if (net_log_) {
     net_log_->AddGlobalEntry(
         NetLog::TYPE_BAD_PROXY_LIST_REPORTED,
-        make_scoped_refptr(
-            new BadProxyListNetLogParam(new_retry_info)));
+        base::Bind(&NetLogBadProxyListCallback, &new_retry_info));
   }
 }
 
 void ProxyService::CancelPacRequest(PacRequest* req) {
   DCHECK(CalledOnValidThread());
   DCHECK(req);
   req->Cancel();
   RemovePendingRequest(req);
 }
 
@@ skipping 15 matching lines @@
   pending_requests_.erase(it);
 }
 
 int ProxyService::DidFinishResolvingProxy(ProxyInfo* result,
                                           int result_code,
                                           const BoundNetLog& net_log) {
   // Log the result of the proxy resolution.
   if (result_code == OK) {
     // When logging all events is enabled, dump the proxy list.
     if (net_log.IsLoggingAllEvents()) {
+      std::string pac_string = result->ToPacString();

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

Can this be internalized into the NetLog callback?

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

Done.  Didn't do it before because of the "IsLoggingAllEvents()" check.

I suspect that once we get rid of the alway-on-observers, we'll want to get rid
of basic logging entirely, and have the NetLog just not get the lock unless it
has active observers.

       net_log.AddEvent(
           NetLog::TYPE_PROXY_SERVICE_RESOLVED_PROXY_LIST,
-          make_scoped_refptr(new NetLogStringParameter(
-              "pac_string", result->ToPacString())));
+          NetLog::StringCallback("pac_string", &pac_string));
     }
     result->DeprioritizeBadProxies(proxy_retry_info_);
   } else {
-    net_log.AddEvent(
-        NetLog::TYPE_PROXY_SERVICE_RESOLVED_PROXY_LIST,
-        make_scoped_refptr(new NetLogIntegerParameter(
-            "net_error", result_code)));
+    net_log.AddEventWithNetErrorCode(
+        NetLog::TYPE_PROXY_SERVICE_RESOLVED_PROXY_LIST, result_code);
 
     if (!config_.pac_mandatory()) {
       // Fall-back to direct when the proxy resolver fails. This corresponds
       // with a javascript runtime error in the PAC script.
       //
       // This implicit fall-back to direct matches Firefox 3.5 and
       // Internet Explorer 8. For more information, see:
       //
       // http://www.chromium.org/developers/design-documents/proxy-settings-fallback
       result->UseDirect();
       result_code = OK;
     } else {
       result_code = ERR_MANDATORY_PROXY_CONFIGURATION_FAILED;
     }
   }
 
-  net_log.EndEvent(NetLog::TYPE_PROXY_SERVICE, NULL);
+  net_log.EndEvent(NetLog::TYPE_PROXY_SERVICE);
   return result_code;
 }
 
 void ProxyService::SetProxyScriptFetchers(
     ProxyScriptFetcher* proxy_script_fetcher,
     DhcpProxyScriptFetcher* dhcp_proxy_script_fetcher) {
   DCHECK(CalledOnValidThread());
   State previous_state = ResetProxyConfig(false);
   proxy_script_fetcher_.reset(proxy_script_fetcher);
   dhcp_proxy_script_fetcher_.reset(dhcp_proxy_script_fetcher);
@@ skipping 125 matching lines @@
     case ProxyConfigService::CONFIG_VALID:
       effective_config = config;
       break;
     case ProxyConfigService::CONFIG_UNSET:
       effective_config = ProxyConfig::CreateDirect();
       break;
   }
 
   // Emit the proxy settings change to the NetLog stream.
   if (net_log_) {
-    scoped_refptr<NetLog::EventParameters> params(
-        new ProxyConfigChangedNetLogParam(fetched_config_, effective_config));
-    net_log_->AddGlobalEntry(net::NetLog::TYPE_PROXY_CONFIG_CHANGED,
-                                params);
+    net_log_->AddGlobalEntry(
+        net::NetLog::TYPE_PROXY_CONFIG_CHANGED,
+        base::Bind(&NetLogProxyConfigChangedCallback,
+                   &fetched_config_, &effective_config));
   }
 
   // Set the new configuration as the most recently fetched one.
   fetched_config_ = effective_config;
   fetched_config_.set_id(1);  // Needed for a later DCHECK of is_valid().
 
   InitializeUsingLastFetchedConfig();
 }
 
 void ProxyService::InitializeUsingLastFetchedConfig() {
@@ skipping 131 matching lines @@
     OnCompletion(result_);
   }
 }
 
 void SyncProxyServiceHelper::OnCompletion(int rv) {
   result_ = rv;
   event_.Signal();
 }
 
 }  // namespace net