net: FileStream cleanup

chrome/browser/extensions/api/messaging/native_message_process_host.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 "chrome/browser/extensions/api/messaging/native_message_process_host.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
-#include "base/platform_file.h"
 #include "base/prefs/pref_service.h"
 #include "base/process/kill.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/api/messaging/native_messaging_host_manifest.h"
 #include "chrome/browser/extensions/api/messaging/native_process_launcher.h"
 #include "chrome/common/chrome_version_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/pref_names.h"
 #include "extensions/common/constants.h"
@@ skipping 74 matching lines @@
     base::WeakPtr<Client> weak_client_ui,
     const std::string& source_extension_id,
     const std::string& native_host_name,
     int destination_port,
     scoped_ptr<NativeProcessLauncher> launcher)
     : weak_client_ui_(weak_client_ui),
       source_extension_id_(source_extension_id),
       native_host_name_(native_host_name),
       destination_port_(destination_port),
       launcher_(launcher.Pass()),
+      process_handle_(base::kNullProcessHandle),
       closed_(false),
-      process_handle_(base::kNullProcessHandle),
-#if defined(OS_POSIX)
-      read_file_(base::kInvalidPlatformFileValue),
-#endif
       read_pending_(false),
-      write_pending_(false) {
+      write_pending_(false),
+      direct_read_for_test_(false) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   // It's safe to use base::Unretained() here because NativeMessagePort always
   // deletes us on the IO thread.
   content::BrowserThread::PostTask(content::BrowserThread::IO, FROM_HERE,
       base::Bind(&NativeMessageProcessHost::LaunchHostProcess,
                  base::Unretained(this)));
 }
 
 NativeMessageProcessHost::~NativeMessageProcessHost() {
@@ skipping 59 matching lines @@
       Close(kForbiddenError);
       return;
     case NativeProcessLauncher::RESULT_FAILED_TO_START:
       Close(kFailedToStartError);
       return;
     case NativeProcessLauncher::RESULT_SUCCESS:
       break;
   }
 
   process_handle_ = process_handle;
-#if defined(OS_POSIX)
-  // This object is not the owner of the file so it should not keep an fd.
-  read_file_ = read_file.GetPlatformFile();
-#endif
 
   scoped_refptr<base::TaskRunner> task_runner(
       content::BrowserThread::GetBlockingPool()->
           GetTaskRunnerWithShutdownBehavior(
               base::SequencedWorkerPool::SKIP_ON_SHUTDOWN));
 
   read_stream_.reset(new net::FileStream(read_file.Pass(), task_runner));
   write_stream_.reset(new net::FileStream(write_file.Pass(), task_runner));
 
   WaitRead();
@@ skipping 18 matching lines @@
   // Push new message to the write queue.
   write_queue_.push(buffer);
 
   // Send() may be called before the host process is started. In that case the
   // message will be written when OnHostProcessLaunched() is called. If it's
   // already started then write the message now.
   if (write_stream_)
     DoWrite();
 }
 
-#if defined(OS_POSIX)
-void NativeMessageProcessHost::OnFileCanReadWithoutBlocking(int fd) {
-  DCHECK_EQ(fd, read_file_);
-  DoRead();
-}
-
-void NativeMessageProcessHost::OnFileCanWriteWithoutBlocking(int fd) {
-  NOTREACHED();
-}
-#endif  // !defined(OS_POSIX)
-
-void NativeMessageProcessHost::ReadNowForTesting() {
-  DoRead();
+void NativeMessageProcessHost::DontWaitToReadForTesting() {
+  direct_read_for_test_ = true;
 }
 
 void NativeMessageProcessHost::WaitRead() {
   if (closed_)
     return;
 
   DCHECK(!read_pending_);
-
-  // On POSIX FileStream::Read() uses blocking thread pool, so it's better to
-  // wait for the file to become readable before calling DoRead(). Otherwise it
-  // would always be consuming one thread in the thread pool. On Windows
-  // FileStream uses overlapped IO, so that optimization isn't necessary there.
-#if defined(OS_POSIX)
-  base::MessageLoopForIO::current()->WatchFileDescriptor(
-    read_file_, false /* persistent */,
-    base::MessageLoopForIO::WATCH_READ, &read_watcher_, this);
-#else  // defined(OS_POSIX)
   DoRead();
-#endif  // defined(!OS_POSIX)
 }
 
 void NativeMessageProcessHost::DoRead() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
 
   while (!closed_ && !read_pending_) {
     read_buffer_ = new net::IOBuffer(kReadBufferSize);
-    int result = read_stream_->Read(
-        read_buffer_.get(),
-        kReadBufferSize,
-        base::Bind(&NativeMessageProcessHost::OnRead, base::Unretained(this)));
+    int result;
+    if (direct_read_for_test_) {
+      result = read_stream_->Read(
+          read_buffer_.get(),
+          kReadBufferSize,
+          base::Bind(&NativeMessageProcessHost::OnRead,
+                     base::Unretained(this)));
+    } else {
+      result = read_stream_->ReadNonBlocking(
+          read_buffer_.get(),
+          kReadBufferSize,
+          base::Bind(&NativeMessageProcessHost::OnRead,
+                     base::Unretained(this)));
+    }
     HandleReadResult(result);
   }
 }
 
 void NativeMessageProcessHost::OnRead(int result) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::IO);
   DCHECK(read_pending_);
   read_pending_ = false;
 
   HandleReadResult(result);
@@ skipping 120 matching lines @@
     content::BrowserThread::PostBlockingPoolTask(
         FROM_HERE, base::Bind(&base::EnsureProcessTerminated, process_handle_));
 #else
     base::EnsureProcessTerminated(process_handle_);
 #endif
     process_handle_ = base::kNullProcessHandle;
   }
 }
 
 }  // namespace extensions