Fix BufferedSocketWriter not to return any results from Write().

remoting/protocol/channel_multiplexer.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 "remoting/protocol/channel_multiplexer.h"
 
 #include <string.h>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 66 matching lines @@
   void set_receive_id(int id) { receive_id_ = id; }
 
   // Called by ChannelMultiplexer.
   scoped_ptr<P2PStreamSocket> CreateSocket();
   void OnIncomingPacket(scoped_ptr<MultiplexPacket> packet,
                         const base::Closure& done_task);
   void OnBaseChannelError(int error);
 
   // Called by MuxSocket.
   void OnSocketDestroyed();
-  bool DoWrite(scoped_ptr<MultiplexPacket> packet,
+  void DoWrite(scoped_ptr<MultiplexPacket> packet,
                const base::Closure& done_task);
   int DoRead(const scoped_refptr<net::IOBuffer>& buffer, int buffer_len);
 
  private:
   ChannelMultiplexer* multiplexer_;
   std::string name_;
   int send_id_;
   bool id_sent_;
   int receive_id_;
   MuxSocket* socket_;
@@ skipping 77 matching lines @@
 void ChannelMultiplexer::MuxChannel::OnBaseChannelError(int error) {
   if (socket_)
     socket_->OnBaseChannelError(error);
 }
 
 void ChannelMultiplexer::MuxChannel::OnSocketDestroyed() {
   DCHECK(socket_);
   socket_ = nullptr;
 }
 
-bool ChannelMultiplexer::MuxChannel::DoWrite(
+void ChannelMultiplexer::MuxChannel::DoWrite(
     scoped_ptr<MultiplexPacket> packet,
     const base::Closure& done_task) {
   packet->set_channel_id(send_id_);
   if (!id_sent_) {
     packet->set_channel_name(name_);
     id_sent_ = true;
   }
-  return multiplexer_->DoWrite(packet.Pass(), done_task);
+  multiplexer_->DoWrite(packet.Pass(), done_task);
 }
 
 int ChannelMultiplexer::MuxChannel::DoRead(
     const scoped_refptr<net::IOBuffer>& buffer,
     int buffer_len) {
   int pos = 0;
   while (buffer_len > 0 && !pending_packets_.empty()) {
     DCHECK(!pending_packets_.front()->is_empty());
     int result = pending_packets_.front()->Read(
         buffer->data() + pos, buffer_len);
@@ skipping 45 matching lines @@
   DCHECK(write_callback_.is_null());
 
   if (base_channel_error_ != net::OK)
     return base_channel_error_;
 
   scoped_ptr<MultiplexPacket> packet(new MultiplexPacket());
   size_t size = std::min(kMaxPacketSize, buffer_len);
   packet->mutable_data()->assign(buffer->data(), size);
 
   write_pending_ = true;
-  bool result = channel_->DoWrite(packet.Pass(), base::Bind(
+  channel_->DoWrite(packet.Pass(), base::Bind(
       &ChannelMultiplexer::MuxSocket::OnWriteComplete, AsWeakPtr()));
 
-  if (!result) {
-    // Cannot complete the write, e.g. if the connection has been terminated.
-    return net::ERR_FAILED;
-  }
-
   // OnWriteComplete() might be called above synchronously.
   if (write_pending_) {
     DCHECK(write_callback_.is_null());
     write_callback_ = callback;
     write_result_ = size;
     return net::ERR_IO_PENDING;
   }
 
   return size;
 }
@@ skipping 181 matching lines @@
       return;
     }
     channel = GetOrCreateChannel(packet->channel_name());
     channel->set_receive_id(receive_id);
     channels_by_receive_id_[receive_id] = channel;
   }
 
   channel->OnIncomingPacket(packet.Pass(), done_task);
 }
 
-bool ChannelMultiplexer::DoWrite(scoped_ptr<MultiplexPacket> packet,
+void ChannelMultiplexer::DoWrite(scoped_ptr<MultiplexPacket> packet,
                                  const base::Closure& done_task) {
-  return writer_.Write(SerializeAndFrameMessage(*packet), done_task);
+  writer_.Write(SerializeAndFrameMessage(*packet), done_task);
 }
 
 }  // namespace protocol
 }  // namespace remoting