User MessageLoopForIO::WatchFileDescriptor in proces_output_watcher

chromeos/process_proxy/process_output_watcher_unittest.cc

 // Copyright (c) 2012 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 <gtest/gtest.h>
 
 #include <queue>
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread.h"
 #include "chromeos/process_proxy/process_output_watcher.h"
 
 namespace chromeos {
 
+namespace {
+
 struct TestCase {
   TestCase(const std::string& input, bool send_terminating_null)
       : input(input),
         should_send_terminating_null(send_terminating_null),
         expected_output(input) {}
 
   // Conctructor for cases where the output is not expected to be the same as
   // input.
   TestCase(const std::string& input,
            bool send_terminating_null,
@@ skipping 42 matching lines @@
 
   bool IsDone() {
     return received_from_out_ >= out_expectations_.length();
   }
 
  private:
   std::string out_expectations_;
   size_t received_from_out_;
 };
 
+void StopProcessOutputWatcher(scoped_ptr<ProcessOutputWatcher> watcher) {
+  // Just deleting |watcher| if sufficient.
+}
+
+}  // namespace
+
 class ProcessOutputWatcherTest : public testing::Test {
  public:
   ProcessOutputWatcherTest() : output_watch_thread_started_(false),
                                failed_(false) {
   }
 
   ~ProcessOutputWatcherTest() override {}
 
   void TearDown() override {
     if (output_watch_thread_started_)
       output_watch_thread_->Stop();
   }
 
-  void StartWatch(int pt, int stop) {
-    // This will delete itself.
-    ProcessOutputWatcher* crosh_watcher = new ProcessOutputWatcher(pt, stop,
-        base::Bind(&ProcessOutputWatcherTest::OnRead, base::Unretained(this)));
-    crosh_watcher->Start();
-  }
-
   void OnRead(ProcessOutputType type, const std::string& output) {
     ASSERT_FALSE(failed_);
     // There may be an EXIT signal sent during test tear down (which is sent
     // by process output watcher when master end of test pseudo-terminal is
     // closed). If this happens, ignore it. If EXIT is seen before test
     // expectations are met, fall through in order to fail the test.
     if (type == PROCESS_OUTPUT_TYPE_EXIT && expectations_.IsDone()) {
       ASSERT_TRUE(test_case_done_callback_.is_null());
       return;
     }
@@ skipping 11 matching lines @@
   std::string VeryLongString() {
     std::string result = "0123456789";
     for (int i = 0; i < 8; i++)
       result = result.append(result);
     return result;
   }
 
   void RunTest(const std::vector<TestCase>& test_cases) {
     ASSERT_FALSE(output_watch_thread_started_);
     output_watch_thread_.reset(new base::Thread("ProcessOutpuWatchThread"));
-    output_watch_thread_started_ = output_watch_thread_->Start();
+    output_watch_thread_started_ = output_watch_thread_->StartWithOptions(
+        base::Thread::Options(base::MessageLoop::TYPE_IO, 0));
     ASSERT_TRUE(output_watch_thread_started_);
 
-    int pt_pipe[2], stop_pipe[2];
+    int pt_pipe[2];
     ASSERT_FALSE(HANDLE_EINTR(pipe(pt_pipe)));
-    ASSERT_FALSE(HANDLE_EINTR(pipe(stop_pipe)));
+
+    scoped_ptr<ProcessOutputWatcher> crosh_watcher(new ProcessOutputWatcher(
+        pt_pipe[0],
+        base::Bind(&ProcessOutputWatcherTest::OnRead, base::Unretained(this))));
 
     output_watch_thread_->task_runner()->PostTask(
-        FROM_HERE,
-        base::Bind(&ProcessOutputWatcherTest::StartWatch,
-                   base::Unretained(this), pt_pipe[0], stop_pipe[0]));
+        FROM_HERE, base::Bind(&ProcessOutputWatcher::Start,
+                              base::Unretained(crosh_watcher.get())));
 
     for (size_t i = 0; i < test_cases.size(); i++) {
       expectations_.SetTestCase(test_cases[i]);
 
       base::RunLoop run_loop;
       ASSERT_TRUE(test_case_done_callback_.is_null());
       test_case_done_callback_ = run_loop.QuitClosure();
 
       const std::string& test_str = test_cases[i].input;
       // Let's make inputs not NULL terminated, unless other is specified in
       // the test case.
       ssize_t test_size = test_str.length() * sizeof(*test_str.c_str());
       if (test_cases[i].should_send_terminating_null)
         test_size += sizeof(*test_str.c_str());
       EXPECT_TRUE(base::WriteFileDescriptor(pt_pipe[1], test_str.c_str(),
                                             test_size));
 
       run_loop.Run();
       EXPECT_TRUE(expectations_.IsDone());
       if (failed_)
         break;
     }
 
-    // Send stop signal. It is not important which string we send.
-    EXPECT_TRUE(base::WriteFileDescriptor(stop_pipe[1], "q", 1));
+    output_watch_thread_->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&StopProcessOutputWatcher, base::Passed(&crosh_watcher)));
 
-    EXPECT_NE(-1, IGNORE_EINTR(close(stop_pipe[1])));
     EXPECT_NE(-1, IGNORE_EINTR(close(pt_pipe[1])));
   }
 
  private:
   base::Closure test_case_done_callback_;
   base::MessageLoop message_loop_;
   scoped_ptr<base::Thread> output_watch_thread_;
   bool output_watch_thread_started_;
   bool failed_;
   ProcessWatcherExpectations expectations_;
@@ skipping 123 matching lines @@
   // This will send '\0' to output watcher.
   test_cases.push_back(TestCase("", true));
   // Let's verify that next input also gets detected (i.e. output watcher does
   // not exit after seeing '\0' from previous test case).
   test_cases.push_back(TestCase("a", true));
 
   RunTest(test_cases);
 }
 
 }  // namespace chromeos