It2Me native messaging: GYP and source refactoring

remoting/host/setup/native_messaging_reader_unittest.cc

Index: remoting/host/setup/native_messaging_reader_unittest.cc
diff --git a/remoting/host/setup/native_messaging_reader_unittest.cc b/remoting/host/setup/native_messaging_reader_unittest.cc
deleted file mode 100644
index c78b4c2bd24e4f241ee45299ce0bc9f250a70c6f..0000000000000000000000000000000000000000
--- a/remoting/host/setup/native_messaging_reader_unittest.cc
+++ /dev/null
@@ -1,163 +0,0 @@
-// 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/native_messaging_reader.h"
-
-#include "base/basictypes.h"
-#include "base/bind.h"
-#include "base/memory/scoped_ptr.h"
-#include "base/message_loop/message_loop.h"
-#include "base/platform_file.h"
-#include "base/run_loop.h"
-#include "base/values.h"
-#include "remoting/host/setup/test_util.h"
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace remoting {
-
-class NativeMessagingReaderTest : public testing::Test {
- public:
-  NativeMessagingReaderTest();
-  virtual ~NativeMessagingReaderTest();
-
-  virtual void SetUp() OVERRIDE;
-  virtual void TearDown() OVERRIDE;
-
-  // Starts the reader and runs the MessageLoop to completion.
-  void Run();
-
-  // MessageCallback passed to the Reader. Stores |message| so it can be
-  // verified by tests.
-  void OnMessage(scoped_ptr<base::Value> message);
-
-  // Writes a message (header+body) to the write-end of the pipe.
-  void WriteMessage(std::string message);
-
-  // Writes some data to the write-end of the pipe.
-  void WriteData(const char* data, int length);
-
- protected:
-  scoped_ptr<NativeMessagingReader> reader_;
-  base::PlatformFile read_handle_;
-  base::PlatformFile write_handle_;
-  scoped_ptr<base::Value> message_;
-
- private:
-  // MessageLoop declared here, since the NativeMessageReader ctor requires a
-  // MessageLoop to have been created.
-  base::MessageLoop message_loop_;
-  base::RunLoop run_loop_;
-};
-
-NativeMessagingReaderTest::NativeMessagingReaderTest()
-    : message_loop_(base::MessageLoop::TYPE_IO) {
-}
-
-NativeMessagingReaderTest::~NativeMessagingReaderTest() {}
-
-void NativeMessagingReaderTest::SetUp() {
-  ASSERT_TRUE(MakePipe(&read_handle_, &write_handle_));
-  reader_.reset(new NativeMessagingReader(read_handle_));
-}
-
-void NativeMessagingReaderTest::TearDown() {
-  // |read_handle_| is owned by NativeMessagingReader's FileStream, so don't
-  // try to close it here. Also, |write_handle_| gets closed by Run().
-}
-
-void NativeMessagingReaderTest::Run() {
-  // Close the write-end, so the reader doesn't block waiting for more data.
-  base::ClosePlatformFile(write_handle_);
-
-  // base::Unretained is safe since no further tasks can run after
-  // RunLoop::Run() returns.
-  reader_->Start(
-      base::Bind(&NativeMessagingReaderTest::OnMessage, base::Unretained(this)),
-      run_loop_.QuitClosure());
-  run_loop_.Run();
-}
-
-void NativeMessagingReaderTest::OnMessage(scoped_ptr<base::Value> message) {
-  message_ = message.Pass();
-}
-
-void NativeMessagingReaderTest::WriteMessage(std::string message) {
-  uint32 length = message.length();
-  WriteData(reinterpret_cast<char*>(&length), 4);
-  WriteData(message.data(), length);
-}
-
-void NativeMessagingReaderTest::WriteData(const char* data, int length) {
-  int written = base::WritePlatformFileAtCurrentPos(write_handle_, data,
-                                                    length);
-  ASSERT_EQ(length, written);
-}
-
-TEST_F(NativeMessagingReaderTest, GoodMessage) {
-  WriteMessage("{\"foo\": 42}");
-  Run();
-  EXPECT_TRUE(message_);
-  base::DictionaryValue* message_dict;
-  EXPECT_TRUE(message_->GetAsDictionary(&message_dict));
-  int result;
-  EXPECT_TRUE(message_dict->GetInteger("foo", &result));
-  EXPECT_EQ(42, result);
-}
-
-TEST_F(NativeMessagingReaderTest, InvalidLength) {
-  uint32 length = 0xffffffff;
-  WriteData(reinterpret_cast<char*>(&length), 4);
-  Run();
-  EXPECT_FALSE(message_);
-}
-
-TEST_F(NativeMessagingReaderTest, EmptyFile) {
-  Run();
-  EXPECT_FALSE(message_);
-}
-
-TEST_F(NativeMessagingReaderTest, ShortHeader) {
-  // Write only 3 bytes - the message length header is supposed to be 4 bytes.
-  WriteData("xxx", 3);
-  Run();
-  EXPECT_FALSE(message_);
-}
-
-TEST_F(NativeMessagingReaderTest, EmptyBody) {
-  uint32 length = 1;
-  WriteData(reinterpret_cast<char*>(&length), 4);
-  Run();
-  EXPECT_FALSE(message_);
-}
-
-TEST_F(NativeMessagingReaderTest, ShortBody) {
-  uint32 length = 2;
-  WriteData(reinterpret_cast<char*>(&length), 4);
-
-  // Only write 1 byte, where the header indicates there should be 2 bytes.
-  WriteData("x", 1);
-  Run();
-  EXPECT_FALSE(message_);
-}
-
-TEST_F(NativeMessagingReaderTest, InvalidJSON) {
-  std::string text = "{";
-  WriteMessage(text);
-  Run();
-  EXPECT_FALSE(message_);
-}
-
-TEST_F(NativeMessagingReaderTest, SecondMessage) {
-  WriteMessage("{}");
-  WriteMessage("{\"foo\": 42}");
-  Run();
-  EXPECT_TRUE(message_);
-  base::DictionaryValue* message_dict;
-  EXPECT_TRUE(message_->GetAsDictionary(&message_dict));
-  int result;
-  EXPECT_TRUE(message_dict->GetInteger("foo", &result));
-  EXPECT_EQ(42, result);
-}
-
-}  // namespace remoting