Fix linux ProcessSingleton invalid message handling infinite log spam.

chrome/browser/process_singleton_linux.cc

 // Copyright (c) 2011 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.
 
 // On Linux, when the user tries to launch a second copy of chrome, we check
 // for a socket in the user's profile directory.  If the socket file is open we
 // send a message to the first chrome browser process with the current
 // directory and second process command line flags.  The second process then
 // exits.
 //
@@ skipping 41 matching lines @@
 #include <sys/types.h>
 #include <sys/un.h>
 #include <unistd.h>
 
 #include <cstring>
 #include <set>
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/basictypes.h"
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/eintr_wrapper.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/rand_util.h"
 #include "base/safe_strerror_posix.h"
@@ skipping 382 matching lines @@
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // ProcessSingleton::LinuxWatcher
 // A helper class for a Linux specific implementation of the process singleton.
 // This class sets up a listener on the singleton socket and handles parsing
 // messages that come in on the singleton socket.
 class ProcessSingleton::LinuxWatcher
     : public MessageLoopForIO::Watcher,
       public MessageLoop::DestructionObserver,
-      public base::RefCountedThreadSafe<ProcessSingleton::LinuxWatcher> {
+      public base::RefCountedThreadSafe<ProcessSingleton::LinuxWatcher,
+                                        BrowserThread::DeleteOnIOThread> {
  public:
   // A helper class to read message from an established socket.
   class SocketReader : public MessageLoopForIO::Watcher {
    public:
     SocketReader(ProcessSingleton::LinuxWatcher* parent,
                  MessageLoop* ui_message_loop,
                  int fd)
         : parent_(parent),
           ui_message_loop_(ui_message_loop),
           fd_(fd),
           bytes_read_(0) {
+      DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
       // Wait for reads.
       MessageLoopForIO::current()->WatchFileDescriptor(
           fd, true, MessageLoopForIO::WATCH_READ, &fd_reader_, this);
+      // If we haven't completed in a reasonable amount of time, give up.
       timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(kTimeoutInSeconds),
-                   this, &SocketReader::OnTimerExpiry);
+                   this, &SocketReader::CleanupAndDeleteSelf);
     }
 
     virtual ~SocketReader() {
       CloseSocket(fd_);
     }
 
     // MessageLoopForIO::Watcher impl.
     virtual void OnFileCanReadWithoutBlocking(int fd);
     virtual void OnFileCanWriteWithoutBlocking(int fd) {
       // SocketReader only watches for accept (read) events.
       NOTREACHED();
     }
 
     // Finish handling the incoming message by optionally sending back an ACK
     // message and removing this SocketReader.
     void FinishWithACK(const char *message, size_t length);
 
    private:
-    // If we haven't completed in a reasonable amount of time, give up.
-    void OnTimerExpiry() {
+    void CleanupAndDeleteSelf() {
+      DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
       parent_->RemoveSocketReader(this);
       // We're deleted beyond this point.
     }
 
     MessageLoopForIO::FileDescriptorWatcher fd_reader_;
 
     // The ProcessSingleton::LinuxWatcher that owns us.
     ProcessSingleton::LinuxWatcher* const parent_;
 
     // A reference to the UI message loop.
@@ skipping 22 matching lines @@
 
   // Start listening for connections on the socket.  This method should be
   // called from the IO thread.
   void StartListening(int socket);
 
   // This method determines if we should use the same process and if we should,
   // opens a new browser tab.  This runs on the UI thread.
   // |reader| is for sending back ACK message.
   void HandleMessage(const std::string& current_dir,
                      const std::vector<std::string>& argv,
-                     SocketReader *reader);
+                     SocketReader* reader);
 
   // MessageLoopForIO::Watcher impl.  These run on the IO thread.
   virtual void OnFileCanReadWithoutBlocking(int fd);
   virtual void OnFileCanWriteWithoutBlocking(int fd) {
     // ProcessSingleton only watches for accept (read) events.
     NOTREACHED();
   }
 
   // MessageLoop::DestructionObserver
   virtual void WillDestroyCurrentMessageLoop() {
     fd_watcher_.StopWatchingFileDescriptor();
   }
 
  private:
-  friend class base::RefCountedThreadSafe<ProcessSingleton::LinuxWatcher>;
+  friend struct BrowserThread::DeleteOnThread<BrowserThread::IO>;
+  friend class DeleteTask<ProcessSingleton::LinuxWatcher>;
 
   virtual ~LinuxWatcher() {
+    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
     STLDeleteElements(&readers_);
   }
 
   // Removes and deletes the SocketReader.
   void RemoveSocketReader(SocketReader* reader);
 
   MessageLoopForIO::FileDescriptorWatcher fd_watcher_;
 
   // A reference to the UI message loop (i.e., the message loop we were
   // constructed on).
   MessageLoop* ui_message_loop_;
 
   // The ProcessSingleton that owns us.
   ProcessSingleton* const parent_;
 
   std::set<SocketReader*> readers_;
 
   DISALLOW_COPY_AND_ASSIGN(LinuxWatcher);
 };
 
 void ProcessSingleton::LinuxWatcher::OnFileCanReadWithoutBlocking(int fd) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   // Accepting incoming client.
   sockaddr_un from;
   socklen_t from_len = sizeof(from);
   int connection_socket = HANDLE_EINTR(accept(
       fd, reinterpret_cast<sockaddr*>(&from), &from_len));
   if (-1 == connection_socket) {
     PLOG(ERROR) << "accept() failed";
     return;
   }
   int rv = SetNonBlocking(connection_socket);
