Access singletons with a new GetInstance() method instead of Singleton<T>.

ipc/ipc_channel_posix.cc

 // Copyright (c) 2010 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 "ipc/ipc_channel_posix.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <stddef.h>
 #include <sys/types.h>
@@ skipping 57 matching lines @@
 //   connects. Once the client connects, the server will close the original
 //   copy of the client socket and remove the mapping. Thus, when the client
 //   object closes, it will close the only remaining copy of the client socket
 //   in the fd table and the server will see EOF on its side.
 //
 // TODO(port): a client process cannot connect to multiple IPC channels with
 // this scheme.
 
 class PipeMap {
  public:
+  static PipeMap* GetInstance() {
+    return Singleton<PipeMap>::get();
+  }
+
   // Lookup a given channel id. Return -1 if not found.
   int Lookup(const std::string& channel_id) {
     AutoLock locked(lock_);
 
     ChannelToFDMap::const_iterator i = map_.find(channel_id);
     if (i == map_.end())
       return -1;
     return i->second;
   }
 
@@ skipping 20 matching lines @@
     CHECK(i == map_.end()) << "Creating second IPC server (fd " << fd << ") "
                            << "for '" << channel_id << "' while first "
                            << "(fd " << i->second << ") still exists";
     map_[channel_id] = fd;
   }
 
  private:
   Lock lock_;
   typedef std::map<std::string, int> ChannelToFDMap;
   ChannelToFDMap map_;
+
+  friend struct DefaultSingletonTraits<PipeMap>;
 };
 
 // Used to map a channel name to the equivalent FD # in the current process.
 // Returns -1 if the channel is unknown.
 int ChannelNameToFD(const std::string& channel_id) {
   // See the large block comment above PipeMap for the reasoning here.
-  const int fd = Singleton<PipeMap>()->Lookup(channel_id);
+  const int fd = PipeMap::GetInstance()->Lookup(channel_id);
 
   if (fd != -1) {
     int dup_fd = dup(fd);
     if (dup_fd < 0)
       PLOG(FATAL) << "dup(" << fd << ")";
     return dup_fd;
   }
 
   return fd;
 }
@@ skipping 163 matching lines @@
                   << " mode";
   }
 }
 
 Channel::ChannelImpl::~ChannelImpl() {
   Close();
 }
 
 // static
 void AddChannelSocket(const std::string& name, int socket) {
-  Singleton<PipeMap>()->Insert(name, socket);
+  PipeMap::GetInstance()->Insert(name, socket);
 }
 
 // static
 void RemoveAndCloseChannelSocket(const std::string& name) {
-  Singleton<PipeMap>()->RemoveAndClose(name);
+  PipeMap::GetInstance()->RemoveAndClose(name);
 }
 
 // static
 bool ChannelSocketExists(const std::string& name) {
-  return Singleton<PipeMap>()->Lookup(name) != -1;
+  return PipeMap::GetInstance()->Lookup(name) != -1;
 }
 
 // static
 bool SocketPair(int* fd1, int* fd2) {
   int pipe_fds[2];
   if (socketpair(AF_UNIX, SOCK_STREAM, 0, pipe_fds) != 0) {
     PLOG(ERROR) << "socketpair()";
     return false;
   }
 
@@ skipping 176 matching lines @@
           return false;
         }
       } else if (bytes_read == 0) {
         // The pipe has closed...
         return false;
       }
     }
     DCHECK(bytes_read);
 
     if (client_pipe_ != -1) {
-      Singleton<PipeMap>()->RemoveAndClose(pipe_name_);
+      PipeMap::GetInstance()->RemoveAndClose(pipe_name_);
       client_pipe_ = -1;
     }
 
     // a pointer to an array of |num_wire_fds| file descriptors from the read
     const int* wire_fds = NULL;
     unsigned num_wire_fds = 0;
 
     // walk the list of control messages and, if we find an array of file
     // descriptors, save a pointer to the array
 
@@ skipping 488 matching lines @@
 
   // Unregister libevent for the FIFO and close it.
   read_watcher_.StopWatchingFileDescriptor();
   write_watcher_.StopWatchingFileDescriptor();
   if (pipe_ != -1) {
     if (HANDLE_EINTR(close(pipe_)) < 0)
       PLOG(ERROR) << "close";
     pipe_ = -1;
   }
   if (client_pipe_ != -1) {
-    Singleton<PipeMap>()->RemoveAndClose(pipe_name_);
+    PipeMap::GetInstance()->RemoveAndClose(pipe_name_);
     client_pipe_ = -1;
   }
 #if !defined(OS_MACOSX)
   if (fd_pipe_ != -1) {
     if (HANDLE_EINTR(close(fd_pipe_)) < 0)
       PLOG(ERROR) << "close";
     fd_pipe_ = -1;
   }
   if (remote_fd_pipe_ != -1) {
     if (HANDLE_EINTR(close(remote_fd_pipe_)) < 0)
@@ skipping 47 matching lines @@
 
 bool Channel::Send(Message* message) {
   return channel_impl_->Send(message);
 }
 
 int Channel::GetClientFileDescriptor() const {
   return channel_impl_->GetClientFileDescriptor();
 }
 
 }  // namespace IPC