Pass error messages from native messaging to web-app.

remoting/host/setup/me2me_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/setup/me2me_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"
@@ skipping 144 matching lines @@
  public:
   MockDaemonControllerDelegate();
   ~MockDaemonControllerDelegate() override;
 
   // DaemonController::Delegate interface.
   DaemonController::State GetState() override;
   scoped_ptr<base::DictionaryValue> GetConfig() override;
   void SetConfigAndStart(
       scoped_ptr<base::DictionaryValue> config,
       bool consent,
-      const DaemonController::CompletionCallback& done) override;
+      const base::Closure& on_done,
+      const DaemonController::ErrorCallback& on_error) override;
   void UpdateConfig(scoped_ptr<base::DictionaryValue> config,
-                    const DaemonController::CompletionCallback& done) override;
-  void Stop(const DaemonController::CompletionCallback& done) override;
+                    const base::Closure& on_done,
+                    const DaemonController::ErrorCallback& on_error) override;
+  void Stop(const base::Closure& on_done,
+            const DaemonController::ErrorCallback& on_error) override;
   DaemonController::UsageStatsConsent GetUsageStatsConsent() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(MockDaemonControllerDelegate);
 };
 
 MockDaemonControllerDelegate::MockDaemonControllerDelegate() {}
 
 MockDaemonControllerDelegate::~MockDaemonControllerDelegate() {}
 
 DaemonController::State MockDaemonControllerDelegate::GetState() {
   return DaemonController::STATE_STARTED;
 }
 
 scoped_ptr<base::DictionaryValue> MockDaemonControllerDelegate::GetConfig() {
   return make_scoped_ptr(new base::DictionaryValue());
 }
 
 void MockDaemonControllerDelegate::SetConfigAndStart(
     scoped_ptr<base::DictionaryValue> config,
     bool consent,
-    const DaemonController::CompletionCallback& done) {
+    const base::Closure& on_done,
+    const DaemonController::ErrorCallback& on_error) {
 
   // Verify parameters passed in.
   if (consent && config && config->HasKey("start")) {
-    done.Run(DaemonController::RESULT_OK);
+    on_done.Run();
   } else {
-    done.Run(DaemonController::RESULT_FAILED);
+    on_error.Run("Missing 'start'", FROM_HERE);
   }
 }
 
 void MockDaemonControllerDelegate::UpdateConfig(
     scoped_ptr<base::DictionaryValue> config,
-    const DaemonController::CompletionCallback& done) {
+    const base::Closure& on_done,
+    const DaemonController::ErrorCallback& on_error) {
   if (config && config->HasKey("update")) {
-    done.Run(DaemonController::RESULT_OK);
+    on_done.Run();
   } else {
-    done.Run(DaemonController::RESULT_FAILED);
+    on_error.Run("Missing 'update'", FROM_HERE);
   }
 }
 
 void MockDaemonControllerDelegate::Stop(
-    const DaemonController::CompletionCallback& done) {
-  done.Run(DaemonController::RESULT_OK);
+    const base::Closure& on_done,
+    const DaemonController::ErrorCallback& on_error) {
+  on_done.Run();
 }
 
 DaemonController::UsageStatsConsent
 MockDaemonControllerDelegate::GetUsageStatsConsent() {
   DaemonController::UsageStatsConsent consent;
   consent.supported = true;
   consent.allowed = true;
   consent.set_by_policy = true;
   return consent;
 }
 
 class Me2MeNativeMessagingHostTest : public testing::Test {
  public:
   Me2MeNativeMessagingHostTest();
   ~Me2MeNativeMessagingHostTest() override;
 
   void SetUp() override;
   void TearDown() override;
 
   scoped_ptr<base::DictionaryValue> ReadMessageFromOutputPipe();
 
   void WriteMessageToInputPipe(const base::Value& message);
 
-  // The Host process should shut down when it receives a malformed request.
-  // This is tested by sending a known-good request, followed by |message|,
-  // followed by the known-good request again. The response file should only
-  // contain a single response from the first good request.
-  void TestBadRequest(const base::Value& message);
+  void TestBadDictionary(const base::DictionaryValue& message);
+  void TestBadRequest(const base::Value& message,
+                      const std::string& expected_type);
 
  protected:
   // Reference to the MockDaemonControllerDelegate, which is owned by
   // |channel_|.
   MockDaemonControllerDelegate* daemon_controller_delegate_;
 
  private:
   void StartHost();
   void StopHost();
   void ExitTest();
@@ skipping 159 matching lines @@
     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));
   input_write_file_.WriteAtCurrentPos(message_json.data(), length);
 }
 
