Updated NetLog::ParametersCallback & all related calbacks returning value as scoped_ptr<base::Value…

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 40 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);
 }
 
-base::Value* NetLogStartCallback(const std::string* hostname,
-                                 uint16 qtype,
-                                 NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+scoped_ptr<base::Value> NetLogStartCallback(
+    const std::string* hostname,
+    uint16 qtype,
+    NetLogCaptureMode /* capture_mode */) {
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetString("hostname", *hostname);
   dict->SetInteger("query_type", qtype);
-  return dict;
+  return dict.Pass();
 };
 
 // ----------------------------------------------------------------------------
 
 // A single asynchronous DNS exchange, 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 DnsAttempt {
  public:
   explicit DnsAttempt(unsigned server_index)
@@ skipping 13 matching lines @@
 
   // Returns the net log bound to the source of the socket.
   virtual const BoundNetLog& GetSocketNetLog() const = 0;
 
   // Returns the index of the destination server within DnsConfig::nameservers.
   unsigned server_index() const { return server_index_; }
 
   // 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.
-  base::Value* NetLogResponseCallback(NetLogCaptureMode capture_mode) const {
+  scoped_ptr<base::Value> NetLogResponseCallback(
+      NetLogCaptureMode capture_mode) const {
     DCHECK(GetResponse()->IsValid());
 
-    base::DictionaryValue* dict = new base::DictionaryValue();
+    scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
     dict->SetInteger("rcode", GetResponse()->rcode());
     dict->SetInteger("answer_count", GetResponse()->answer_count());
-    GetSocketNetLog().source().AddToEventParameters(dict);
-    return dict;
+    GetSocketNetLog().source().AddToEventParameters(dict.get());
+    return dict.Pass();
   }
 
   void set_result(int result) {
     result_ = result;
   }
 
   // True if current attempt is pending (waiting for server response).
   bool is_pending() const {
     return result_ == ERR_IO_PENDING;
   }
@@ skipping 466 matching lines @@
 
   uint16 GetType() const override {
     DCHECK(CalledOnValidThread());
     return qtype_;
   }
 
   void Start() override {
     DCHECK(!callback_.is_null());
     DCHECK(attempts_.empty());
     net_log_.BeginEvent(NetLog::TYPE_DNS_TRANSACTION,
-                        base::Bind(&NetLogStartCallback, &hostname_, qtype_));
+                        base::Bind(NetLogStartCallback, &hostname_, qtype_));
     AttemptResult result(PrepareSearch(), NULL);
     if (result.rv == OK) {
       qnames_initial_size_ = qnames_.size();
       if (qtype_ == dns_protocol::kTypeA)
         UMA_HISTOGRAM_COUNTS("AsyncDNS.SuffixSearchStart", qnames_.size());
       result = ProcessAttemptResult(StartQuery());
     }
 
     // Must always return result asynchronously, to avoid reentrancy.
     if (result.rv != ERR_IO_PENDING) {
@@ skipping 382 matching lines @@
 }  // namespace
 
 // static
 scoped_ptr<DnsTransactionFactory> DnsTransactionFactory::CreateFactory(
     DnsSession* session) {
   return scoped_ptr<DnsTransactionFactory>(
       new DnsTransactionFactoryImpl(session));
 }
 
 }  // namespace net