Add an implementation of base::SyncSocket::Peek for posix platforms.

ipc/sync_socket_unittest.cc

 // Copyright (c) 2009 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 <stdio.h>
 #include <iostream>
 #include <string>
 #include <sstream>
 
 #include "base/message_loop.h"
@@ skipping 171 matching lines @@
         IPC_MESSAGE_HANDLER(MsgClassResponse, OnMsgClassResponse)
       IPC_END_MESSAGE_MAP()
     }
   }
 
  private:
   // When a response is received from the server, it sends the same
   // string as was written on the SyncSocket.  These are compared
   // and a shutdown message is sent back to the server.
   void OnMsgClassResponse(const std::string& str) {
-#if defined(OS_WIN)
     // We rely on the order of sync_socket.Send() and chan_->Send() in
     // the SyncSocketServerListener object.
     EXPECT_EQ(kHelloStringLength, socket_->Peek());
-#endif
     char buf[kHelloStringLength];
     socket_->Receive(static_cast<void*>(buf), kHelloStringLength);
     EXPECT_EQ(strcmp(str.c_str(), buf), 0);
+    // After receiving from the socket there should be no bytes left.
+    EXPECT_EQ(0, socket_->Peek());
     IPC::Message* msg = new MsgClassShutdown();
     EXPECT_NE(msg, reinterpret_cast<IPC::Message*>(NULL));

[Evan Martin, 2009/12/06 01:45:22]

Off-topic, but I think if "new" returns NULL you've got more major problems than
something a unittest can check for...

     EXPECT_TRUE(chan_->Send(msg));
     MessageLoop::current()->Quit();
   }
 
   base::SyncSocket* socket_;
   IPC::Channel* chan_;
 
   DISALLOW_COPY_AND_ASSIGN(SyncSocketClientListener);
 };
 
 class SyncSocketTest : public IPCChannelTest {
 };
 
 TEST_F(SyncSocketTest, SanityTest) {
   SyncSocketClientListener listener;
   IPC::Channel chan(kSyncSocketChannel, IPC::Channel::MODE_SERVER,
                     &listener);
   base::ProcessHandle server_process = SpawnChild(SYNC_SOCKET_SERVER, &chan);
   ASSERT_TRUE(server_process);
   // Create a pair of SyncSockets.
   base::SyncSocket* pair[2];
   base::SyncSocket::CreatePair(pair);
+  // Immediately after creation there should be no pending bytes.
+  EXPECT_EQ(0, pair[0]->Peek());
+  EXPECT_EQ(0, pair[1]->Peek());
   base::SyncSocket::Handle target_handle;
   // Connect the channel and listener.
   ASSERT_TRUE(chan.Connect());
   listener.Init(pair[0], &chan);
 #if defined(OS_WIN)
   // On windows we need to duplicate the handle into the server process.
   BOOL retval = DuplicateHandle(GetCurrentProcess(), pair[1]->handle(),
                                 server_process, &target_handle,
                                 0, FALSE, DUPLICATE_SAME_ACCESS);
   EXPECT_TRUE(retval);
   // Set up a message to pass the handle to the server.
   IPC::Message* msg = new MsgClassSetHandle(target_handle);
 #else
   target_handle = pair[1]->handle();
   // Set up a message to pass the handle to the server.
   base::FileDescriptor filedesc(target_handle, false);
   IPC::Message* msg = new MsgClassSetHandle(filedesc);
 #endif  // defined(OS_WIN)
   EXPECT_NE(msg, reinterpret_cast<IPC::Message*>(NULL));
   EXPECT_TRUE(chan.Send(msg));
   // Use the current thread as the I/O thread.
   MessageLoop::current()->Run();
   // Shut down.
   delete pair[0];
   delete pair[1];
   EXPECT_TRUE(base::WaitForSingleProcess(server_process, 5000));
   base::CloseProcessHandle(server_process);
 }