unittests for Chromoting native messaging host.

remoting/host/setup/native_messaging_reader.cc

 // Copyright 2013 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/host/setup/native_messaging_reader.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/json/json_reader.h"
@@ skipping 55 matching lines @@
     base::PlatformFile handle,
     scoped_refptr<base::SingleThreadTaskRunner> caller_task_runner,
     scoped_refptr<base::SequencedTaskRunner> read_task_runner,
     base::WeakPtr<NativeMessagingReader> reader)
     : read_stream_(handle, base::PLATFORM_FILE_READ, NULL),
       reader_(reader),
       caller_task_runner_(caller_task_runner),
       read_task_runner_(read_task_runner) {
 }
 
-NativeMessagingReader::Core::~Core() {
-}
+NativeMessagingReader::Core::~Core() {}
 
 void NativeMessagingReader::Core::ReadMessage() {
   DCHECK(read_task_runner_->RunsTasksOnCurrentThread());
 
   // Keep reading messages until the stream is closed or an error occurs.
   while (true) {
     MessageLengthType message_length;
     int read_result = read_stream_.ReadUntilComplete(
         reinterpret_cast<char*>(&message_length), kMessageHeaderSize);
     if (read_result != kMessageHeaderSize) {
-      LOG(ERROR) << "Failed to read message header, read returned "
-                 << read_result;
+      // 0 means EOF which is normal and should not be logged as an error.
+      if (read_result != 0) {
+        LOG(ERROR) << "Failed to read message header, read returned "
+                   << read_result;
+      }
       NotifyEof();
       return;
     }
 
     if (message_length > kMaximumMessageSize) {
       LOG(ERROR) << "Message size too large: " << message_length;
       NotifyEof();
       return;
     }
 
     std::string message_json(message_length, '\0');
-    read_result = read_stream_.ReadUntilComplete(
-        string_as_array(&message_json), message_length);
+    read_result = read_stream_.ReadUntilComplete(string_as_array(&message_json),
+                                                 message_length);
     if (read_result != static_cast<int>(message_length)) {
       LOG(ERROR) << "Failed to read message body, read returned "
                  << read_result;
       NotifyEof();
       return;
     }
 
     scoped_ptr<base::Value> message(base::JSONReader::Read(message_json));
     if (!message) {
       LOG(ERROR) << "Failed to parse JSON message: " << message;
       NotifyEof();
       return;
     }
 
     // Notify callback of new message.
-    caller_task_runner_->PostTask(FROM_HERE, base::Bind(
-        &NativeMessagingReader::InvokeMessageCallback, reader_,
-        base::Passed(&message)));
+    caller_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&NativeMessagingReader::InvokeMessageCallback,
+                              reader_, base::Passed(&message)));
   }
 }
 
 void NativeMessagingReader::Core::NotifyEof() {
   DCHECK(read_task_runner_->RunsTasksOnCurrentThread());
-  caller_task_runner_->PostTask(FROM_HERE, base::Bind(
-      &NativeMessagingReader::InvokeEofCallback, reader_));
+  caller_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&NativeMessagingReader::InvokeEofCallback, reader_));
 }
 
 NativeMessagingReader::NativeMessagingReader(base::PlatformFile handle)
     : reader_thread_("Reader"),
       weak_factory_(this) {
   reader_thread_.Start();
   read_task_runner_ = reader_thread_.message_loop_proxy();
   core_.reset(new Core(handle, base::ThreadTaskRunnerHandle::Get(),
                        read_task_runner_, weak_factory_.GetWeakPtr()));
 }
 
 NativeMessagingReader::~NativeMessagingReader() {
   read_task_runner_->DeleteSoon(FROM_HERE, core_.release());
 }
 
 void NativeMessagingReader::Start(MessageCallback message_callback,
                                   base::Closure eof_callback) {
   message_callback_ = message_callback;
   eof_callback_ = eof_callback;
 
   // base::Unretained is safe since |core_| is only deleted via the
   // DeleteSoon task which is posted from this class's dtor.
-  read_task_runner_->PostTask(FROM_HERE, base::Bind(
-      &NativeMessagingReader::Core::ReadMessage,
-      base::Unretained(core_.get())));
+  read_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&NativeMessagingReader::Core::ReadMessage,
+                            base::Unretained(core_.get())));
 }
 
 void NativeMessagingReader::InvokeMessageCallback(
     scoped_ptr<base::Value> message) {
   message_callback_.Run(message.Pass());
 }
 
 void NativeMessagingReader::InvokeEofCallback() {
   eof_callback_.Run();
 }
 
 }  // namespace remoting