Renaming NativeMessagingHost to Me2MeNativeMessagingHost.

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 181 matching lines @@
 }
 
 void MockDaemonControllerDelegate::Stop(
     const DaemonController::CompletionCallback& done) {
   done.Run(DaemonController::RESULT_OK);
 }
 
 void MockDaemonControllerDelegate::SetWindow(void* window_handle) {}
 
 std::string MockDaemonControllerDelegate::GetVersion() {
-  // Unused - NativeMessagingHost returns the compiled-in version string
+  // Unused - Me2MeNativeMessagingHost returns the compiled-in version string
   // instead of calling this method.
   NOTREACHED();
   return std::string();
 }
 
 DaemonController::UsageStatsConsent
 MockDaemonControllerDelegate::GetUsageStatsConsent() {
   DaemonController::UsageStatsConsent consent;
   consent.supported = true;
   consent.allowed = true;
   consent.set_by_policy = true;
   return consent;
 }
 
-class NativeMessagingHostTest : public testing::Test {
+class Me2MeNativeMessagingHostTest : public testing::Test {
  public:
-  NativeMessagingHostTest();
-  virtual ~NativeMessagingHostTest();
+  Me2MeNativeMessagingHostTest();
+  virtual ~Me2MeNativeMessagingHostTest();
 
   virtual void SetUp() OVERRIDE;
   virtual 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);
 
  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
+  // Me2MeNativeMessagingHost 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
+  // unittest -> [input] -> Me2MeNativeMessagingHost -> [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::NativeMessagingHost> host_;
+  scoped_ptr<remoting::Me2MeNativeMessagingHost> host_;
 
-  DISALLOW_COPY_AND_ASSIGN(NativeMessagingHostTest);
+  DISALLOW_COPY_AND_ASSIGN(Me2MeNativeMessagingHostTest);
 };
 
-NativeMessagingHostTest::NativeMessagingHostTest() {}
+Me2MeNativeMessagingHostTest::Me2MeNativeMessagingHostTest() {}
 
-NativeMessagingHostTest::~NativeMessagingHostTest() {}
+Me2MeNativeMessagingHostTest::~Me2MeNativeMessagingHostTest() {}
 
-void NativeMessagingHostTest::SetUp() {
+void Me2MeNativeMessagingHostTest::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();
 
   // 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::Bind(&Me2MeNativeMessagingHostTest::ExitTest,
                  base::Unretained(this)));
 
   host_task_runner_->PostTask(
       FROM_HERE,
-      base::Bind(&NativeMessagingHostTest::StartHost, base::Unretained(this)));
+      base::Bind(&Me2MeNativeMessagingHostTest::StartHost,
+                 base::Unretained(this)));
 
   // Wait until the host finishes starting.
   test_run_loop_->Run();
 }
 
-void NativeMessagingHostTest::StartHost() {
+void Me2MeNativeMessagingHostTest::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> channel(
       new NativeMessagingChannel(input_read_handle, output_write_handle));
 
-  host_.reset(new NativeMessagingHost(channel.Pass(),
+  host_.reset(new Me2MeNativeMessagingHost(channel.Pass(),
                                       daemon_controller,
                                       pairing_registry,
                                       scoped_ptr<remoting::OAuthClient>()));
-  host_->Start(base::Bind(&NativeMessagingHostTest::StopHost,
+  host_->Start(base::Bind(&Me2MeNativeMessagingHostTest::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() {
+void Me2MeNativeMessagingHostTest::StopHost() {
   DCHECK(host_task_runner_->RunsTasksOnCurrentThread());
 
   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() {
+void Me2MeNativeMessagingHostTest::ExitTest() {
   if (!test_message_loop_->message_loop_proxy()->RunsTasksOnCurrentThread()) {
     test_message_loop_->message_loop_proxy()->PostTask(
         FROM_HERE,
-        base::Bind(&NativeMessagingHostTest::ExitTest,
+        base::Bind(&Me2MeNativeMessagingHostTest::ExitTest,
                    base::Unretained(this)));
     return;
   }
   test_run_loop_->Quit();
 }
 
-void NativeMessagingHostTest::TearDown() {
+void Me2MeNativeMessagingHostTest::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_|.
+  // The It2MeMe2MeNativeMessagingHost 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>
-NativeMessagingHostTest::ReadMessageFromOutputPipe() {
+Me2MeNativeMessagingHostTest::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');
   read_result = base::ReadPlatformFileAtCurrentPos(
       output_read_handle_, string_as_array(&message_json), length);
   if (read_result != static_cast<int>(length)) {
     return scoped_ptr<base::DictionaryValue>();
   }
 
   scoped_ptr<base::Value> message(base::JSONReader::Read(message_json));
   if (!message || !message->IsType(base::Value::TYPE_DICTIONARY)) {
     return scoped_ptr<base::DictionaryValue>();
   }
 
   return scoped_ptr<base::DictionaryValue>(
       static_cast<base::DictionaryValue*>(message.release()));
 }
 
-void NativeMessagingHostTest::WriteMessageToInputPipe(
+void Me2MeNativeMessagingHostTest::WriteMessageToInputPipe(
     const base::Value& message) {
   std::string message_json;
   base::JSONWriter::Write(&message, &message_json);
 
   uint32 length = message_json.length();
   base::WritePlatformFileAtCurrentPos(input_write_handle_,
                                       reinterpret_cast<char*>(&length),
                                       sizeof(length));
   base::WritePlatformFileAtCurrentPos(input_write_handle_, message_json.data(),
                                       length);
 }
 
-void NativeMessagingHostTest::TestBadRequest(const base::Value& message) {
+void Me2MeNativeMessagingHostTest::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);
 
   // 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, All) {
+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");
   WriteMessageToInputPipe(message);
 
@@ skipping 66 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, Id) {
+TEST_F(Me2MeNativeMessagingHostTest, Id) {
   base::DictionaryValue message;
   message.SetString("type", "hello");
   WriteMessageToInputPipe(message);
   message.SetString("id", "42");
   WriteMessageToInputPipe(message);
 
   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, WrongFormat) {
+TEST_F(Me2MeNativeMessagingHostTest, WrongFormat) {
   base::ListValue message;
   TestBadRequest(message);
 }
 
 // Verify requests with no type are rejected.
-TEST_F(NativeMessagingHostTest, MissingType) {
+TEST_F(Me2MeNativeMessagingHostTest, MissingType) {
   base::DictionaryValue message;
   TestBadRequest(message);
 }
 
 // Verify rejection if type is unrecognized.
-TEST_F(NativeMessagingHostTest, InvalidType) {
+TEST_F(Me2MeNativeMessagingHostTest, InvalidType) {
   base::DictionaryValue message;
   message.SetString("type", "xxx");
   TestBadRequest(message);
 }
 
 // Verify rejection if getPinHash request has no hostId.
-TEST_F(NativeMessagingHostTest, GetPinHashNoHostId) {
+TEST_F(Me2MeNativeMessagingHostTest, 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, GetPinHashNoPin) {
+TEST_F(Me2MeNativeMessagingHostTest, 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, UpdateDaemonConfigInvalidConfig) {
+TEST_F(Me2MeNativeMessagingHostTest, 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, StartDaemonInvalidConfig) {
+TEST_F(Me2MeNativeMessagingHostTest, 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, StartDaemonNoConsent) {
+TEST_F(Me2MeNativeMessagingHostTest, StartDaemonNoConsent) {
   base::DictionaryValue message;
   message.SetString("type", "startDaemon");
   message.Set("config", base::DictionaryValue().DeepCopy());
   TestBadRequest(message);
 }
 
 }  // namespace remoting