Use base::FileDescriptorWatcher instead of MessageLoopForIO::WatchFileDescriptor in proxy_config_se…

net/proxy/proxy_config_service_linux.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 "net/proxy/proxy_config_service_linux.h"
 
 #include <errno.h>
 #if defined(USE_GCONF)
 #include <gconf/gconf-client.h>
 #endif  // defined(USE_GCONF)
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <sys/inotify.h>
 #include <unistd.h>
 
 #include <map>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/leak_annotations.h"
+#include "base/files/file_descriptor_watcher_posix.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/logging.h"
 #include "base/macros.h"
-#include "base/message_loop/message_loop.h"
 #include "base/nix/xdg_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/timer/timer.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_util.h"
 #include "net/proxy/proxy_config.h"
@@ skipping 812 matching lines @@
   }
 
   VLOG(1) << "All gsettings tests OK. Will get proxy config from gsettings.";
   return true;
 }
 #endif  // defined(USE_GIO)
 
 // This is the KDE version that reads kioslaverc and simulates gconf.
 // Doing this allows the main Delegate code, as well as the unit tests
 // for it, to stay the same - and the settings map fairly well besides.
-class SettingGetterImplKDE : public ProxyConfigServiceLinux::SettingGetter,
-                             public base::MessagePumpLibevent::Watcher {
+class SettingGetterImplKDE : public ProxyConfigServiceLinux::SettingGetter {
  public:
   explicit SettingGetterImplKDE(base::Environment* env_var_getter)
       : inotify_fd_(-1),
-        inotify_watcher_(FROM_HERE),
         notify_delegate_(nullptr),
         debounce_timer_(new base::OneShotTimer()),
         indirect_manual_(false),
         auto_no_pac_(false),
         reversed_bypass_list_(false),
         env_var_getter_(env_var_getter),
         file_task_runner_(nullptr) {
     // This has to be called on the UI thread (http://crbug.com/69057).
     base::ThreadRestrictions::ScopedAllowIO allow_io;
 
@@ skipping 87 matching lines @@
     // The initial read is done on the current thread, not
     // |file_task_runner_|, since we will need to have it for
     // SetUpAndFetchInitialConfig().
     UpdateCachedSettings();
     return true;
   }
 
   void ShutDown() override {
     if (inotify_fd_ >= 0) {
       ResetCachedSettings();
-      inotify_watcher_.StopWatchingFileDescriptor();
+      inotify_watcher_.reset();
       close(inotify_fd_);
       inotify_fd_ = -1;
     }
     debounce_timer_.reset();
   }
 
   bool SetUpNotifications(
       ProxyConfigServiceLinux::Delegate* delegate) override {
     DCHECK_GE(inotify_fd_, 0);
     DCHECK(file_task_runner_->BelongsToCurrentThread());
     // We can't just watch the kioslaverc file directly, since KDE will write
     // a new copy of it and then rename it whenever settings are changed and
     // inotify watches inodes (so we'll be watching the old deleted file after
     // the first change, and it will never change again). So, we watch the
     // directory instead. We then act only on changes to the kioslaverc entry.
     if (inotify_add_watch(inotify_fd_, kde_config_dir_.value().c_str(),
                           IN_MODIFY | IN_MOVED_TO) < 0) {
       return false;
     }
     notify_delegate_ = delegate;
-    if (!base::MessageLoopForIO::current()->WatchFileDescriptor(
-            inotify_fd_, true, base::MessageLoopForIO::WATCH_READ,
-            &inotify_watcher_, this)) {
-      return false;
-    }
+    inotify_watcher_ = base::FileDescriptorWatcher::WatchReadable(
+        inotify_fd_, base::Bind(&SettingGetterImplKDE::OnChangeNotification,
+                                base::Unretained(this)));
     // Simulate a change to avoid possibly losing updates before this point.
     OnChangeNotification();
     return true;
   }
 
   const scoped_refptr<base::SingleThreadTaskRunner>& GetNotificationTaskRunner()
       override {
     return file_task_runner_;
   }
 
-  // Implement base::MessagePumpLibevent::Watcher.
-  void OnFileCanReadWithoutBlocking(int fd) override {
-    DCHECK_EQ(fd, inotify_fd_);
-    DCHECK(file_task_runner_->BelongsToCurrentThread());
-    OnChangeNotification();
-  }
-  void OnFileCanWriteWithoutBlocking(int fd) override { NOTREACHED(); }
-
   ProxyConfigSource GetConfigSource() override {
     return PROXY_CONFIG_SOURCE_KDE;
   }
 
   bool GetString(StringSetting key, std::string* result) override {
     string_map_type::iterator it = string_table_.find(key);
     if (it == string_table_.end())
       return false;
     *result = it->second;
     return true;
@@ skipping 282 matching lines @@
       // new behavior (EINVAL) so we can reuse the code below.
       errno = EINVAL;
     if (errno != EAGAIN) {
       PLOG(WARNING) << "error reading inotify file descriptor";
       if (errno == EINVAL) {
         // Our buffer is not large enough to read the next event. This should
         // not happen (because its size is calculated to always be sufficiently
         // large), but if it does we'd warn continuously since |inotify_fd_|
         // would be forever ready to read. Close it and stop watching instead.
         LOG(ERROR) << "inotify failure; no longer watching kioslaverc!";
-        inotify_watcher_.StopWatchingFileDescriptor();
+        inotify_watcher_.reset();
         close(inotify_fd_);
         inotify_fd_ = -1;
       }
     }
     if (kioslaverc_touched) {
       // We don't use Reset() because the timer may not yet be running.
       // (In that case Stop() is a no-op.)
       debounce_timer_->Stop();
       debounce_timer_->Start(FROM_HERE, base::TimeDelta::FromMilliseconds(
           kDebounceTimeoutMilliseconds), this,
           &SettingGetterImplKDE::OnDebouncedNotification);
     }
   }
 
   typedef std::map<StringSetting, std::string> string_map_type;
   typedef std::map<StringListSetting,
                    std::vector<std::string> > strings_map_type;
 
   int inotify_fd_;
-  base::MessagePumpLibevent::FileDescriptorWatcher inotify_watcher_;
+  std::unique_ptr<base::FileDescriptorWatcher::Controller> inotify_watcher_;
   ProxyConfigServiceLinux::Delegate* notify_delegate_;
   std::unique_ptr<base::OneShotTimer> debounce_timer_;
   base::FilePath kde_config_dir_;
   bool indirect_manual_;
   bool auto_no_pac_;
   bool reversed_bypass_list_;
   // We don't own |env_var_getter_|.  It's safe to hold a pointer to it, since
   // both it and us are owned by ProxyConfigServiceLinux::Delegate, and have the
   // same lifetime.
   base::Environment* env_var_getter_;
@@ skipping 431 matching lines @@
 void ProxyConfigServiceLinux::RemoveObserver(Observer* observer) {
   delegate_->RemoveObserver(observer);
 }
 
 ProxyConfigService::ConfigAvailability
     ProxyConfigServiceLinux::GetLatestProxyConfig(ProxyConfig* config) {
   return delegate_->GetLatestProxyConfig(config);
 }
 
 }  // namespace net