Pass error messages from native messaging to web-app.

remoting/host/it2me/it2me_native_messaging_host_unittest.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/it2me/it2me_native_messaging_host.h"
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
 #include "base/strings/stringize_macros.h"
 #include "base/values.h"
 #include "net/base/file_stream.h"
 #include "net/base/net_util.h"
 #include "remoting/base/auto_thread_task_runner.h"
 #include "remoting/host/chromoting_host_context.h"
+#include "remoting/host/native_messaging/log_message_handler.h"
 #include "remoting/host/native_messaging/native_messaging_pipe.h"
 #include "remoting/host/native_messaging/pipe_messaging_channel.h"
 #include "remoting/host/policy_watcher.h"
 #include "remoting/host/setup/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace remoting {
 
 namespace {
 
@@ skipping 224 matching lines @@
   scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
   EXPECT_FALSE(response);
 
   // The It2MeNativeMessagingHost dtor closes the handles that are passed to it.
   // So the only handle left to close is |output_read_file_|.
   output_read_file_.Close();
 }
 
 scoped_ptr<base::DictionaryValue>
 It2MeNativeMessagingHostTest::ReadMessageFromOutputPipe() {
-  uint32 length;
-  int read_result = output_read_file_.ReadAtCurrentPos(
-      reinterpret_cast<char*>(&length), sizeof(length));
-  if (read_result != sizeof(length)) {
-    // The output pipe has been closed, return an empty message.
-    return nullptr;
+  while (true) {
+    uint32 length;
+    int read_result = output_read_file_.ReadAtCurrentPos(
+        reinterpret_cast<char*>(&length), sizeof(length));
+    if (read_result != sizeof(length)) {
+      // The output pipe has been closed, return an empty message.
+      return nullptr;
+    }
+
+    std::string message_json(length, '\0');
+    read_result = output_read_file_.ReadAtCurrentPos(
+        string_as_array(&message_json), length);
+    if (read_result != static_cast<int>(length)) {
+      LOG(ERROR) << "Message size (" << read_result
+                 << ") doesn't match the header (" << length << ").";
+      return nullptr;
+    }
+
+    scoped_ptr<base::Value> message = base::JSONReader::Read(message_json);
+    if (!message || !message->IsType(base::Value::TYPE_DICTIONARY)) {
+      LOG(ERROR) << "Malformed message:" << message_json;
+      return nullptr;
+    }
+
+    scoped_ptr<base::DictionaryValue> result = make_scoped_ptr(
+        static_cast<base::DictionaryValue*>(message.release()));
+    std::string type;
+    if (!result->GetString("type", &type) ||

[Sergey Ulanov, 2015/08/20 21:50:20]

Add a comment that we are skipping log messages here

[Jamie, 2015/08/20 22:29:16]

Done.

+        type != LogMessageHandler::debug_message_type_name) {
+      return result;
+    }
   }
-
-  std::string message_json(length, '\0');
-  read_result = output_read_file_.ReadAtCurrentPos(
-      string_as_array(&message_json), length);
-  if (read_result != static_cast<int>(length)) {
-    LOG(ERROR) << "Message size (" << read_result
-               << ") doesn't match the header (" << length << ").";
-    return nullptr;
-  }
-
-  scoped_ptr<base::Value> message = base::JSONReader::Read(message_json);
-  if (!message || !message->IsType(base::Value::TYPE_DICTIONARY)) {
-    LOG(ERROR) << "Malformed message:" << message_json;
-    return nullptr;
-  }
-
-  return make_scoped_ptr(
-      static_cast<base::DictionaryValue*>(message.release()));
 }
 
 void It2MeNativeMessagingHostTest::WriteMessageToInputPipe(
     const base::Value& message) {
   std::string message_json;
   base::JSONWriter::Write(message, &message_json);
 
   uint32 length = message_json.length();
   input_write_file_.WriteAtCurrentPos(reinterpret_cast<char*>(&length),
                                       sizeof(length));
@@ skipping 241 matching lines @@
 }
 
 // Verify rejection if type is unrecognized.
 TEST_F(It2MeNativeMessagingHostTest, InvalidType) {
   base::DictionaryValue message;
   message.SetString("type", "xxx");
   TestBadRequest(message, true);
 }
 
 }  // namespace remoting