Fix MessageReader to pass errors to the channel

remoting/protocol/message_reader.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/message_reader.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/location.h"
@@ skipping 20 matching lines @@
 
 MessageReader::~MessageReader() {
 }
 
 void MessageReader::SetMessageReceivedCallback(
     const MessageReceivedCallback& callback) {
   DCHECK(CalledOnValidThread());
   message_received_callback_ = callback;
 }
 
-void MessageReader::StartReading(net::Socket* socket) {
+void MessageReader::StartReading(
+    net::Socket* socket,
+    const ReadFailedCallback& read_failed_callback) {
   DCHECK(CalledOnValidThread());
   DCHECK(socket);
+  DCHECK(!read_failed_callback.is_null());
+
   socket_ = socket;
+  read_failed_callback_ = read_failed_callback;
   DoRead();
 }
 
 void MessageReader::DoRead() {
   DCHECK(CalledOnValidThread());
   // Don't try to read again if there is another read pending or we
   // have messages that we haven't finished processing yet.
-  while (!closed_ && !read_pending_ && pending_messages_ == 0) {
+  bool read_succeeded = true;
+  while (read_succeeded && !closed_ && !read_pending_ &&
+         pending_messages_ == 0) {
     read_buffer_ = new net::IOBuffer(kReadBufferSize);
     int result = socket_->Read(
         read_buffer_.get(),
         kReadBufferSize,
         base::Bind(&MessageReader::OnRead, weak_factory_.GetWeakPtr()));
-    HandleReadResult(result);
+
+    HandleReadResult(result, &read_succeeded);
   }
 }
 
 void MessageReader::OnRead(int result) {
   DCHECK(CalledOnValidThread());
   DCHECK(read_pending_);
   read_pending_ = false;
 
   if (!closed_) {
-    HandleReadResult(result);
-    DoRead();
+    bool read_succeeded;
+    HandleReadResult(result, &read_succeeded);
+    if (read_succeeded)
+      DoRead();
   }
 }
 
-void MessageReader::HandleReadResult(int result) {
+void MessageReader::HandleReadResult(int result, bool* read_succeeded) {
   DCHECK(CalledOnValidThread());
   if (closed_)
     return;
 
+  *read_succeeded = true;
+
   if (result > 0) {
     OnDataReceived(read_buffer_.get(), result);
+    *read_succeeded = true;
   } else if (result == net::ERR_IO_PENDING) {
     read_pending_ = true;
   } else {
-    if (result != net::ERR_CONNECTION_CLOSED) {
-      LOG(ERROR) << "Read() returned error " << result;
-    }
+    DCHECK_LT(result, 0);
+
     // Stop reading after any error.
     closed_ = true;
+    *read_succeeded = false;
+
+    LOG(ERROR) << "Read() returned error " << result;
+    read_failed_callback_.Run(result);
   }
 }
 
 void MessageReader::OnDataReceived(net::IOBuffer* data, int data_size) {
   DCHECK(CalledOnValidThread());
   message_decoder_.AddData(data, data_size);
 
   // Get list of all new messages first, and then call the callback
   // for all of them.
   while (true) {
@@ skipping 21 matching lines @@
   DCHECK(CalledOnValidThread());
   pending_messages_--;
   DCHECK_GE(pending_messages_, 0);
 
   // Start next read if necessary.
   DoRead();
 }
 
 }  // namespace protocol
 }  // namespace remoting