Remove weak pointers from CastSocket.

extensions/browser/api/cast_channel/cast_channel_api.cc

 // Copyright 2014 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 "extensions/browser/api/cast_channel/cast_channel_api.h"
 
 #include <limits>
 #include <string>
 
 #include "base/json/json_writer.h"
@@ skipping 47 matching lines @@
   const net::IPEndPoint& ip_endpoint = socket.ip_endpoint();
   channel_info->connect_info.ip_address = ip_endpoint.ToStringWithoutPort();
   channel_info->connect_info.port = ip_endpoint.port();
   channel_info->connect_info.auth = socket.channel_auth();
   channel_info->ready_state = socket.ready_state();
   channel_info->error_state = socket.error_state();
 }
 
 bool IsValidConnectInfoPort(const ConnectInfo& connect_info) {
   return connect_info.port > 0 && connect_info.port <
-    std::numeric_limits<unsigned short>::max();
+    std::numeric_limits<uint16_t>::max();
 }
 
 bool IsValidConnectInfoAuth(const ConnectInfo& connect_info) {
   return connect_info.auth == cast_channel::CHANNEL_AUTH_TYPE_SSL_VERIFIED ||
     connect_info.auth == cast_channel::CHANNEL_AUTH_TYPE_SSL;
 }
 
 bool IsValidConnectInfoIpAddress(const ConnectInfo& connect_info) {
   net::IPAddressNumber ip_address;
   return net::ParseIPLiteralToNumber(connect_info.ip_address, &ip_address);
@@ skipping 76 matching lines @@
 }
 
 bool CastChannelAsyncApiFunction::Respond() {
   return error_ != cast_channel::CHANNEL_ERROR_NONE;
 }
 
 CastSocket* CastChannelAsyncApiFunction::GetSocketOrCompleteWithError(
     int channel_id) {
   CastSocket* socket = GetSocket(channel_id);
   if (!socket) {
-    SetResultFromError(cast_channel::CHANNEL_ERROR_INVALID_CHANNEL_ID);
+    SetResultFromError(channel_id,
+                       cast_channel::CHANNEL_ERROR_INVALID_CHANNEL_ID);
     AsyncWorkCompleted();
   }
   return socket;
 }
 
 int CastChannelAsyncApiFunction::AddSocket(CastSocket* socket) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(socket);
   DCHECK(manager_);
   const int id = manager_->Add(socket);
   socket->set_id(id);
   return id;
 }
 
 void CastChannelAsyncApiFunction::RemoveSocket(int channel_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(manager_);
   manager_->Remove(extension_->id(), channel_id);
 }
 
-void CastChannelAsyncApiFunction::SetResultFromSocket(int channel_id) {
-  CastSocket* socket = GetSocket(channel_id);
-  DCHECK(socket);
+void CastChannelAsyncApiFunction::SetResultFromSocket(
+    const CastSocket& socket) {
   ChannelInfo channel_info;
-  FillChannelInfo(*socket, &channel_info);
-  error_ = socket->error_state();
+  FillChannelInfo(socket, &channel_info);
+  error_ = socket.error_state();
   SetResultFromChannelInfo(channel_info);
 }
 
-void CastChannelAsyncApiFunction::SetResultFromError(ChannelError error) {
+void CastChannelAsyncApiFunction::SetResultFromError(int channel_id,
+                                                     ChannelError error) {
   ChannelInfo channel_info;
-  channel_info.channel_id = -1;
+  channel_info.channel_id = channel_id;
   channel_info.url = "";
   channel_info.ready_state = cast_channel::READY_STATE_CLOSED;
   channel_info.error_state = error;
+  channel_info.connect_info.ip_address = "";
+  channel_info.connect_info.port = 0;
+  channel_info.connect_info.auth = cast_channel::CHANNEL_AUTH_TYPE_SSL;
   SetResultFromChannelInfo(channel_info);
   error_ = error;
 }
 
 CastSocket* CastChannelAsyncApiFunction::GetSocket(int channel_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(manager_);
   return manager_->Get(extension_->id(), channel_id);
 }
 
@@ skipping 120 matching lines @@
                                             ? *connect_info_->timeout
                                             : kDefaultConnectTimeoutMillis));
   new_channel_id_ = AddSocket(socket.release());
   GetSocket(new_channel_id_)->Connect(
       base::Bind(&CastChannelOpenFunction::OnOpen, this));
 }
 
 void CastChannelOpenFunction::OnOpen(int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(1) << "Connect finished, OnOpen invoked.";
-  SetResultFromSocket(new_channel_id_);
+  CastSocket* socket = GetSocket(new_channel_id_);
+  if (!socket) {
+    SetResultFromError(new_channel_id_,
+                       cast_channel::CHANNEL_ERROR_CONNECT_ERROR);
+  } else {
+    SetResultFromSocket(*socket);
+  }
   AsyncWorkCompleted();
 }
 
 CastChannelSendFunction::CastChannelSendFunction() { }
 
 CastChannelSendFunction::~CastChannelSendFunction() { }
 
 bool CastChannelSendFunction::Prepare() {
   params_ = Send::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
@@ skipping 23 matching lines @@
 void CastChannelSendFunction::AsyncWorkStart() {
   CastSocket* socket = GetSocketOrCompleteWithError(
       params_->channel.channel_id);
   if (socket)
     socket->SendMessage(params_->message,
                         base::Bind(&CastChannelSendFunction::OnSend, this));
 }
 
 void CastChannelSendFunction::OnSend(int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  if (result < 0) {
-    SetResultFromError(cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
+  int channel_id = params_->channel.channel_id;
+  CastSocket* socket = GetSocket(channel_id);
+  if (result < 0 || !socket) {
+    SetResultFromError(channel_id,
+                       cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
   } else {
-    SetResultFromSocket(params_->channel.channel_id);
+    SetResultFromSocket(*socket);
   }
   AsyncWorkCompleted();
 }
 
 CastChannelCloseFunction::CastChannelCloseFunction() { }
 
 CastChannelCloseFunction::~CastChannelCloseFunction() { }
 
 bool CastChannelCloseFunction::Prepare() {
   params_ = Close::Params::Create(*args_);
   EXTENSION_FUNCTION_VALIDATE(params_.get());
   return true;
 }
 
 void CastChannelCloseFunction::AsyncWorkStart() {
   CastSocket* socket = GetSocketOrCompleteWithError(
       params_->channel.channel_id);
   if (socket)
     socket->Close(base::Bind(&CastChannelCloseFunction::OnClose, this));
 }
 
 void CastChannelCloseFunction::OnClose(int result) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   VLOG(1) << "CastChannelCloseFunction::OnClose result = " << result;
-  if (result < 0) {
-    SetResultFromError(cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
+  int channel_id = params_->channel.channel_id;
+  CastSocket* socket = GetSocket(channel_id);
+  if (result < 0 || !socket) {
+    SetResultFromError(channel_id,
+                       cast_channel::CHANNEL_ERROR_SOCKET_ERROR);
   } else {
-    int channel_id = params_->channel.channel_id;
-    SetResultFromSocket(channel_id);
+    SetResultFromSocket(*socket);
+    // This will delete |socket|.
     RemoveSocket(channel_id);
+    socket = NULL;
   }
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions