Refactoring Me2MeNativeMessagingHost to implement NativeMessageHost interface

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 <stddef.h>
-#include <stdint.h>
 
+#include <cstdint>
+#include <memory>
+#include <string>
 #include <utility>
 
 #include "base/compiler_specific.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.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 "google_apis/gaia/gaia_oauth_client.h"
 #include "net/base/file_stream.h"
 #include "net/base/network_interfaces.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/pin_hash.h"
 #include "remoting/host/setup/mock_oauth_client.h"
 #include "remoting/host/setup/test_util.h"
 #include "remoting/protocol/pairing_registry.h"
 #include "remoting/protocol/protocol_mock_objects.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using remoting::protocol::MockPairingRegistryDelegate;
 using remoting::protocol::PairingRegistry;
@@ skipping 235 matching lines @@
 
   // Message loop of the test thread.
   std::unique_ptr<base::MessageLoop> test_message_loop_;
   std::unique_ptr<base::RunLoop> test_run_loop_;
 
   std::unique_ptr<base::Thread> host_thread_;
   std::unique_ptr<base::RunLoop> host_run_loop_;
 
   // Task runner of the host thread.
   scoped_refptr<AutoThreadTaskRunner> host_task_runner_;
-  std::unique_ptr<remoting::Me2MeNativeMessagingHost> host_;
+  std::unique_ptr<NativeMessagingPipe> native_messaging_pipe_;
 
   DISALLOW_COPY_AND_ASSIGN(Me2MeNativeMessagingHostTest);
 };
 
 Me2MeNativeMessagingHostTest::Me2MeNativeMessagingHostTest() {}
 
 Me2MeNativeMessagingHostTest::~Me2MeNativeMessagingHostTest() {}
 
 void Me2MeNativeMessagingHostTest::SetUp() {
   base::File input_read_file;
@@ skipping 34 matching lines @@
   ASSERT_TRUE(MakePipe(&output_read_file_, &output_write_file));
 
   daemon_controller_delegate_ = new MockDaemonControllerDelegate();
   scoped_refptr<DaemonController> daemon_controller(
       new DaemonController(base::WrapUnique(daemon_controller_delegate_)));
 
   scoped_refptr<PairingRegistry> pairing_registry =
       new SynchronousPairingRegistry(
           base::WrapUnique(new MockPairingRegistryDelegate()));
 
+  native_messaging_pipe_.reset(new NativeMessagingPipe());
+
   std::unique_ptr<extensions::NativeMessagingChannel> channel(
       new PipeMessagingChannel(std::move(input_read_file),
                                std::move(output_write_file)));
 
   std::unique_ptr<OAuthClient> oauth_client(
       new MockOAuthClient("fake_user_email", "fake_refresh_token"));
 
-  host_.reset(new Me2MeNativeMessagingHost(false, 0, std::move(channel),
-                                           daemon_controller, pairing_registry,
-                                           std::move(oauth_client)));
-  host_->Start(base::Bind(&Me2MeNativeMessagingHostTest::StopHost,
-                          base::Unretained(this)));
+  std::unique_ptr<ChromotingHostContext> context =
+      ChromotingHostContext::Create(new remoting::AutoThreadTaskRunner(
+          host_task_runner_, base::Bind(&Me2MeNativeMessagingHostTest::StopHost,
+                                        base::Unretained(this))));
+
+  std::unique_ptr<remoting::Me2MeNativeMessagingHost> host(
+      new Me2MeNativeMessagingHost(false, 0, std::move(context),
+                                   daemon_controller, pairing_registry,
+                                   std::move(oauth_client)));
+  host->Start(native_messaging_pipe_.get());
+
+  native_messaging_pipe_->Start(std::move(host), std::move(channel));
 
   // Notify the test that the host has finished starting up.
   test_message_loop_->task_runner()->PostTask(
       FROM_HERE, test_run_loop_->QuitClosure());
 }
 
 void Me2MeNativeMessagingHostTest::StopHost() {
   DCHECK(host_task_runner_->RunsTasksOnCurrentThread());
 
-  host_.reset();
+  native_messaging_pipe_.reset();
 
   // Wait till all shutdown tasks have completed.
   base::RunLoop().RunUntilIdle();
 
   // Trigger a test shutdown via ExitTest().
   host_task_runner_ = nullptr;
 }
 
 void Me2MeNativeMessagingHostTest::ExitTest() {
   if (!test_message_loop_->task_runner()->RunsTasksOnCurrentThread()) {
@@ skipping 261 matching lines @@
 }
 
 // Verify rejection if getCredentialsFromAuthCode has no auth code.
 TEST_F(Me2MeNativeMessagingHostTest, GetCredentialsFromAuthCodeNoAuthCode) {
   base::DictionaryValue message;
   message.SetString("type", "getCredentialsFromAuthCode");
   TestBadRequest(message);
 }
 
 }  // namespace remoting