Use FileDescriptorWatcher in AudioPipeReader.

remoting/host/linux/audio_pipe_reader.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 "remoting/host/linux/audio_pipe_reader.h"
 
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/stat.h>
 #include <sys/types.h>
@@ skipping 45 matching lines @@
 
 AudioPipeReader::~AudioPipeReader() {}
 
 void AudioPipeReader::AddObserver(StreamObserver* observer) {
   observers_->AddObserver(observer);
 }
 void AudioPipeReader::RemoveObserver(StreamObserver* observer) {
   observers_->RemoveObserver(observer);
 }
 
-void AudioPipeReader::OnFileCanReadWithoutBlocking(int fd) {
-  DCHECK_EQ(fd, pipe_.GetPlatformFile());
-  StartTimer();
-}
-
-void AudioPipeReader::OnFileCanWriteWithoutBlocking(int fd) {
-  NOTREACHED();
-}
-
 void AudioPipeReader::StartOnAudioThread() {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   if (!file_watcher_.Watch(pipe_path_.DirName(), true,
                            base::Bind(&AudioPipeReader::OnDirectoryChanged,
                                       base::Unretained(this)))) {
     LOG(ERROR) << "Failed to watch pulseaudio directory "
                << pipe_path_.DirName().value();
   }
 
@@ skipping 23 matching lines @@
   if (new_pipe.IsValid() && pipe_.IsValid()) {
     struct stat old_stat;
     struct stat new_stat;
     if (fstat(pipe_.GetPlatformFile(), &old_stat) == 0 &&
         fstat(new_pipe.GetPlatformFile(), &new_stat) == 0 &&
         old_stat.st_ino == new_stat.st_ino) {
       return;
     }
   }
 
-  file_descriptor_watcher_.StopWatchingFileDescriptor();
+  pipe_watch_controller_.reset();
   timer_.Stop();
 
   pipe_ = std::move(new_pipe);
 
   if (pipe_.IsValid()) {
     // Get buffer size for the pipe.
     pipe_buffer_size_ = fpathconf(pipe_.GetPlatformFile(), _PC_PIPE_BUF);
     if (pipe_buffer_size_ < 0) {
       PLOG(ERROR) << "fpathconf(_PC_PIPE_BUF)";
       pipe_buffer_size_ = 4096;
     }
 
     // Read from the pipe twice per buffer length, to avoid starving the stream.
     capture_period_ = base::TimeDelta::FromSeconds(1) * pipe_buffer_size_ /
                       kSampleBytesPerSecond / 2;
 
     WaitForPipeReadable();
   }
 }
 
 void AudioPipeReader::StartTimer() {
   DCHECK(task_runner_->BelongsToCurrentThread());
+  DCHECK(pipe_watch_controller_);
+  pipe_watch_controller_.reset();
   started_time_ = base::TimeTicks::Now();
   last_capture_position_ = 0;
   timer_.Start(FROM_HERE, capture_period_, this, &AudioPipeReader::DoCapture);
 }
 
 void AudioPipeReader::DoCapture() {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(pipe_.IsValid());
 
   // Calculate how much we need read from the pipe. Pulseaudio doesn't control
@@ skipping 44 matching lines @@
   DCHECK_LE(last_capture_position_, stream_position_bytes);
 
   // Dispatch asynchronous notification to the stream observers.
   scoped_refptr<base::RefCountedString> data_ref =
       base::RefCountedString::TakeString(&data);
   observers_->Notify(FROM_HERE, &StreamObserver::OnDataRead, data_ref);
 }
 
 void AudioPipeReader::WaitForPipeReadable() {
   timer_.Stop();
-  base::MessageLoopForIO::current()->WatchFileDescriptor(
-      pipe_.GetPlatformFile(), false, base::MessageLoopForIO::WATCH_READ,
-      &file_descriptor_watcher_, this);
+  DCHECK(!pipe_watch_controller_);
+  pipe_watch_controller_ = base::FileDescriptorWatcher::WatchReadable(
+      pipe_.GetPlatformFile(),
+      base::Bind(&AudioPipeReader::StartTimer, base::Unretained(this)));
 }
 
 // static
 void AudioPipeReaderTraits::Destruct(const AudioPipeReader* audio_pipe_reader) {
   audio_pipe_reader->task_runner_->DeleteSoon(FROM_HERE, audio_pipe_reader);
 }
 
 }  // namespace remoting