Disconnect native messaging port on read pipe EOF.

chrome/browser/extensions/api/messaging/native_message_process_host_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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_file.h"
+#include "base/rand_util.h"
 #include "base/run_loop.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/test_timeouts.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "chrome/browser/extensions/api/messaging/native_message_process_host.h"
 #include "chrome/browser/extensions/api/messaging/native_messaging_test_util.h"
 #include "chrome/browser/extensions/api/messaging/native_process_launcher.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_version_info.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/features/feature_channel.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+#if defined(OS_WIN)
+#include <windows.h>
+#include "base/win/scoped_handle.h"
+#else
+#include <unistd.h>
+#endif
+
 using content::BrowserThread;
 
 namespace {
 
 const char kTestMessage[] = "{\"text\": \"Hello.\"}";
 
 base::FilePath GetTestDir() {
   base::FilePath test_dir;
   PathService::Get(chrome::DIR_TEST_DATA, &test_dir);
   test_dir = test_dir.AppendASCII("native_messaging");
   return test_dir;
 }
 
 }  // namespace
 
 namespace extensions {
 
 class FakeLauncher : public NativeProcessLauncher {
  public:
-  FakeLauncher(base::FilePath read_file, base::FilePath write_file) {
-    read_file_ = base::CreatePlatformFile(
-        read_file,
-        base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ |
-            base::PLATFORM_FILE_ASYNC,
-        NULL, NULL);
-    write_file_ = base::CreatePlatformFile(
-        write_file,
-        base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE |
-            base::PLATFORM_FILE_ASYNC,
-        NULL, NULL);
+  FakeLauncher(base::PlatformFile read_file, base::PlatformFile write_file)
+    : read_file_(read_file),
+      write_file_(write_file) {
+  }
+
+  static scoped_ptr<NativeProcessLauncher> Create(base::FilePath read_file,
+                                         base::FilePath write_file) {
+    int read_flags = base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ |
+                     base::PLATFORM_FILE_ASYNC;
+    int write_flags = base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE |
+                      base::PLATFORM_FILE_ASYNC;
+    return scoped_ptr<NativeProcessLauncher>(new FakeLauncher(
+        base::CreatePlatformFile(read_file, read_flags, NULL, NULL),
+        base::CreatePlatformFile(write_file, write_flags, NULL, NULL)));
+  }
+
+  static scoped_ptr<NativeProcessLauncher> CreateWithPipeInput(
+      base::PlatformFile read_pipe,
+      base::FilePath write_file) {
+    int write_flags = base::PLATFORM_FILE_CREATE | base::PLATFORM_FILE_WRITE |
+                      base::PLATFORM_FILE_ASYNC;
+    return scoped_ptr<NativeProcessLauncher>(new FakeLauncher(
+        read_pipe,
+        base::CreatePlatformFile(write_file, write_flags, NULL, NULL)));
   }
 
   virtual void Launch(const GURL& origin,
                       const std::string& native_host_name,
                       LaunchedCallback callback) const OVERRIDE {
     callback.Run(NativeProcessLauncher::RESULT_SUCCESS,
                  read_file_, write_file_);
   }
 
  private:
@@ skipping 77 matching lines @@
   content::TestBrowserThreadBundle thread_bundle_;
   std::string last_message_;
   scoped_ptr<base::DictionaryValue> last_message_parsed_;
 };
 
 // Read a single message from a local file.
 TEST_F(NativeMessagingTest, SingleSendMessageRead) {
   base::FilePath temp_output_file = temp_dir_.path().AppendASCII("output");
   base::FilePath temp_input_file = CreateTempFileWithMessage(kTestMessage);
 
-  scoped_ptr<NativeProcessLauncher> launcher(
-      new FakeLauncher(temp_input_file, temp_output_file));
+  scoped_ptr<NativeProcessLauncher> launcher =
+      FakeLauncher::Create(temp_input_file, temp_output_file).Pass();
   native_message_process_host_ = NativeMessageProcessHost::CreateWithLauncher(
       AsWeakPtr(), kTestNativeMessagingExtensionId, "empty_app.py",
       0, launcher.Pass());
   ASSERT_TRUE(native_message_process_host_.get());
   read_message_run_loop_.reset(new base::RunLoop());
   read_message_run_loop_->RunUntilIdle();
 
   if (last_message_.empty()) {
     read_message_run_loop_.reset(new base::RunLoop());
     native_message_process_host_->ReadNowForTesting();
     read_message_run_loop_->Run();
   }
   EXPECT_EQ(kTestMessage, last_message_);
 }
 
 // Tests sending a single message. The message should get written to
 // |temp_file| and should match the contents of single_message_request.msg.
 TEST_F(NativeMessagingTest, SingleSendMessageWrite) {
   base::FilePath temp_output_file = temp_dir_.path().AppendASCII("output");
-  base::FilePath temp_input_file = CreateTempFileWithMessage(std::string());
 
-  scoped_ptr<NativeProcessLauncher> launcher(
-      new FakeLauncher(temp_input_file, temp_output_file));
+  base::PlatformFile read_file;
+#if defined(OS_WIN)
+  string16 pipe_name = base::StringPrintf(
+      L"\\\\.\\pipe\\chrome.nativeMessaging.out.%llx", base::RandUint64());
+  base::win::ScopedHandle write_handle(
+      CreateNamedPipeW(pipe_name.c_str(),
+                       PIPE_ACCESS_OUTBOUND | FILE_FLAG_OVERLAPPED |
+                           FILE_FLAG_FIRST_PIPE_INSTANCE,
+                       PIPE_TYPE_BYTE, 1, 0, 0, 5000, NULL));
+  ASSERT_TRUE(write_handle);
+  base::win::ScopedHandle read_handle(
+      CreateFileW(pipe_name.c_str(), GENERIC_READ, 0, NULL, OPEN_EXISTING,
+                  FILE_ATTRIBUTE_NORMAL | FILE_FLAG_OVERLAPPED, NULL));
+  ASSERT_TRUE(read_handle);
+
+  read_file = read_handle.Get();
+#else  // defined(OS_WIN)
+  base::PlatformFile pipe_handles[2];
+  ASSERT_EQ(0, pipe(pipe_handles));
+  file_util::ScopedFD read_fd(pipe_handles);
+  file_util::ScopedFD write_fd(pipe_handles + 1);
+
+  read_file = pipe_handles[0];
+#endif  // !defined(OS_WIN)
+
+  scoped_ptr<NativeProcessLauncher> launcher =
+      FakeLauncher::CreateWithPipeInput(read_file, temp_output_file).Pass();
   native_message_process_host_ = NativeMessageProcessHost::CreateWithLauncher(
       AsWeakPtr(), kTestNativeMessagingExtensionId, "empty_app.py",
       0, launcher.Pass());
   ASSERT_TRUE(native_message_process_host_.get());
   base::RunLoop().RunUntilIdle();
 
   native_message_process_host_->Send(kTestMessage);
   base::RunLoop().RunUntilIdle();
 
   std::string output;
@@ skipping 50 matching lines @@
   read_message_run_loop_->Run();
   EXPECT_TRUE(last_message_parsed_->GetInteger("id", &id));
   EXPECT_EQ(2, id);
   EXPECT_TRUE(last_message_parsed_->GetString("echo.foo", &text));
   EXPECT_EQ("bar", text);
   EXPECT_TRUE(last_message_parsed_->GetString("caller_url", &url));
   EXPECT_EQ(expected_url, url);
 }
 
 }  // namespace extensions