Revert 291214 "Fixes three crashes" in an attempt to find the cause of Athena related unit test fai…

trunk/src/athena/system/device_socket_listener.cc

Index: trunk/src/athena/system/device_socket_listener.cc
===================================================================
--- trunk/src/athena/system/device_socket_listener.cc	(revision 291393)
+++ trunk/src/athena/system/device_socket_listener.cc	(working copy)
@@ -12,6 +12,7 @@
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
+#include "base/memory/singleton.h"
 #include "base/message_loop/message_loop.h"
 #include "base/observer_list.h"
 #include "base/stl_util.h"
@@ -54,22 +55,17 @@
 // A singleton instance for managing all connections to sockets.
 class DeviceSocketManager {
  public:
-  static void Create(scoped_refptr<base::TaskRunner> file_task_runner) {
-    device_socket_manager_instance_ = new DeviceSocketManager(file_task_runner);
+  static void Create(scoped_refptr<base::TaskRunner> io_task_runner) {
+    device_socket_manager_instance_ =
+        new DeviceSocketManager(io_task_runner);
   }
 
   static void Shutdown() {
     CHECK(device_socket_manager_instance_);
-    device_socket_manager_instance_->ScheduleDelete();
-    // Once scheduled to be deleted, no-one should be
-    // able to access it.
+    delete device_socket_manager_instance_;
     device_socket_manager_instance_ = NULL;
   }
 
-  static DeviceSocketManager* GetInstanceUnsafe() {
-    return device_socket_manager_instance_;
-  }
-
   static DeviceSocketManager* GetInstance() {
     CHECK(device_socket_manager_instance_);
     return device_socket_manager_instance_;
@@ -98,6 +94,8 @@
   void OnEOF(const std::string& socket_path);
 
  private:
+  friend struct DefaultSingletonTraits<DeviceSocketManager>;
+
   struct SocketData {
     SocketData()
         : fd(-1) {
@@ -109,29 +107,26 @@
     scoped_ptr<DeviceSocketReader> watcher;
   };
 
-  static void DeleteOnFILE(DeviceSocketManager* manager) { delete manager; }
+  DeviceSocketManager(scoped_refptr<base::TaskRunner> io_task_runner)
+      : io_task_runner_(io_task_runner) {
+  }
 
-  DeviceSocketManager(scoped_refptr<base::TaskRunner> file_task_runner)
-      : file_task_runner_(file_task_runner) {}
-
   ~DeviceSocketManager() {
     STLDeleteContainerPairSecondPointers(socket_data_.begin(),
                                          socket_data_.end());
   }
 
-  void ScheduleDelete();
+  void StartListeningOnIO(const std::string& socket_path,
+                          size_t data_size,
+                          DeviceSocketListener* listener);
 
-  void StartListeningOnFILE(const std::string& socket_path,
-                            size_t data_size,
-                            DeviceSocketListener* listener);
+  void StopListeningOnIO(const std::string& socket_path,
+                         DeviceSocketListener* listener);
 
-  void StopListeningOnFILE(const std::string& socket_path,
-                           DeviceSocketListener* listener);
-
   void CloseSocket(const std::string& socket_path);
 
   std::map<std::string, SocketData*> socket_data_;
-  scoped_refptr<base::TaskRunner> file_task_runner_;
+  scoped_refptr<base::TaskRunner> io_task_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceSocketManager);
 };
@@ -167,31 +162,23 @@
 void DeviceSocketManager::StartListening(const std::string& socket_path,
                                          size_t data_size,
                                          DeviceSocketListener* listener) {
-  file_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&DeviceSocketManager::StartListeningOnFILE,
-                 base::Unretained(this),
-                 socket_path,
-                 data_size,
-                 listener));
+  io_task_runner_->PostTask(FROM_HERE,
+      base::Bind(&DeviceSocketManager::StartListeningOnIO,
+                 base::Unretained(this), socket_path, data_size, listener));
 }
 
 void DeviceSocketManager::StopListening(const std::string& socket_path,
                                         DeviceSocketListener* listener) {
-  file_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&DeviceSocketManager::StopListeningOnFILE,
-                 base::Unretained(this),
-                 socket_path,
-                 listener));
+  io_task_runner_->PostTask(FROM_HERE,
+      base::Bind(&DeviceSocketManager::StopListeningOnIO,
+                 base::Unretained(this), socket_path, listener));
 }
 
 void DeviceSocketManager::OnDataAvailable(const std::string& socket_path,
                                           const void* data) {
   CHECK_GT(socket_data_.count(socket_path), 0UL);
   DeviceSocketListeners& listeners = socket_data_[socket_path]->observers;
-  FOR_EACH_OBSERVER(
-      DeviceSocketListener, listeners, OnDataAvailableOnFILE(data));
+  FOR_EACH_OBSERVER(DeviceSocketListener, listeners, OnDataAvailableOnIO(data));
 }
 
 void DeviceSocketManager::CloseSocket(const std::string& socket_path) {
@@ -215,10 +202,10 @@
   CloseSocket(socket_path);
 }
 
-void DeviceSocketManager::StartListeningOnFILE(const std::string& socket_path,
-                                               size_t data_size,
-                                               DeviceSocketListener* listener) {
-  CHECK(file_task_runner_->RunsTasksOnCurrentThread());
+void DeviceSocketManager::StartListeningOnIO(const std::string& socket_path,
+                                             size_t data_size,
+                                             DeviceSocketListener* listener) {
+  CHECK(io_task_runner_->RunsTasksOnCurrentThread());
   SocketData* socket_data = NULL;
   if (!socket_data_.count(socket_path)) {
     int socket_fd = -1;
@@ -250,12 +237,12 @@
   socket_data->observers.AddObserver(listener);
 }
 
-void DeviceSocketManager::StopListeningOnFILE(const std::string& socket_path,
-                                              DeviceSocketListener* listener) {
+void DeviceSocketManager::StopListeningOnIO(const std::string& socket_path,
+                                            DeviceSocketListener* listener) {
   if (!socket_data_.count(socket_path))
     return;  // Happens if unable to create a socket.
 
-  CHECK(file_task_runner_->RunsTasksOnCurrentThread());
+  CHECK(io_task_runner_->RunsTasksOnCurrentThread());
   DeviceSocketListeners& listeners = socket_data_[socket_path]->observers;
   listeners.RemoveObserver(listener);
   if (!listeners.might_have_observers()) {
@@ -264,14 +251,6 @@
   }
 }
 
-void DeviceSocketManager::ScheduleDelete() {
-  // Schedule a task to delete on FILE thread because
-  // there may be a task scheduled on |file_task_runner_|.
-  file_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&DeleteOnFILE, base::Unretained(this)));
-}
-
 }  // namespace
 
 DeviceSocketListener::DeviceSocketListener(const std::string& socket_path,
@@ -286,8 +265,8 @@
 
 // static
 void DeviceSocketListener::CreateSocketManager(
-    scoped_refptr<base::TaskRunner> file_task_runner) {
-  DeviceSocketManager::Create(file_task_runner);
+    scoped_refptr<base::TaskRunner> io_task_runner) {
+  DeviceSocketManager::Create(io_task_runner);
 }
 
 // static
@@ -302,9 +281,7 @@
 }
 
 void DeviceSocketListener::StopListening() {
-  DeviceSocketManager* instance = DeviceSocketManager::GetInstanceUnsafe();
-  if (instance)
-    instance->StopListening(socket_path_, this);
+  DeviceSocketManager::GetInstance()->StopListening(socket_path_, this);
 }
 
 }  // namespace athena