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

net/http/http_stream_parser.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/http/http_stream_parser.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/metrics/histogram_macros.h"
@@ skipping 56 matching lines @@
   // There's at least one |field_name| header.  Check if there are any more
   // such headers, and if so, return true if they have different values.
   std::string field_value2;
   while (headers.EnumerateHeader(&it, field_name, &field_value2)) {
     if (field_value != field_value2)
       return true;
   }
   return false;
 }
 
-base::Value* NetLogSendRequestBodyCallback(
+scoped_ptr<base::Value> NetLogSendRequestBodyCallback(
     uint64 length,
     bool is_chunked,
     bool did_merge,
     NetLogCaptureMode /* capture_mode */) {
-  base::DictionaryValue* dict = new base::DictionaryValue();
+  scoped_ptr<base::DictionaryValue> dict(new base::DictionaryValue());
   dict->SetInteger("length", static_cast<int>(length));
   dict->SetBoolean("is_chunked", is_chunked);
   dict->SetBoolean("did_merge", did_merge);
-  return dict;
+  return dict.Pass();
 }
 
 // Returns true if |error_code| is an error for which we give the server a
 // chance to send a body containing error information, if the error was received
 // while trying to upload a request body.
 bool ShouldTryReadingOnUploadError(int error_code) {
   return (error_code == ERR_CONNECTION_RESET);
 }
 
 }  // namespace
@@ skipping 190 matching lines @@
           request_headers_.get(), static_cast<int>(todo), CompletionCallback());
       DCHECK_GT(consumed, 0);  // Read() won't fail if not chunked.
       request_headers_->DidConsume(consumed);
       todo -= consumed;
     }
     DCHECK(request_->upload_data_stream->IsEOF());
     // Reset the offset, so the buffer can be read from the beginning.
     request_headers_->SetOffset(0);
     did_merge = true;
 
-    net_log_.AddEvent(
-        NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_BODY,
-        base::Bind(&NetLogSendRequestBodyCallback,
-                   request_->upload_data_stream->size(),
-                   false, /* not chunked */
-                   true /* merged */));
+    net_log_.AddEvent(NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_BODY,
+                      base::Bind(NetLogSendRequestBodyCallback,
+                                 request_->upload_data_stream->size(),
+                                 false, /* not chunked */
+                                 true /* merged */));
   }
 
   if (!did_merge) {
     // If we didn't merge the body with the headers, then |request_headers_|
     // contains just the HTTP headers.
     scoped_refptr<StringIOBuffer> headers_io_buf(new StringIOBuffer(request));
     request_headers_ =
         new DrainableIOBuffer(headers_io_buf.get(), headers_io_buf->size());
   }
 
@@ skipping 161 matching lines @@
   if (request_headers_->BytesRemaining() > 0) {
     io_state_ = STATE_SEND_HEADERS;
     return OK;
   }
 
   if (request_->upload_data_stream != NULL &&
       (request_->upload_data_stream->is_chunked() ||
       // !IsEOF() indicates that the body wasn't merged.
       (request_->upload_data_stream->size() > 0 &&
         !request_->upload_data_stream->IsEOF()))) {
-    net_log_.AddEvent(
-        NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_BODY,
-        base::Bind(&NetLogSendRequestBodyCallback,
-                   request_->upload_data_stream->size(),
-                   request_->upload_data_stream->is_chunked(),
-                   false /* not merged */));
+    net_log_.AddEvent(NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST_BODY,
+                      base::Bind(NetLogSendRequestBodyCallback,
+                                 request_->upload_data_stream->size(),
+                                 request_->upload_data_stream->is_chunked(),
+                                 false /* not merged */));
     io_state_ = STATE_SEND_BODY;
     return OK;
   }
 
   // Finished sending the request.
   return OK;
 }
 
 int HttpStreamParser::DoSendBody() {
   if (request_body_send_buf_->BytesRemaining() > 0) {
@@ skipping 588 matching lines @@
       request_body->IsInMemory() &&
       request_body->size() > 0) {
     uint64 merged_size = request_headers.size() + request_body->size();
     if (merged_size <= kMaxMergedHeaderAndBodySize)
       return true;
   }
   return false;
 }
 
 }  // namespace net