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

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 204 matching lines @@
 }
 
 class NativeMessagingHostTest : public testing::Test {
  public:
   NativeMessagingHostTest();
   virtual ~NativeMessagingHostTest();
 
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
-  void Run();
-
-  // Deletes |host_|.
-  void DeleteHost();
-
   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);
 
  protected:
   // Reference to the MockDaemonControllerDelegate, which is owned by
   // |channel_|.
   MockDaemonControllerDelegate* daemon_controller_delegate_;
 
  private:
+  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_;
 
-  base::MessageLoop message_loop_;
-  base::RunLoop run_loop_;
-  scoped_refptr<AutoThreadTaskRunner> task_runner_;
-  scoped_ptr<remoting::NativeMessagingChannel> channel_;
+  // 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::NativeMessagingHost> host_;
 
   DISALLOW_COPY_AND_ASSIGN(NativeMessagingHostTest);
 };
 
-NativeMessagingHostTest::NativeMessagingHostTest()
-    : message_loop_(base::MessageLoop::TYPE_IO) {}
+NativeMessagingHostTest::NativeMessagingHostTest() {}
 
 NativeMessagingHostTest::~NativeMessagingHostTest() {}
 
 void NativeMessagingHostTest::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));
 
-  // Arrange to run |message_loop_| until no components depend on it.
-  task_runner_ = new AutoThreadTaskRunner(
-      message_loop_.message_loop_proxy(), run_loop_.QuitClosure());
+  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();
+
+  // Arrange to run |test_message_loop_| until no components depend on it.
+  host_task_runner_ = new AutoThreadTaskRunner(
+      host_thread_->message_loop_proxy(),
+      base::Bind(&NativeMessagingHostTest::ExitTest,
+                 base::Unretained(this)));
+
+  host_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&NativeMessagingHostTest::StartHost, base::Unretained(this)));
+
+  // Wait until the host finishes starting.
+  test_run_loop_->Run();
+}
+
+void NativeMessagingHostTest::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_));
+  ASSERT_TRUE(MakePipe(&output_read_handle_, &output_write_handle));
 
   daemon_controller_delegate_ = new MockDaemonControllerDelegate();
   scoped_refptr<DaemonController> daemon_controller(
       new DaemonController(
           scoped_ptr<DaemonController::Delegate>(daemon_controller_delegate_)));
 
   scoped_refptr<PairingRegistry> pairing_registry =
       new SynchronousPairingRegistry(scoped_ptr<PairingRegistry::Delegate>(
           new MockPairingRegistryDelegate()));
