Use std::default_delete as the default deleter for scoped_ptr.

content/browser/renderer_host/p2p/socket_host.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 "content/browser/renderer_host/p2p/socket_host.h"
 
 #include "base/metrics/histogram.h"
 #include "base/sys_byteorder.h"
 #include "content/browser/renderer_host/p2p/socket_host_tcp.h"
 #include "content/browser/renderer_host/p2p/socket_host_tcp_server.h"
@@ skipping 620 matching lines @@
   if (!valid) {
     DCHECK(false);
     return;
   }
 
   scoped_ptr<uint8[]> header_buffer(new uint8[header_length]);
   memcpy(header_buffer.get(), packet, header_length);
 
   // Posts to the IO thread as the data members should be accessed on the IO
   // thread only.
-  BrowserThread::PostTask(BrowserThread::IO,
-                          FROM_HERE,
-                          base::Bind(&P2PSocketHost::DumpRtpPacketOnIOThread,
-                                     weak_ptr_factory_.GetWeakPtr(),
-                                     Passed(&header_buffer),
-                                     header_length,
-                                     rtp_packet_length,
-                                     incoming));
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&P2PSocketHost::DumpRtpPacketOnIOThread,
+                 weak_ptr_factory_.GetWeakPtr(), base::Passed(&header_buffer),
+                 header_length, rtp_packet_length, incoming));
 }
 
 void P2PSocketHost::DumpRtpPacketOnIOThread(scoped_ptr<uint8[]> packet_header,
                                             size_t header_length,
                                             size_t packet_length,
                                             bool incoming) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
   if ((incoming && !dump_incoming_rtp_packet_) ||
       (!incoming && !dump_outgoing_rtp_packet_) ||
       packet_dump_callback_.is_null()) {
     return;
   }
 
   // |packet_dump_callback_| must be called on the UI thread.
-  BrowserThread::PostTask(BrowserThread::UI,
-                          FROM_HERE,
-                          base::Bind(packet_dump_callback_,
-                                     Passed(&packet_header),
-                                     header_length,
-                                     packet_length,
-                                     incoming));
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(packet_dump_callback_, base::Passed(&packet_header),
+                 header_length, packet_length, incoming));
 }
 
 void P2PSocketHost::IncrementDelayedPackets() {
   send_packets_delayed_total_++;
 }
 
 void P2PSocketHost::IncrementTotalSentPackets() {
   send_packets_total_++;
 }
 
 void P2PSocketHost::IncrementDelayedBytes(uint32 size) {
   send_bytes_delayed_cur_ += size;
   if (send_bytes_delayed_cur_ > send_bytes_delayed_max_) {
     send_bytes_delayed_max_ = send_bytes_delayed_cur_;
   }
 }
 
 void P2PSocketHost::DecrementDelayedBytes(uint32 size) {
   send_bytes_delayed_cur_ -= size;
   DCHECK_GE(send_bytes_delayed_cur_, 0);
 }
 
 }  // namespace content