Me2me Native Messaging host on Windows: restructure NativeMessagingHost and NativeMessagingChannel.…

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"
@@ skipping 169 matching lines @@
   void VerifyDisconnectResponses(int request_id);
 
   // 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, bool expect_error_response);
   void TestConnect();
 
  private:
-  void StartHost(base::PlatformFile input, base::PlatformFile output);
+  void StartHost();
   void StopHost();
   void ExitTest();
 
   // Each test creates two unidirectional pipes: "input" and "output".
   // NativeMessagingHost reads from input_read_handle and writes to
   // output_write_handle. The unittest supplies data to input_write_handle, and
   // verifies output from output_read_handle.
   //
   // unittest -> [input] -> NativeMessagingHost -> [output] -> unittest
   base::PlatformFile input_write_handle_;
   base::PlatformFile output_read_handle_;
 
   // Message loop of the test thread.
   scoped_ptr<base::MessageLoop> test_message_loop_;
   scoped_ptr<base::RunLoop> test_run_loop_;
 
   scoped_ptr<base::Thread> host_thread_;
   scoped_ptr<base::RunLoop> host_run_loop_;
 
   // Task runner of the host thread.
   scoped_refptr<AutoThreadTaskRunner> host_task_runner_;
-  scoped_ptr<remoting::NativeMessagingChannel> channel_;
+  scoped_ptr<remoting::It2MeNativeMessagingHost> host_;
 
   DISALLOW_COPY_AND_ASSIGN(It2MeNativeMessagingHostTest);
 };
 
 void It2MeNativeMessagingHostTest::SetUp() {
-  base::PlatformFile input_read_handle;
-  base::PlatformFile output_write_handle;
-
-  ASSERT_TRUE(MakePipe(&input_read_handle, &input_write_handle_));
-  ASSERT_TRUE(MakePipe(&output_read_handle_, &output_write_handle));
-
   test_message_loop_.reset(new base::MessageLoop());
   test_run_loop_.reset(new base::RunLoop());
 
   // Run the host on a dedicated thread.
   host_thread_.reset(new base::Thread("host_thread"));
   host_thread_->Start();
 
   host_task_runner_ = new AutoThreadTaskRunner(
       host_thread_->message_loop_proxy(),
       base::Bind(&It2MeNativeMessagingHostTest::ExitTest,
                  base::Unretained(this)));
 
   host_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&It2MeNativeMessagingHostTest::StartHost,
-                 base::Unretained(this),
-                 input_read_handle,
-                 output_write_handle));
+                 base::Unretained(this)));
 
   // Wait until the host finishes starting.
   test_run_loop_->Run();
 }
 
 void It2MeNativeMessagingHostTest::TearDown() {
   // Closing the write-end of the input will send an EOF to the native
   // messaging reader. This will trigger a host shutdown.
   base::ClosePlatformFile(input_write_handle_);
 
   // Start a new RunLoop and Wait until the host finishes shutting down.
   test_run_loop_.reset(new base::RunLoop());
   test_run_loop_->Run();
 
   // Verify there are no more message in the output pipe.
   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_handle_|.
   base::ClosePlatformFile(output_read_handle_);
 }
 
 scoped_ptr<base::DictionaryValue>
 It2MeNativeMessagingHostTest::ReadMessageFromOutputPipe() {
   uint32 length;
   int read_result = base::ReadPlatformFileAtCurrentPos(
       output_read_handle_, reinterpret_cast<char*>(&length), sizeof(length));
   if (read_result != sizeof(length)) {
-    LOG(ERROR) << "Invalid message header.";
+    // The output pipe has been closed, return an empty message.
     return scoped_ptr<base::DictionaryValue>();
   }
 
   std::string message_json(length, '\0');
   read_result = base::ReadPlatformFileAtCurrentPos(
       output_read_handle_, 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 scoped_ptr<base::DictionaryValue>();
@@ skipping 139 matching lines @@
 
   VerifyHelloResponse(1);
 
   if (expect_error_response)
     VerifyErrorResponse();
 
   scoped_ptr<base::DictionaryValue> response = ReadMessageFromOutputPipe();
   EXPECT_FALSE(response);
 }
 
-void It2MeNativeMessagingHostTest::StartHost(base::PlatformFile input,
-                                             base::PlatformFile output) {
+void It2MeNativeMessagingHostTest::StartHost() {
   DCHECK(host_task_runner_->RunsTasksOnCurrentThread());
 
+  base::PlatformFile input_read_handle;
+  base::PlatformFile output_write_handle;
+
+  ASSERT_TRUE(MakePipe(&input_read_handle, &input_write_handle_));

[Sergey Ulanov, 2013/12/12 23:55:16]

FWIW, not required for this CL: now that dependency on IO pipes is isolated in
NativeMessaginChannel you could make it an abstract interface and use mock here
instead of actual implementation. That would mean that you wouldn't need to
create these IO pipes and it would make the the test significantly simpler

+  ASSERT_TRUE(MakePipe(&output_read_handle_, &output_write_handle));
+
   // Creating a native messaging host with a mock It2MeHostFactory.
   scoped_ptr<It2MeHostFactory> factory(new MockIt2MeHostFactory());
-  scoped_ptr<NativeMessagingChannel::Delegate> host(
-      new It2MeNativeMessagingHost(host_task_runner_, factory.Pass()));
 
-  // Set up and start the native messaging channel.
-  channel_.reset(new NativeMessagingChannel(host.Pass(), input, output));
-  channel_->Start(base::Bind(&It2MeNativeMessagingHostTest::StopHost,
-                             base::Unretained(this)));
+  scoped_ptr<NativeMessagingChannel> channel(
+      new NativeMessagingChannel(input_read_handle, output_write_handle));
+
+  host_.reset(
+      new It2MeNativeMessagingHost(
+          host_task_runner_, channel.Pass(), factory.Pass()));
+  host_->Start(base::Bind(&It2MeNativeMessagingHostTest::StopHost,
+                          base::Unretained(this)));
 
   // Notify the test that the host has finished starting up.
   test_message_loop_->message_loop_proxy()->PostTask(
       FROM_HERE, test_run_loop_->QuitClosure());
 }
 
 void It2MeNativeMessagingHostTest::StopHost() {
   DCHECK(host_task_runner_->RunsTasksOnCurrentThread());
 
-  // The NativeMessagingChannel dtor will destroy the reader, the writer,
-  // and the delegate (the native messaging host).
-  channel_.reset();
+  host_.reset();
 
   // Wait till all shutdown tasks have completed.
   base::MessageLoop::current()->RunUntilIdle();
 
   // Trigger a test shutdown via ExitTest().
   host_task_runner_ = NULL;
 }
 
 void It2MeNativeMessagingHostTest::ExitTest() {
   if (!test_message_loop_->message_loop_proxy()->RunsTasksOnCurrentThread()) {
@@ skipping 82 matching lines @@
 }
 
 // Verify rejection if type is unrecognized.
 TEST_F(It2MeNativeMessagingHostTest, InvalidType) {
   base::DictionaryValue message;
   message.SetString("type", "xxx");
   TestBadRequest(message, true);
 }
 
 }  // namespace remoting