-void Me2MeNativeMessagingHostTest::TestBadRequest(const base::Value& message) {
+void Me2MeNativeMessagingHostTest::TestBadDictionary(
+    const base::DictionaryValue& message) {
+  std::string type;
+  EXPECT_TRUE(message.GetString("type", &type));
+  TestBadRequest(message, type + "Response");
+}
+
+void Me2MeNativeMessagingHostTest::TestBadRequest(
+    const base::Value& message,
+    const std::string& expected_type) {
   base::DictionaryValue good_message;
   good_message.SetString("type", "hello");
 
   // This test currently relies on synchronous processing of hello messages and
   // message parameters verification.
   WriteMessageToInputPipe(good_message);
   WriteMessageToInputPipe(message);
-  WriteMessageToInputPipe(good_message);
 
   // Read from output pipe, and verify responses.
   scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
   VerifyHelloResponse(response.Pass());
 
   response = ReadMessageFromOutputPipe();
-  EXPECT_FALSE(response);
+  EXPECT_TRUE(response);
+
+  // If a type is expected, assert that it matches (note that a type is expected
+  // for all message that included one).
+  std::string value;
+  if (!expected_type.empty()) {
+    EXPECT_TRUE(response->GetString("type", &value));
+    EXPECT_EQ(expected_type, value);
+  } else {
+    EXPECT_FALSE(response->GetString("type", &value));
+  }
+
+  EXPECT_TRUE(response->GetString("error_message", &value));
+  EXPECT_TRUE(response->GetString("error_location", &value));
 }
 
-// TODO (weitaosu): crbug.com/323306. Re-enable these tests.
 // Test all valid request-types.
 TEST_F(Me2MeNativeMessagingHostTest, All) {
   int next_id = 0;
   base::DictionaryValue message;
   message.SetInteger("id", next_id++);
   message.SetString("type", "hello");
   WriteMessageToInputPipe(message);
 
   message.SetInteger("id", next_id++);
   message.SetString("type", "getHostName");
@@ skipping 95 matching lines @@
 
   response = ReadMessageFromOutputPipe();
   EXPECT_TRUE(response);
   EXPECT_TRUE(response->GetString("id", &value));
   EXPECT_EQ("42", value);
 }
 
 // Verify non-Dictionary requests are rejected.
 TEST_F(Me2MeNativeMessagingHostTest, WrongFormat) {
   base::ListValue message;
-  TestBadRequest(message);
+  TestBadRequest(message, "");
 }
 
 // Verify requests with no type are rejected.
 TEST_F(Me2MeNativeMessagingHostTest, MissingType) {
   base::DictionaryValue message;
-  TestBadRequest(message);
+  TestBadRequest(message, "");
 }
 
 // Verify rejection if type is unrecognized.
 TEST_F(Me2MeNativeMessagingHostTest, InvalidType) {
   base::DictionaryValue message;
   message.SetString("type", "xxx");
-  TestBadRequest(message);
+  TestBadDictionary(message);
 }
 
 // Verify rejection if getPinHash request has no hostId.
 TEST_F(Me2MeNativeMessagingHostTest, GetPinHashNoHostId) {
   base::DictionaryValue message;
   message.SetString("type", "getPinHash");
   message.SetString("pin", "1234");
-  TestBadRequest(message);
+  TestBadDictionary(message);
 }
 
 // Verify rejection if getPinHash request has no pin.
 TEST_F(Me2MeNativeMessagingHostTest, GetPinHashNoPin) {
   base::DictionaryValue message;
   message.SetString("type", "getPinHash");
   message.SetString("hostId", "my_host");
-  TestBadRequest(message);
+  TestBadDictionary(message);
 }
 
 // Verify rejection if updateDaemonConfig request has invalid config.
 TEST_F(Me2MeNativeMessagingHostTest, UpdateDaemonConfigInvalidConfig) {
   base::DictionaryValue message;
   message.SetString("type", "updateDaemonConfig");
   message.SetString("config", "xxx");
-  TestBadRequest(message);
+  TestBadDictionary(message);
 }
 
 // Verify rejection if startDaemon request has invalid config.
 TEST_F(Me2MeNativeMessagingHostTest, StartDaemonInvalidConfig) {
   base::DictionaryValue message;
   message.SetString("type", "startDaemon");
   message.SetString("config", "xxx");
   message.SetBoolean("consent", true);
-  TestBadRequest(message);
+  TestBadDictionary(message);
 }
 
 // Verify rejection if startDaemon request has no "consent" parameter.
 TEST_F(Me2MeNativeMessagingHostTest, StartDaemonNoConsent) {
   base::DictionaryValue message;
   message.SetString("type", "startDaemon");
   message.Set("config", base::DictionaryValue().DeepCopy());
-  TestBadRequest(message);
+  TestBadDictionary(message);
 }
 
 // Verify rejection if getCredentialsFromAuthCode has no auth code.
 TEST_F(Me2MeNativeMessagingHostTest, GetCredentialsFromAuthCodeNoAuthCode) {
   base::DictionaryValue message;
   message.SetString("type", "getCredentialsFromAuthCode");
-  TestBadRequest(message);
+  TestBadDictionary(message);
 }
 
 }  // namespace remoting