-  scoped_ptr<NativeMessagingChannel::Delegate> host(
-      new NativeMessagingHost(daemon_controller,
-                              pairing_registry,
-                              scoped_ptr<remoting::OAuthClient>()));
-  channel_.reset(
-      new NativeMessagingChannel(host.Pass(),
-                                 input_read_handle,
-                                 output_write_handle));
+
+  host_.reset(new NativeMessagingHost(daemon_controller,
+                                      pairing_registry,
+                                      scoped_ptr<remoting::OAuthClient>()));
+  host_->Start(input_read_handle, output_write_handle,
+              base::Bind(&NativeMessagingHostTest::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 NativeMessagingHostTest::StopHost() {
+  DCHECK(host_task_runner_->RunsTasksOnCurrentThread());
+
+  host_->ShutDown();
+  host_.reset();
+
+  // Wait till all shutdown tasks have completed.
+  base::MessageLoop::current()->RunUntilIdle();
+
+  // Trigger a test shutdown via ExitTest().
+  host_task_runner_ = NULL;
+}
+
+void NativeMessagingHostTest::ExitTest() {
+  if (!test_message_loop_->message_loop_proxy()->RunsTasksOnCurrentThread()) {
+    test_message_loop_->message_loop_proxy()->PostTask(
+        FROM_HERE,
+        base::Bind(&NativeMessagingHostTest::ExitTest,
+                   base::Unretained(this)));
+    return;
+  }
+  test_run_loop_->Quit();
 }
 
 void NativeMessagingHostTest::TearDown() {
-  // DaemonController destroys its internals asynchronously. Let these and any
-  // other pending tasks run to make sure we don't leak the memory owned by
-  // them.
-  message_loop_.RunUntilIdle();
+  // 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_);
 
-  // The NativeMessagingHost dtor closes the handles that are passed to it.
-  // |input_write_handle_| gets closed just before starting the host. So the
-  // only handle left to close is |output_read_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_);
 }
 
-void NativeMessagingHostTest::Run() {
-  // Close the write-end of input, so that the host sees EOF after reading
-  // messages and won't block waiting for more input.
-  base::ClosePlatformFile(input_write_handle_);
-  channel_->Start(base::Bind(&NativeMessagingHostTest::DeleteHost,
-                             base::Unretained(this)));
-  run_loop_.Run();
-}
-
-void NativeMessagingHostTest::DeleteHost() {
-  // Destroy |channel_| so that it closes its end of the output pipe, so that
-  // TestBadRequest() will see EOF and won't block waiting for more data.
-  channel_.reset();
-  task_runner_ = NULL;
-}
-
 scoped_ptr<base::DictionaryValue>
 NativeMessagingHostTest::ReadMessageFromOutputPipe() {
   uint32 length;
   int read_result = base::ReadPlatformFileAtCurrentPos(
       output_read_handle_, reinterpret_cast<char*>(&length), sizeof(length));
   if (read_result != sizeof(length)) {
     return scoped_ptr<base::DictionaryValue>();
   }
 
   std::string message_json(length, '\0');
@@ skipping 28 matching lines @@
 void NativeMessagingHostTest::TestBadRequest(const base::Value& message) {
   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);
 
-  Run();
-
   // Read from output pipe, and verify responses.
   scoped_ptr<base::DictionaryValue> response =
       ReadMessageFromOutputPipe();
   VerifyHelloResponse(response.Pass());
 
   response = ReadMessageFromOutputPipe();
   EXPECT_FALSE(response);
 }
 
 // TODO (weitaosu): crbug.com/323306. Re-enable these tests.
 // Test all valid request-types.
-TEST_F(NativeMessagingHostTest, DISABLED_All) {
+TEST_F(NativeMessagingHostTest, 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");
   WriteMessageToInputPipe(message);
 
@@ skipping 33 matching lines @@
   WriteMessageToInputPipe(message);
 
   config.Clear();
   config.SetBoolean("start", true);
   message.Set("config", config.DeepCopy());
   message.SetBoolean("consent", true);
   message.SetInteger("id", next_id++);
   message.SetString("type", "startDaemon");
   WriteMessageToInputPipe(message);
 
-  Run();
-
   void (*verify_routines[])(scoped_ptr<base::DictionaryValue>) = {
     &VerifyHelloResponse,
     &VerifyGetHostNameResponse,
     &VerifyGetPinHashResponse,
     &VerifyGenerateKeyPairResponse,
     &VerifyGetDaemonConfigResponse,
     &VerifyGetUsageStatsConsentResponse,
     &VerifyStopDaemonResponse,
     &VerifyGetDaemonStateResponse,
     &VerifyUpdateDaemonConfigResponse,
@@ skipping 13 matching lines @@
     // Call the verification routine corresponding to the message id.
     ASSERT_TRUE(verify_routines[id]);
     verify_routines[id](response.Pass());
 
     // Clear the pointer so that the routine cannot be called the second time.
     verify_routines[id] = NULL;
   }
 }
 
 // Verify that response ID matches request ID.
-TEST_F(NativeMessagingHostTest, DISABLED_Id) {
+TEST_F(NativeMessagingHostTest, Id) {
   base::DictionaryValue message;
   message.SetString("type", "hello");
   WriteMessageToInputPipe(message);
   message.SetString("id", "42");
   WriteMessageToInputPipe(message);
 
-  Run();
-
   scoped_ptr<base::DictionaryValue> response =
       ReadMessageFromOutputPipe();
   EXPECT_TRUE(response);
   std::string value;
   EXPECT_FALSE(response->GetString("id", &value));
 
   response = ReadMessageFromOutputPipe();
   EXPECT_TRUE(response);
   EXPECT_TRUE(response->GetString("id", &value));
   EXPECT_EQ("42", value);
 }
 
 // Verify non-Dictionary requests are rejected.
-TEST_F(NativeMessagingHostTest, DISABLED_WrongFormat) {
+TEST_F(NativeMessagingHostTest, WrongFormat) {
   base::ListValue message;
   TestBadRequest(message);
 }
 
 // Verify requests with no type are rejected.
-TEST_F(NativeMessagingHostTest, DISABLED_MissingType) {
+TEST_F(NativeMessagingHostTest, MissingType) {
   base::DictionaryValue message;
   TestBadRequest(message);
 }
 
 // Verify rejection if type is unrecognized.
-TEST_F(NativeMessagingHostTest, DISABLED_InvalidType) {
+TEST_F(NativeMessagingHostTest, InvalidType) {
   base::DictionaryValue message;
   message.SetString("type", "xxx");
   TestBadRequest(message);
 }
 
 // Verify rejection if getPinHash request has no hostId.
-TEST_F(NativeMessagingHostTest, DISABLED_GetPinHashNoHostId) {
+TEST_F(NativeMessagingHostTest, GetPinHashNoHostId) {
   base::DictionaryValue message;
   message.SetString("type", "getPinHash");
   message.SetString("pin", "1234");
   TestBadRequest(message);
 }
 
 // Verify rejection if getPinHash request has no pin.
-TEST_F(NativeMessagingHostTest, DISABLED_GetPinHashNoPin) {
+TEST_F(NativeMessagingHostTest, GetPinHashNoPin) {
   base::DictionaryValue message;
   message.SetString("type", "getPinHash");
   message.SetString("hostId", "my_host");
   TestBadRequest(message);
 }
 
 // Verify rejection if updateDaemonConfig request has invalid config.
-TEST_F(NativeMessagingHostTest, DISABLED_UpdateDaemonConfigInvalidConfig) {
+TEST_F(NativeMessagingHostTest, UpdateDaemonConfigInvalidConfig) {
   base::DictionaryValue message;
   message.SetString("type", "updateDaemonConfig");
   message.SetString("config", "xxx");
   TestBadRequest(message);
 }
 
 // Verify rejection if startDaemon request has invalid config.
-TEST_F(NativeMessagingHostTest, DISABLED_StartDaemonInvalidConfig) {
+TEST_F(NativeMessagingHostTest, StartDaemonInvalidConfig) {
   base::DictionaryValue message;
   message.SetString("type", "startDaemon");
   message.SetString("config", "xxx");
   message.SetBoolean("consent", true);
   TestBadRequest(message);
 }
 
 // Verify rejection if startDaemon request has no "consent" parameter.
-TEST_F(NativeMessagingHostTest, DISABLED_StartDaemonNoConsent) {
+TEST_F(NativeMessagingHostTest, StartDaemonNoConsent) {
   base::DictionaryValue message;
   message.SetString("type", "startDaemon");
   message.Set("config", base::DictionaryValue().DeepCopy());
   TestBadRequest(message);
 }
 
 }  // namespace remoting