NetLogEventParameter to Callback refactoring 4.

net/dns/dns_transaction.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/dns/dns_transaction.h"
 
 #include <deque>
 #include <string>
 #include <vector>
 
@@ skipping 32 matching lines @@
   for (size_t i = 0; i < name.size() && name[i]; i += name[i] + 1)
     ++count;
   return count;
 }
 
 bool IsIPLiteral(const std::string& hostname) {
   IPAddressNumber ip;
   return ParseIPLiteralToNumber(hostname, &ip);
 }
 
-class StartParameters : public NetLog::EventParameters {
- public:
-  StartParameters(const std::string& hostname,
-                  uint16 qtype)
-      : hostname_(hostname), qtype_(qtype) {}
-
-  virtual Value* ToValue() const OVERRIDE {
-    DictionaryValue* dict = new DictionaryValue();
-    dict->SetString("hostname", hostname_);
-    dict->SetInteger("query_type", qtype_);
-    return dict;
-  }
-
- protected:
-  virtual ~StartParameters() {}
-
- private:
-  const std::string hostname_;
-  const uint16 qtype_;
-};
-
-class ResponseParameters : public NetLog::EventParameters {
- public:
-  ResponseParameters(int rcode, int answer_count, const NetLog::Source& source)
-      : rcode_(rcode), answer_count_(answer_count), source_(source) {}
-
-  virtual Value* ToValue() const OVERRIDE {
-    DictionaryValue* dict = new DictionaryValue();
-    dict->SetInteger("rcode", rcode_);
-    dict->SetInteger("answer_count", answer_count_);
-    dict->Set("source_dependency", source_.ToValue());
-    return dict;
-  }
-
- protected:
-  virtual ~ResponseParameters() {}
-
- private:
-  const int rcode_;
-  const int answer_count_;
-  const NetLog::Source source_;
+Value* NetLogStartCallback(const std::string* hostname,
+                           uint16 qtype,
+                           NetLog::LogLevel /* log_level */) {
+  DictionaryValue* dict = new DictionaryValue();
+  dict->SetString("hostname", *hostname);
+  dict->SetInteger("query_type", qtype);
+  return dict;
 };
 
 // ----------------------------------------------------------------------------
 
 // A single asynchronous DNS exchange over UDP, which consists of sending out a
 // DNS query, waiting for a response, and returning the response that it
 // matches. Logging is done in the socket and in the outer DnsTransaction.
 class DnsUDPAttempt {
  public:
   DnsUDPAttempt(scoped_ptr<DatagramClientSocket> socket,
@@ skipping 23 matching lines @@
     return socket_.get();
   }
 
   // Returns the response or NULL if has not received a matching response from
   // the server.
   const DnsResponse* response() const {
     const DnsResponse* resp = response_.get();
     return (resp != NULL && resp->IsValid()) ? resp : NULL;
   }
 
+  // Returns a Value representing the received response, along with a reference
+  // to the NetLog source source of the UDP socket used.  The request must have
+  // completed before this is called.
+  Value* NetLogResponseCallback(NetLog::LogLevel /* log_level */) const {
+    DCHECK(response_->IsValid());
+
+    DictionaryValue* dict = new DictionaryValue();
+    dict->SetInteger("rcode", response_->rcode());
+    dict->SetInteger("answer_count", response_->answer_count());
+    socket_->NetLog().source().AddToEventParameters(dict);
+    return dict;
+  }
+
  private:
   enum State {
     STATE_CONNECT,
     STATE_SEND_QUERY,
     STATE_SEND_QUERY_COMPLETE,
     STATE_READ_RESPONSE,
     STATE_READ_RESPONSE_COMPLETE,
     STATE_NONE,
   };
 
@@ skipping 150 matching lines @@
   }
 
   virtual uint16 GetType() const OVERRIDE {
     DCHECK(CalledOnValidThread());
     return qtype_;
   }
 
   virtual int Start() OVERRIDE {
     DCHECK(!callback_.is_null());
     DCHECK(attempts_.empty());
-    net_log_.BeginEvent(NetLog::TYPE_DNS_TRANSACTION, make_scoped_refptr(
-        new StartParameters(hostname_, qtype_)));
+    net_log_.BeginEvent(NetLog::TYPE_DNS_TRANSACTION,
+                        base::Bind(&NetLogStartCallback, &hostname_, qtype_));
     int rv = PrepareSearch();
     if (rv == OK) {
       AttemptResult result = FinishAttempt(StartQuery());
       if (result.rv == OK) {
         // DnsTransaction must never succeed synchronously.
         MessageLoop::current()->PostTask(
             FROM_HERE,
             base::Bind(&DnsTransactionImpl::DoCallback, AsWeakPtr(), result));
         return ERR_IO_PENDING;
       }
@@ skipping 102 matching lines @@
             net_log_.source()));
 
     uint16 id = session_->NextQueryId();
     scoped_ptr<DnsQuery> query;
     if (attempts_.empty()) {
       query.reset(new DnsQuery(id, qnames_.front(), qtype_));
     } else {
       query.reset(attempts_[0]->query()->CloneWithNewId(id));
     }
 
-    net_log_.AddEvent(NetLog::TYPE_DNS_TRANSACTION_ATTEMPT, make_scoped_refptr(
-        new NetLogSourceParameter("source_dependency",
-                                  socket->NetLog().source())));
+    net_log_.AddEvent(NetLog::TYPE_DNS_TRANSACTION_ATTEMPT,
+                      socket->NetLog().source().ToEventParametersCallback());
 
     const DnsConfig& config = session_->config();
 
     unsigned server_index = first_server_index_ +
         (attempt_number % config.nameservers.size());
 
     DnsUDPAttempt* attempt = new DnsUDPAttempt(
         socket.Pass(),
         config.nameservers[server_index],
         query.Pass(),
         base::Bind(&DnsTransactionImpl::OnAttemptComplete,
                    base::Unretained(this),
                    attempt_number));
 
     attempts_.push_back(attempt);
 
     int rv = attempt->Start();
     if (rv == ERR_IO_PENDING) {
       timer_.Stop();
       base::TimeDelta timeout = session_->NextTimeout(attempt_number);
       timer_.Start(FROM_HERE, timeout, this, &DnsTransactionImpl::OnTimeout);
     }
     return AttemptResult(rv, attempt);
   }
 
   // Begins query for the current name. Makes the first attempt.
   AttemptResult StartQuery() {
     std::string dotted_qname = DNSDomainToString(qnames_.front());
-    net_log_.BeginEvent(
-        NetLog::TYPE_DNS_TRANSACTION_QUERY,
-        make_scoped_refptr(new NetLogStringParameter("qname", dotted_qname)));
+    net_log_.BeginEvent(NetLog::TYPE_DNS_TRANSACTION_QUERY,
+                        NetLog::StringCallback("qname", &dotted_qname));
 
     first_server_index_ = session_->NextFirstServerIndex();
 
     attempts_.reset();
     return MakeAttempt();
   }
 
   void OnAttemptComplete(unsigned attempt_number, int rv) {
     if (callback_.is_null())
       return;
     DCHECK_LT(attempt_number, attempts_.size());
     const DnsUDPAttempt* attempt = attempts_[attempt_number];
     AttemptResult result = FinishAttempt(AttemptResult(rv, attempt));
     if (result.rv != ERR_IO_PENDING)
       DoCallback(result);
   }
 
   void LogResponse(const DnsUDPAttempt* attempt) {
     if (attempt && attempt->response()) {
       net_log_.AddEvent(
           NetLog::TYPE_DNS_TRANSACTION_RESPONSE,
-          make_scoped_refptr(
-              new ResponseParameters(attempt->response()->rcode(),
-                                     attempt->response()->answer_count(),
-                                     attempt->socket()->NetLog().source())));
+          base::Bind(&DnsUDPAttempt::NetLogResponseCallback,
+                     base::Unretained(attempt)));
     }
   }
 
   bool MoreAttemptsAllowed() const {
     const DnsConfig& config = session_->config();
     return attempts_.size() < config.attempts * config.nameservers.size();
   }
 
   // Resolves the result of a DnsUDPAttempt until a terminal result is reached
   // or it will complete asynchronously (ERR_IO_PENDING).
@@ skipping 105 matching lines @@
 
 // static
 scoped_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
     DnsSession* session) {
   return scoped_ptr<DnsTransactionFactory>(
       new DnsTransactionFactoryImpl(session));
 }
 
 }  // namespace net