@@ skipping 65 matching lines @@
     BrowserInit::ProcessCommandLine(parsed_command_line, current_dir_file_path,
                                     false /* not process startup */, profile,
                                     NULL);
   }
 
   // Send back "ACK" message to prevent the client process from starting up.
   reader->FinishWithACK(kACKToken, arraysize(kACKToken) - 1);
 }
 
 void ProcessSingleton::LinuxWatcher::RemoveSocketReader(SocketReader* reader) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(reader);
   readers_.erase(reader);
   delete reader;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ProcessSingleton::LinuxWatcher::SocketReader
 //
 
 void ProcessSingleton::LinuxWatcher::SocketReader::OnFileCanReadWithoutBlocking(
     int fd) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK_EQ(fd, fd_);
   while (bytes_read_ < sizeof(buf_)) {
     ssize_t rv = HANDLE_EINTR(
         read(fd, buf_ + bytes_read_, sizeof(buf_) - bytes_read_));
     if (rv < 0) {
       if (errno != EAGAIN && errno != EWOULDBLOCK) {
         PLOG(ERROR) << "read() failed";
         CloseSocket(fd);
         return;
       } else {
         // It would block, so we just return and continue to watch for the next
         // opportunity to read.
         return;
       }
     } else if (!rv) {
       // No more data to read.  It's time to process the message.
       break;
     } else {
       bytes_read_ += rv;
     }
   }
 
   // Validate the message.  The shortest message is kStartToken\0x\0x
   const size_t kMinMessageLength = arraysize(kStartToken) + 4;
   if (bytes_read_ < kMinMessageLength) {
     buf_[bytes_read_] = 0;
     LOG(ERROR) << "Invalid socket message (wrong length):" << buf_;
+    CleanupAndDeleteSelf();
     return;
   }
 
   std::string str(buf_, bytes_read_);
   std::vector<std::string> tokens;
   base::SplitString(str, kTokenDelimiter, &tokens);
 
   if (tokens.size() < 3 || tokens[0] != kStartToken) {
     LOG(ERROR) << "Wrong message format: " << str;
+    CleanupAndDeleteSelf();
     return;
   }
 
   // Stop the expiration timer to prevent this SocketReader object from being
   // terminated unexpectly.
   timer_.Stop();
 
   std::string current_dir = tokens[1];
   // Remove the first two tokens.  The remaining tokens should be the command
   // line argv array.
   tokens.erase(tokens.begin());
   tokens.erase(tokens.begin());
 
   // Return to the UI thread to handle opening a new browser tab.
-  ui_message_loop_->PostTask(FROM_HERE, NewRunnableMethod(
+  ui_message_loop_->PostTask(FROM_HERE, base::Bind(
+      &ProcessSingleton::LinuxWatcher::HandleMessage,
       parent_,
-      &ProcessSingleton::LinuxWatcher::HandleMessage,
       current_dir,
       tokens,
       this));
   fd_reader_.StopWatchingFileDescriptor();
 
   // LinuxWatcher::HandleMessage() is in charge of destroying this SocketReader
   // object by invoking SocketReader::FinishWithACK().
 }
 
 void ProcessSingleton::LinuxWatcher::SocketReader::FinishWithACK(
     const char *message, size_t length) {
   if (message && length) {
     // Not necessary to care about the return value.
     WriteToSocket(fd_, message, length);
   }
 
   if (shutdown(fd_, SHUT_WR) < 0)
     PLOG(ERROR) << "shutdown() failed";
 
-  parent_->RemoveSocketReader(this);
-  // We are deleted beyond this point.
+  BrowserThread::PostTask(
+      BrowserThread::IO,
+      FROM_HERE,
+      base::Bind(&ProcessSingleton::LinuxWatcher::RemoveSocketReader,
+                 parent_,
+                 this));
+  // We will be deleted once the posted RemoveSocketReader task runs.
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ProcessSingleton
 //
 ProcessSingleton::ProcessSingleton(const FilePath& user_data_dir)
     : locked_(false),
       foreground_window_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(watcher_(new LinuxWatcher(this))) {
   socket_path_ = user_data_dir.Append(chrome::kSingletonSocketFilename);
@@ skipping 214 matching lines @@
   }
 
   if (listen(sock, 5) < 0)
     NOTREACHED() << "listen failed: " << safe_strerror(errno);
 
   // Normally we would use BrowserThread, but the IO thread hasn't started yet.
   // Using g_browser_process, we start the thread so we can listen on the
   // socket.
   MessageLoop* ml = g_browser_process->io_thread()->message_loop();
   DCHECK(ml);
-  ml->PostTask(FROM_HERE, NewRunnableMethod(
+  ml->PostTask(FROM_HERE, base::Bind(
+    &ProcessSingleton::LinuxWatcher::StartListening,
     watcher_.get(),
-    &ProcessSingleton::LinuxWatcher::StartListening,
     sock));
 
   return true;
 }
 
 void ProcessSingleton::Cleanup() {
   UnlinkPath(socket_path_);
   UnlinkPath(cookie_path_);
   UnlinkPath(lock_path_);
 }