Revert of Move ScopedFileDescriptor to dbus/file_descriptor.h

chromeos/network/firewall_hole.cc

 // Copyright 2015 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 "chromeos/network/firewall_hole.h"
 
 #include <fcntl.h>
 #include <unistd.h>
 
 #include "base/bind.h"
@@ skipping 32 matching lines @@
     case FirewallHole::PortType::UDP:
       return "UDP";
   }
   NOTREACHED();
   return nullptr;
 }
 
 void PortReleased(FirewallHole::PortType type,
                   uint16_t port,
                   const std::string& interface,
-                  dbus::ScopedFileDescriptor lifeline_fd,
+                  FirewallHole::ScopedFileDescriptor lifeline_fd,
                   bool success) {
   if (!success) {
     LOG(WARNING) << "Failed to release firewall hole for "
                  << PortTypeToString(type) << " port " << port << " on "
                  << interface << ".";
   }
 }
 
 }  // namespace
 
+void CHROMEOS_EXPORT FirewallHole::FileDescriptorDeleter::operator()(
+    dbus::FileDescriptor* fd) {
+  base::WorkerPool::PostTask(
+      FROM_HERE, base::Bind(&base::DeletePointer<dbus::FileDescriptor>, fd),
+      false);
+}
+
 // static
 void FirewallHole::Open(PortType type,
                         uint16_t port,
                         const std::string& interface,
                         const OpenCallback& callback) {
-  dbus::ScopedFileDescriptor lifeline_local(new dbus::FileDescriptor());
-  dbus::ScopedFileDescriptor lifeline_remote(new dbus::FileDescriptor());
+  ScopedFileDescriptor lifeline_local(new dbus::FileDescriptor());
+  ScopedFileDescriptor lifeline_remote(new dbus::FileDescriptor());
 
   // This closure shares pointers with the one below. PostTaskAndReply
   // guarantees that it will always be deleted first.
   base::Closure create_lifeline_closure = base::Bind(
       &CreateValidLifeline, lifeline_local.get(), lifeline_remote.get());
 
   base::WorkerPool::PostTaskAndReply(
       FROM_HERE, create_lifeline_closure,
       base::Bind(&FirewallHole::RequestPortAccess, type, port, interface,
                  base::Passed(&lifeline_local), base::Passed(&lifeline_remote),
@@ skipping 14 matching lines @@
       return;
     case PortType::UDP:
       client->ReleaseUdpPort(port_, interface_, port_released_closure);
       return;
   }
 }
 
 void FirewallHole::RequestPortAccess(PortType type,
                                      uint16_t port,
                                      const std::string& interface,
-                                     dbus::ScopedFileDescriptor lifeline_local,
-                                     dbus::ScopedFileDescriptor lifeline_remote,
+                                     ScopedFileDescriptor lifeline_local,
+                                     ScopedFileDescriptor lifeline_remote,
                                      const OpenCallback& callback) {
   if (!lifeline_local->is_valid() || !lifeline_remote->is_valid()) {
     callback.Run(nullptr);
     return;
   }
 
   base::Callback<void(bool)> access_granted_closure =
       base::Bind(&FirewallHole::PortAccessGranted, type, port, interface,
                  base::Passed(&lifeline_local), callback);
 
   PermissionBrokerClient* client =
       DBusThreadManager::Get()->GetPermissionBrokerClient();
   DCHECK(client) << "Could not get permission broker client.";
 
   switch (type) {
     case PortType::TCP:
       client->RequestTcpPortAccess(port, interface, *lifeline_remote,
                                    access_granted_closure);
       return;
     case PortType::UDP:
       client->RequestUdpPortAccess(port, interface, *lifeline_remote,
                                    access_granted_closure);
       return;
   }
 }
 
 void FirewallHole::PortAccessGranted(PortType type,
                                      uint16_t port,
                                      const std::string& interface,
-                                     dbus::ScopedFileDescriptor lifeline_fd,
+                                     ScopedFileDescriptor lifeline_fd,
                                      const FirewallHole::OpenCallback& callback,
                                      bool success) {
   if (success) {
     callback.Run(make_scoped_ptr(
         new FirewallHole(type, port, interface, lifeline_fd.Pass())));
   } else {
     callback.Run(nullptr);
   }
 }
 
 FirewallHole::FirewallHole(PortType type,
                            uint16_t port,
                            const std::string& interface,
-                           dbus::ScopedFileDescriptor lifeline_fd)
+                           ScopedFileDescriptor lifeline_fd)
     : type_(type),
       port_(port),
       interface_(interface),
       lifeline_fd_(lifeline_fd.Pass()) {
 }
 
 }  // namespace chromeos