cast channel error cleanup

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 154 matching lines @@
     OnMessage::Create(channel_info, message_info);
   VLOG(1) << "Sending message " << ParamToString(message_info)
           << " to channel " << ParamToString(channel_info);
   scoped_ptr<Event> event(new Event(OnMessage::kEventName, results.Pass()));
   extensions::EventRouter::Get(browser_context_)
       ->DispatchEventToExtension(socket->owner_extension_id(), event.Pass());
 }
 
 CastChannelAPI::~CastChannelAPI() {}
 
-CastChannelAsyncApiFunction::CastChannelAsyncApiFunction()
-  : manager_(NULL), error_(cast_channel::CHANNEL_ERROR_NONE) { }
+CastChannelAsyncApiFunction::CastChannelAsyncApiFunction() : manager_(NULL) {
+}
 
 CastChannelAsyncApiFunction::~CastChannelAsyncApiFunction() { }
 
 bool CastChannelAsyncApiFunction::PrePrepare() {
   manager_ = ApiResourceManager<CastSocket>::Get(browser_context());
   return true;
 }
 
 bool CastChannelAsyncApiFunction::Respond() {
-  return error_ == cast_channel::CHANNEL_ERROR_NONE;
+  return GetError().empty();
 }
 
 CastSocket* CastChannelAsyncApiFunction::GetSocketOrCompleteWithError(
     int channel_id) {
   CastSocket* socket = GetSocket(channel_id);
   if (!socket) {
     SetResultFromError(channel_id,
                        cast_channel::CHANNEL_ERROR_INVALID_CHANNEL_ID);
     AsyncWorkCompleted();
   }
@@ skipping 12 matching lines @@
 void CastChannelAsyncApiFunction::RemoveSocket(int channel_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(manager_);
   manager_->Remove(extension_->id(), channel_id);
 }
 
 void CastChannelAsyncApiFunction::SetResultFromSocket(
     const CastSocket& socket) {
   ChannelInfo channel_info;
   FillChannelInfo(socket, &channel_info);
-  error_ = socket.error_state();
+  ChannelError error = socket.error_state();
+  if (error != cast_channel::CHANNEL_ERROR_NONE) {
+    SetError("Channel socket error = " + base::IntToString(error));
+  }
   SetResultFromChannelInfo(channel_info);
 }
 
 void CastChannelAsyncApiFunction::SetResultFromError(int channel_id,
                                                      ChannelError error) {
   ChannelInfo channel_info;
   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;
+  SetError("Channel error = " + base::IntToString(error));
 }
 
 CastSocket* CastChannelAsyncApiFunction::GetSocket(int channel_id) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DCHECK(manager_);
   return manager_->Get(extension_->id(), channel_id);
 }
 
 void CastChannelAsyncApiFunction::SetResultFromChannelInfo(
     const ChannelInfo& channel_info) {
@@ skipping 283 matching lines @@
   std::string& signature = params_->signature;
   if (signature.empty() || keys.empty() ||
       !cast_channel::SetTrustedCertificateAuthorities(keys, signature)) {
     SetError("Unable to set authority keys.");
   }
 
   AsyncWorkCompleted();
 }
 
 }  // namespace extensions