RefCounted types should not have public destructors, content/browser part 1

content/browser/renderer_host/p2p/socket_dispatcher_host.cc

 // Copyright (c) 2011 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_dispatcher_host.h"
 
 #include "base/bind.h"
 #include "base/stl_util.h"
 #include "content/browser/renderer_host/p2p/socket_host.h"
 #include "content/public/browser/resource_context.h"
@@ skipping 88 matching lines @@
 
   DoneCallback done_callback_;
 };
 
 P2PSocketDispatcherHost::P2PSocketDispatcherHost(
     content::ResourceContext* resource_context)
     : resource_context_(resource_context),
       monitoring_networks_(false) {
 }
 
-P2PSocketDispatcherHost::~P2PSocketDispatcherHost() {
-  DCHECK(sockets_.empty());
-  DCHECK(dns_requests_.empty());
-
-  if (monitoring_networks_)
-    net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
-}
-
 void P2PSocketDispatcherHost::OnChannelClosing() {
   BrowserMessageFilter::OnChannelClosing();
 
   // Since the IPC channel is gone, close pending connections.
   STLDeleteContainerPairSecondPointers(sockets_.begin(), sockets_.end());
   sockets_.clear();
 
   STLDeleteContainerPointers(dns_requests_.begin(), dns_requests_.end());
   dns_requests_.clear();
 }
@@ skipping 14 matching lines @@
     IPC_MESSAGE_HANDLER(P2PHostMsg_CreateSocket, OnCreateSocket)
     IPC_MESSAGE_HANDLER(P2PHostMsg_AcceptIncomingTcpConnection,
                         OnAcceptIncomingTcpConnection)
     IPC_MESSAGE_HANDLER(P2PHostMsg_Send, OnSend)
     IPC_MESSAGE_HANDLER(P2PHostMsg_DestroySocket, OnDestroySocket)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP_EX()
   return handled;
 }
 
+void P2PSocketDispatcherHost::OnIPAddressChanged() {
+  // Notify the renderer about changes to list of network interfaces.
+  BrowserThread::PostTask(
+      BrowserThread::FILE, FROM_HERE, base::Bind(
+          &P2PSocketDispatcherHost::DoGetNetworkList, this));
+}
+
+P2PSocketDispatcherHost::~P2PSocketDispatcherHost() {
+  DCHECK(sockets_.empty());
+  DCHECK(dns_requests_.empty());
+
+  if (monitoring_networks_)
+    net::NetworkChangeNotifier::RemoveIPAddressObserver(this);
+}
+
 P2PSocketHost* P2PSocketDispatcherHost::LookupSocket(
     int32 routing_id, int socket_id) {
   SocketsMap::iterator it = sockets_.find(
       ExtendedSocketId(routing_id, socket_id));
   if (it == sockets_.end())
     return NULL;
   else
     return it->second;
 }
 
 void P2PSocketDispatcherHost::OnStartNetworkNotifications(
     const IPC::Message& msg) {
   if (!monitoring_networks_) {
     net::NetworkChangeNotifier::AddIPAddressObserver(this);
     monitoring_networks_ = true;
   }
 
   notifications_routing_ids_.insert(msg.routing_id());
 
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE, base::Bind(
           &P2PSocketDispatcherHost::DoGetNetworkList, this));
 }
 
 void P2PSocketDispatcherHost::OnStopNetworkNotifications(
     const IPC::Message& msg) {
   notifications_routing_ids_.erase(msg.routing_id());
 }
 
-void P2PSocketDispatcherHost::OnIPAddressChanged() {
-  // Notify the renderer about changes to list of network interfaces.
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE, base::Bind(
-          &P2PSocketDispatcherHost::DoGetNetworkList, this));
-}
-
-void P2PSocketDispatcherHost::DoGetNetworkList() {
-  net::NetworkInterfaceList list;
-  net::GetNetworkList(&list);
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE, base::Bind(
-          &P2PSocketDispatcherHost::SendNetworkList, this, list));
-}
-
-void P2PSocketDispatcherHost::SendNetworkList(
-    const net::NetworkInterfaceList& list) {
-  for (std::set<int>::iterator it = notifications_routing_ids_.begin();
-       it != notifications_routing_ids_.end(); ++it) {
-    Send(new P2PMsg_NetworkListChanged(*it, list));
-  }
-}
-
 void P2PSocketDispatcherHost::OnGetHostAddress(const IPC::Message& msg,
                                                const std::string& host_name,
                                                int32 request_id) {
   DnsRequest* request = new DnsRequest(
       msg.routing_id(), request_id, resource_context_->GetHostResolver());
   dns_requests_.insert(request);
   request->Resolve(host_name, base::Bind(
       &P2PSocketDispatcherHost::OnAddressResolved,
       base::Unretained(this), request));
 }
 
-void P2PSocketDispatcherHost::OnAddressResolved(
-    DnsRequest* request,
-    const net::IPAddressNumber& result) {
-  Send(new P2PMsg_GetHostAddressResult(
-      request->routing_id(), request->request_id(), result));
-
-  dns_requests_.erase(request);
-  delete request;
-}
-
 void P2PSocketDispatcherHost::OnCreateSocket(
     const IPC::Message& msg, P2PSocketType type, int socket_id,
     const net::IPEndPoint& local_address,
     const net::IPEndPoint& remote_address) {
   if (LookupSocket(msg.routing_id(), socket_id)) {
     LOG(ERROR) << "Received P2PHostMsg_CreateSocket for socket "
         "that already exists.";
     return;
   }
 
@@ skipping 45 matching lines @@
   SocketsMap::iterator it = sockets_.find(
       ExtendedSocketId(msg.routing_id(), socket_id));
   if (it != sockets_.end()) {
     delete it->second;
     sockets_.erase(it);
   } else {
     LOG(ERROR) << "Received P2PHostMsg_DestroySocket for invalid socket_id.";
   }
 }
 
+void P2PSocketDispatcherHost::DoGetNetworkList() {
+  net::NetworkInterfaceList list;
+  net::GetNetworkList(&list);
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE, base::Bind(
+          &P2PSocketDispatcherHost::SendNetworkList, this, list));
+}
+
+void P2PSocketDispatcherHost::SendNetworkList(
+    const net::NetworkInterfaceList& list) {
+  for (std::set<int>::iterator it = notifications_routing_ids_.begin();
+       it != notifications_routing_ids_.end(); ++it) {
+    Send(new P2PMsg_NetworkListChanged(*it, list));
+  }
+}
+
+void P2PSocketDispatcherHost::OnAddressResolved(
+    DnsRequest* request,
+    const net::IPAddressNumber& result) {
+  Send(new P2PMsg_GetHostAddressResult(
+      request->routing_id(), request->request_id(), result));
+
+  dns_requests_.erase(request);
+  delete request;
+}
+
 }  // namespace content