Rewrite scoped_ptr<T>(NULL) to use the default ctor in chrome/.

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 <vector>
 
 #include "base/bind.h"
 #include "base/containers/hash_tables.h"
@@ skipping 270 matching lines @@
   } else if (socket->GetSocketType() == Socket::TYPE_TCP) {
     error_ = kTCPSocketBindError;
     SetResult(Value::CreateIntegerValue(result));
     return;
   }
 
   result = socket->Bind(address_, port_);
   SetResult(Value::CreateIntegerValue(result));
 }
 
-SocketListenFunction::SocketListenFunction()
-    : params_(NULL) {
-}
+SocketListenFunction::SocketListenFunction() {}
 
 SocketListenFunction::~SocketListenFunction() {}
 
 bool SocketListenFunction::Prepare() {
   params_ = api::socket::Listen::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketListenFunction::Work() {
@@ skipping 17 matching lines @@
         params_->port,
         params_->backlog.get() ? *params_->backlog.get() : 5,
         &error_);
   } else {
     error_ = kSocketNotFoundError;
   }
 
   SetResult(Value::CreateIntegerValue(result));
 }
 
-SocketAcceptFunction::SocketAcceptFunction()
-  : params_(NULL) {
-}
+SocketAcceptFunction::SocketAcceptFunction() {}
 
 SocketAcceptFunction::~SocketAcceptFunction() {}
 
 bool SocketAcceptFunction::Prepare() {
   params_ = api::socket::Accept::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketAcceptFunction::AsyncWorkStart() {
@@ skipping 12 matching lines @@
   result->SetInteger(kResultCodeKey, result_code);
   if (socket) {
     Socket *client_socket = new TCPSocket(socket, extension_id(), true);
     result->SetInteger(kSocketIdKey, manager_->Add(client_socket));
   }
   SetResult(result);
 
   AsyncWorkCompleted();
 }
 
-SocketReadFunction::SocketReadFunction()
-    : params_(NULL) {
-}
+SocketReadFunction::SocketReadFunction() {}
 
 SocketReadFunction::~SocketReadFunction() {}
 
 bool SocketReadFunction::Prepare() {
   params_ = api::socket::Read::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketReadFunction::AsyncWorkStart() {
@@ skipping 56 matching lines @@
 }
 
 void SocketWriteFunction::OnCompleted(int bytes_written) {
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
   SetResult(result);
 
   AsyncWorkCompleted();
 }
 
-SocketRecvFromFunction::SocketRecvFromFunction()
-    : params_(NULL) {
-}
+SocketRecvFromFunction::SocketRecvFromFunction() {}
 
 SocketRecvFromFunction::~SocketRecvFromFunction() {}
 
 bool SocketRecvFromFunction::Prepare() {
   params_ = api::socket::RecvFrom::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketRecvFromFunction::AsyncWorkStart() {
@@ skipping 91 matching lines @@
 }
 
 void SocketSendToFunction::OnCompleted(int bytes_written) {
   DictionaryValue* result = new DictionaryValue();
   result->SetInteger(kBytesWrittenKey, bytes_written);
   SetResult(result);
 
   AsyncWorkCompleted();
 }
 
-SocketSetKeepAliveFunction::SocketSetKeepAliveFunction()
-    : params_(NULL) {
-}
+SocketSetKeepAliveFunction::SocketSetKeepAliveFunction() {}
 
 SocketSetKeepAliveFunction::~SocketSetKeepAliveFunction() {}
 
 bool SocketSetKeepAliveFunction::Prepare() {
   params_ = api::socket::SetKeepAlive::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketSetKeepAliveFunction::Work() {
   bool result = false;
   Socket* socket = GetSocket(params_->socket_id);
   if (socket) {
     int delay = 0;
     if (params_->delay.get())
       delay = *params_->delay;
     result = socket->SetKeepAlive(params_->enable, delay);
   } else {
     error_ = kSocketNotFoundError;
   }
   SetResult(Value::CreateBooleanValue(result));
 }
 
-SocketSetNoDelayFunction::SocketSetNoDelayFunction()
-    : params_(NULL) {
-}
+SocketSetNoDelayFunction::SocketSetNoDelayFunction() {}
 
 SocketSetNoDelayFunction::~SocketSetNoDelayFunction() {}
 
 bool SocketSetNoDelayFunction::Prepare() {
   params_ = api::socket::SetNoDelay::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketSetNoDelayFunction::Work() {
   bool result = false;
   Socket* socket = GetSocket(params_->socket_id);
   if (socket)
     result = socket->SetNoDelay(params_->no_delay);
   else
     error_ = kSocketNotFoundError;
   SetResult(Value::CreateBooleanValue(result));
 }
 
-SocketGetInfoFunction::SocketGetInfoFunction()
-    : params_(NULL) {}
+SocketGetInfoFunction::SocketGetInfoFunction() {}
 
 SocketGetInfoFunction::~SocketGetInfoFunction() {}
 
 bool SocketGetInfoFunction::Prepare() {
   params_ = api::socket::GetInfo::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketGetInfoFunction::Work() {
@@ skipping 73 matching lines @@
         make_linked_ptr(new api::socket::NetworkInterface);
     info->name = i->name;
     info->address = net::IPAddressToString(i->address);
     create_arg.push_back(info);
   }
 
   results_ = api::socket::GetNetworkList::Results::Create(create_arg);
   SendResponse(true);
 }
 
-SocketJoinGroupFunction::SocketJoinGroupFunction()
-    : params_(NULL) {}
+SocketJoinGroupFunction::SocketJoinGroupFunction() {}
 
 SocketJoinGroupFunction::~SocketJoinGroupFunction() {}
 
 bool SocketJoinGroupFunction::Prepare() {
   params_ = api::socket::JoinGroup::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketJoinGroupFunction::Work() {
@@ skipping 23 matching lines @@
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)->JoinGroup(params_->address);
   if (result != 0) {
     error_ = net::ErrorToString(result);
   }
   SetResult(Value::CreateIntegerValue(result));
 }
 
-
-SocketLeaveGroupFunction::SocketLeaveGroupFunction()
-  : params_(NULL) {}
+SocketLeaveGroupFunction::SocketLeaveGroupFunction() {}
 
 SocketLeaveGroupFunction::~SocketLeaveGroupFunction() {}
 
 bool SocketLeaveGroupFunction::Prepare() {
   params_ = api::socket::LeaveGroup::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketLeaveGroupFunction::Work() {
@@ skipping 23 matching lines @@
     SetResult(Value::CreateIntegerValue(result));
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)->LeaveGroup(params_->address);
   if (result != 0)
     error_ = net::ErrorToString(result);
   SetResult(Value::CreateIntegerValue(result));
 }
 
-SocketSetMulticastTimeToLiveFunction::SocketSetMulticastTimeToLiveFunction()
-  : params_(NULL) {}
+SocketSetMulticastTimeToLiveFunction::SocketSetMulticastTimeToLiveFunction() {}
 
 SocketSetMulticastTimeToLiveFunction::~SocketSetMulticastTimeToLiveFunction() {}
 
 bool SocketSetMulticastTimeToLiveFunction::Prepare() {
   params_ = api::socket::SetMulticastTimeToLive::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 void SocketSetMulticastTimeToLiveFunction::Work() {
   int result = -1;
@@ skipping 10 matching lines @@
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)->SetMulticastTimeToLive(
       params_->ttl);
   if (result != 0)
     error_ = net::ErrorToString(result);
   SetResult(Value::CreateIntegerValue(result));
 }
 
-SocketSetMulticastLoopbackModeFunction::SocketSetMulticastLoopbackModeFunction()
-  : params_(NULL) {}
+SocketSetMulticastLoopbackModeFunction::
+    SocketSetMulticastLoopbackModeFunction() {}
 
 SocketSetMulticastLoopbackModeFunction::
   ~SocketSetMulticastLoopbackModeFunction() {}
 
 bool SocketSetMulticastLoopbackModeFunction::Prepare() {
   params_ = api::socket::SetMulticastLoopbackMode::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
@@ skipping 12 matching lines @@
     return;
   }
 
   result = static_cast<UDPSocket*>(socket)->
       SetMulticastLoopbackMode(params_->enabled);
   if (result != 0)
     error_ = net::ErrorToString(result);
   SetResult(Value::CreateIntegerValue(result));
 }
 
-SocketGetJoinedGroupsFunction::SocketGetJoinedGroupsFunction()
-  : params_(NULL) {}
+SocketGetJoinedGroupsFunction::SocketGetJoinedGroupsFunction() {}
 
 SocketGetJoinedGroupsFunction::~SocketGetJoinedGroupsFunction() {}
 
 bool SocketGetJoinedGroupsFunction::Prepare() {
   params_ = api::socket::GetJoinedGroups::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void SocketGetJoinedGroupsFunction::Work() {
@@ skipping 24 matching lines @@
     return;
   }
 
   base::ListValue* values = new base::ListValue();
   values->AppendStrings((std::vector<std::string>&)
       static_cast<UDPSocket*>(socket)->GetJoinedGroups());
   SetResult(values);
 }
 
 }  // namespace extensions