It2Me Host changes to better support Confirmation Dialog

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 <cstdint>
 #include <memory>
 #include <string>
 #include <utility>
@@ skipping 151 matching lines @@
   RunSetState(kRequestedAccessCode);
 
   std::string access_code(kTestAccessCode);
   base::TimeDelta lifetime =
       base::TimeDelta::FromSeconds(kTestAccessCodeLifetimeInSeconds);
   host_context()->ui_task_runner()->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::Observer::OnStoreAccessCode, observer(),
                             access_code, lifetime));
 
   RunSetState(kReceivedAccessCode);
+  RunSetState(kConnecting);
 
   std::string client_username(kTestClientUsername);
   host_context()->ui_task_runner()->PostTask(
       FROM_HERE, base::Bind(&It2MeHost::Observer::OnClientAuthenticated,
                             observer(), client_username));
 
   RunSetState(kConnected);
 }
 
 void MockIt2MeHost::Disconnect() {
@@ skipping 212 matching lines @@
 void It2MeNativeMessagingHostTest::VerifyErrorResponse() {
   std::unique_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
   VerifyStringProperty(std::move(response), "type", "error");
 }
 
 void It2MeNativeMessagingHostTest::VerifyConnectResponses(int request_id) {
   bool connect_response_received = false;
   bool starting_received = false;
   bool requestedAccessCode_received = false;
   bool receivedAccessCode_received = false;
+  bool connecting_received = false;
   bool connected_received = false;
 
-  // We expect a total of 5 messages: 1 connectResponse and 4 hostStateChanged.
-  for (int i = 0; i < 5; ++i) {
+  // We expect a total of 6 messages: 1 connectResponse and 5 hostStateChanged.
+  for (int i = 0; i < 6; ++i) {
     std::unique_ptr<base::DictionaryValue> response =
         ReadMessageFromOutputPipe();
     ASSERT_TRUE(response);
 
     std::string type;
     ASSERT_TRUE(response->GetString("type", &type));
 
     if (type == "connectResponse") {
       EXPECT_FALSE(connect_response_received);
       connect_response_received = true;
@@ skipping 16 matching lines @@
         receivedAccessCode_received = true;
 
         EXPECT_TRUE(response->GetString("accessCode", &value));
         EXPECT_EQ(kTestAccessCode, value);
 
         int accessCodeLifetime;
         EXPECT_TRUE(
             response->GetInteger("accessCodeLifetime", &accessCodeLifetime));
         EXPECT_EQ(kTestAccessCodeLifetimeInSeconds, accessCodeLifetime);
       } else if (state ==
+                 It2MeNativeMessagingHost::HostStateToString(kConnecting)) {
+        EXPECT_FALSE(connecting_received);
+        connecting_received = true;
+      } else if (state ==
                  It2MeNativeMessagingHost::HostStateToString(kConnected)) {
         EXPECT_FALSE(connected_received);
         connected_received = true;
 
         EXPECT_TRUE(response->GetString("client", &value));
         EXPECT_EQ(kTestClientUsername, value);
       } else {
         ADD_FAILURE() << "Unexpected host state: " << state;
       }
     } else {
@@ skipping 39 matching lines @@
   base::DictionaryValue good_message;
   good_message.SetString("type", "hello");
   good_message.SetInteger("id", 1);
 
   WriteMessageToInputPipe(good_message);
   WriteMessageToInputPipe(message);
   WriteMessageToInputPipe(good_message);
 
   VerifyHelloResponse(1);
 
-  if (expect_error_response)
+  if (expect_error_response) {
     VerifyErrorResponse();
+  }
 
   std::unique_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
   EXPECT_FALSE(response);
 }
 
 void It2MeNativeMessagingHostTest::StartHost() {
   DCHECK(host_task_runner_->RunsTasksOnCurrentThread());
 
   base::File input_read_file;
   base::File output_write_file;
@@ skipping 84 matching lines @@
   response = ReadMessageFromOutputPipe();
   EXPECT_TRUE(response);
   EXPECT_TRUE(response->GetString("id", &value));
   EXPECT_EQ("42", value);
 }
 
 TEST_F(It2MeNativeMessagingHostTest, Connect) {
   // A new It2MeHost instance is created for every it2me session. The native
   // messaging host, on the other hand, is long lived. This test verifies
   // multiple It2Me host startup and shutdowns.
-  for (int i = 0; i < 3; ++i)
+  for (int i = 0; i < 3; ++i) {
     TestConnect();
+  }
 }
 
 // Verify non-Dictionary requests are rejected.
 TEST_F(It2MeNativeMessagingHostTest, WrongFormat) {
   base::ListValue message;
   // No "error" response will be sent for non-Dictionary messages.
   TestBadRequest(message, false);
 }
 
 // Verify requests with no type are rejected.
 TEST_F(It2MeNativeMessagingHostTest, MissingType) {
   base::DictionaryValue message;
   TestBadRequest(message, true);
 }
 
 // Verify rejection if type is unrecognized.
 TEST_F(It2MeNativeMessagingHostTest, InvalidType) {
   base::DictionaryValue message;
   message.SetString("type", "xxx");
   TestBadRequest(message, true);
 }
 
 }  // namespace remoting