RefCounted types should not have public destructors, chrome/browser/extensions

chrome/browser/extensions/api/socket/socket_api.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 "chrome/browser/extensions/api/socket/socket_api.h"
 
 #include "base/bind.h"
 #include "chrome/browser/extensions/api/api_resource_controller.h"
 #include "chrome/browser/extensions/api/socket/socket.h"
 #include "chrome/browser/extensions/api/socket/tcp_socket.h"
 #include "chrome/browser/extensions/api/socket/udp_socket.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 
 namespace extensions {
 
 const char kAddressKey[] = "address";
 const char kPortKey[] = "port";
 const char kBytesWrittenKey[] = "bytesWritten";
 const char kDataKey[] = "data";
 const char kResultCodeKey[] = "resultCode";
 const char kSocketIdKey[] = "socketId";
 const char kTCPOption[] = "tcp";
 const char kUDPOption[] = "udp";
 
 const char kSocketNotFoundError[] = "Socket not found";
 
 SocketCreateFunction::SocketCreateFunction()
-    : src_id_(-1), event_notifier_(NULL) {
+    : src_id_(-1),
+      event_notifier_(NULL) {
 }
 
+SocketCreateFunction::~SocketCreateFunction() {}
+
 bool SocketCreateFunction::Prepare() {
   std::string socket_type_string;
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(0, &socket_type_string));
   if (socket_type_string == kTCPOption)
     socket_type_ = kSocketTypeTCP;
   else if (socket_type_string == kUDPOption)
     socket_type_ = kSocketTypeUDP;
   else
     return false;
 
@@ skipping 132 matching lines @@
 
 bool SocketReadFunction::Respond() {
   return true;
 }
 
 SocketWriteFunction::SocketWriteFunction()
     : socket_id_(0),
       io_buffer_(NULL) {
 }
 
-SocketWriteFunction::~SocketWriteFunction() {
-}
+SocketWriteFunction::~SocketWriteFunction() {}
 
 bool SocketWriteFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   base::ListValue* data_list_value = NULL;
   EXTENSION_FUNCTION_VALIDATE(args_->GetList(1, &data_list_value));
 
   size_t size = data_list_value->GetSize();
   if (size != 0) {
     io_buffer_ = new net::IOBufferWithSize(size);
     uint8* data_buffer =
@@ skipping 20 matching lines @@
 
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
   result_.reset(result);
 }
 
 bool SocketWriteFunction::Respond() {
   return true;
 }
 
+SocketRecvFromFunction::~SocketRecvFromFunction() {}
+
 bool SocketRecvFromFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   return true;
 }
 
 void SocketRecvFromFunction::Work() {
   // TODO(miket): this is an arbitrary number. Can we come up with one that
   // makes sense?
   const int buffer_len = 2048;
   scoped_refptr<net::IOBuffer> io_buffer(new net::IOBuffer(buffer_len));
@@ skipping 29 matching lines @@
 
 bool SocketRecvFromFunction::Respond() {
   return true;
 }
 
 SocketSendToFunction::SocketSendToFunction()
     : socket_id_(0),
       io_buffer_(NULL) {
 }
 
-SocketSendToFunction::~SocketSendToFunction() {
-}
+SocketSendToFunction::~SocketSendToFunction() {}
 
 bool SocketSendToFunction::Prepare() {
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(0, &socket_id_));
   base::ListValue *data_list_value;
   EXTENSION_FUNCTION_VALIDATE(args_->GetList(1, &data_list_value));
   EXTENSION_FUNCTION_VALIDATE(args_->GetString(2, &address_));
   EXTENSION_FUNCTION_VALIDATE(args_->GetInteger(3, &port_));
 
   size_t size = data_list_value->GetSize();
   if (size != 0) {
@@ skipping 25 matching lines @@
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
   result_.reset(result);
 }
 
 bool SocketSendToFunction::Respond() {
   return true;
 }
 
 }  // namespace extensions