mac: Remove IsOSSnowLeopard().

ipc/attachment_broker_mac_unittest.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 "build/build_config.h"
 
 #include <fcntl.h>
 #include <mach/mach_vm.h>
 #include <stddef.h>
 #include <sys/mman.h>
@@ skipping 580 matching lines @@
     LOG(INFO) << "Memory leak!.";
   }
   LOG(INFO) << "Privileged process end.";
   return 0;
 }
 
 // An unprivileged process makes a shared memory region, and writes a string to
 // it. The SharedMemoryHandle is sent to the privileged process using Chrome
 // IPC. The privileged process checks that it received the same memory region.
 TEST_F(IPCAttachmentBrokerMacTest, SendSharedMemoryHandle) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   CommonSetUp("SendSharedMemoryHandle");
 
   SendMessage1(kDataBuffer1);
   base::MessageLoop::current()->Run();
   CommonTearDown();
 }
 
 void SendSharedMemoryHandleCallback(IPC::Sender* sender,
                                     const IPC::Message& message,
                                     ChildProcessGlobals* globals) {
   bool success = CheckContentsOfMessage1(message, kDataBuffer1);
   SendControlMessage(sender, success);
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendSharedMemoryHandle) {
   return CommonPrivilegedProcessMain(&SendSharedMemoryHandleCallback,
                                      "SendSharedMemoryHandle");
 }
 
 // Similar to SendSharedMemoryHandle, but sends a very long shared memory
 // region.
 TEST_F(IPCAttachmentBrokerMacTest, SendSharedMemoryHandleLong) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   CommonSetUp("SendSharedMemoryHandleLong");
 
   std::string buffer(1 << 23, 'a');
   SendMessage1(buffer);
   base::MessageLoop::current()->Run();
   CommonTearDown();
 }
 
 void SendSharedMemoryHandleLongCallback(IPC::Sender* sender,
                                         const IPC::Message& message,
                                         ChildProcessGlobals* globals) {
   std::string buffer(1 << 23, 'a');
   bool success = CheckContentsOfMessage1(message, buffer);
   SendControlMessage(sender, success);
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendSharedMemoryHandleLong) {
   return CommonPrivilegedProcessMain(&SendSharedMemoryHandleLongCallback,
                                      "SendSharedMemoryHandleLong");
 }
 
 // Similar to SendSharedMemoryHandle, but sends two different shared memory
 // regions in two messages.
 TEST_F(IPCAttachmentBrokerMacTest, SendTwoMessagesDifferentSharedMemoryHandle) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   CommonSetUp("SendTwoMessagesDifferentSharedMemoryHandle");
 
   SendMessage1(kDataBuffer1);
   SendMessage1(kDataBuffer2);
   base::MessageLoop::current()->Run();
   CommonTearDown();
 }
 
 void SendTwoMessagesDifferentSharedMemoryHandleCallback(
     IPC::Sender* sender,
@@ skipping 12 matching lines @@
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendTwoMessagesDifferentSharedMemoryHandle) {
   return CommonPrivilegedProcessMain(
       &SendTwoMessagesDifferentSharedMemoryHandleCallback,
       "SendTwoMessagesDifferentSharedMemoryHandle");
 }
 
 // Similar to SendSharedMemoryHandle, but sends the same shared memory region in
 // two messages.
 TEST_F(IPCAttachmentBrokerMacTest, SendTwoMessagesSameSharedMemoryHandle) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   CommonSetUp("SendTwoMessagesSameSharedMemoryHandle");
 
   {
     scoped_ptr<base::SharedMemory> shared_memory(
         MakeSharedMemory(kDataBuffer1));
 
     for (int i = 0; i < 2; ++i) {
       IPC::Message* message =
           new TestSharedMemoryHandleMsg1(100, shared_memory->handle(), 200);
       sender()->Send(message);
@@ skipping 26 matching lines @@
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendTwoMessagesSameSharedMemoryHandle) {
   return CommonPrivilegedProcessMain(
       &SendTwoMessagesSameSharedMemoryHandleCallback,
       "SendTwoMessagesSameSharedMemoryHandle");
 }
 
 // Similar to SendSharedMemoryHandle, but sends one message with two different
 // memory regions.
 TEST_F(IPCAttachmentBrokerMacTest,
        SendOneMessageWithTwoDifferentSharedMemoryHandles) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   CommonSetUp("SendOneMessageWithTwoDifferentSharedMemoryHandles");
 
   {
     scoped_ptr<base::SharedMemory> shared_memory1(
         MakeSharedMemory(kDataBuffer1));
     scoped_ptr<base::SharedMemory> shared_memory2(
         MakeSharedMemory(kDataBuffer2));
     IPC::Message* message = new TestSharedMemoryHandleMsg2(
         shared_memory1->handle(), shared_memory2->handle());
     sender()->Send(message);
@@ skipping 23 matching lines @@
     SendOneMessageWithTwoDifferentSharedMemoryHandles) {
   return CommonPrivilegedProcessMain(
       &SendOneMessageWithTwoDifferentSharedMemoryHandlesCallback,
       "SendOneMessageWithTwoDifferentSharedMemoryHandles");
 }
 
 // Similar to SendSharedMemoryHandle, but sends one message that contains the
 // same memory region twice.
 TEST_F(IPCAttachmentBrokerMacTest,
        SendOneMessageWithTwoSameSharedMemoryHandles) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   CommonSetUp("SendOneMessageWithTwoSameSharedMemoryHandles");
 
   {
     scoped_ptr<base::SharedMemory> shared_memory(
         MakeSharedMemory(kDataBuffer1));
     IPC::Message* message = new TestSharedMemoryHandleMsg2(
         shared_memory->handle(), shared_memory->handle());
     sender()->Send(message);
   }
   base::MessageLoop::current()->Run();
@@ skipping 19 matching lines @@
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(
     SendOneMessageWithTwoSameSharedMemoryHandles) {
   return CommonPrivilegedProcessMain(
       &SendOneMessageWithTwoSameSharedMemoryHandlesCallback,
       "SendOneMessageWithTwoSameSharedMemoryHandles");
 }
 
 // Sends one message with two Posix FDs and two Mach ports.
 TEST_F(IPCAttachmentBrokerMacTest, SendPosixFDAndMachPort) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   base::ScopedTempDir temp_dir;
   ASSERT_TRUE(temp_dir.CreateUniqueTempDir());
   base::FilePath fp1, fp2;
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir.path(), &fp1));
   ASSERT_TRUE(base::CreateTemporaryFileInDir(temp_dir.path(), &fp2));
 
   CommonSetUp("SendPosixFDAndMachPort");
 
   {
     scoped_ptr<base::SharedMemory> shared_memory1(
@@ skipping 44 matching lines @@
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendPosixFDAndMachPort) {
   return CommonPrivilegedProcessMain(&SendPosixFDAndMachPortCallback,
                                      "SendPosixFDAndMachPort");
 }
 
 // Similar to SendHandle, except the attachment's destination process is this
 // process. This is an unrealistic scenario, but simulates an unprivileged
 // process sending an attachment to another unprivileged process.
 TEST_F(IPCAttachmentBrokerMacTest, SendSharedMemoryHandleToSelf) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   SetBroker(new MockBroker);
   CommonSetUp("SendSharedMemoryHandleToSelf");
 
   // Technically, the channel is an endpoint, but we need the proxy listener to
   // receive the messages so that it can quit the message loop.
   channel()->SetAttachmentBrokerEndpoint(false);
   get_proxy_listener()->set_listener(get_broker());
 
   {
     scoped_ptr<base::SharedMemory> shared_memory(
@@ skipping 38 matching lines @@
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendSharedMemoryHandleToSelf) {
   return CommonPrivilegedProcessMain(&SendSharedMemoryHandleToSelfCallback,
                                      "SendSharedMemoryHandleToSelf");
 }
 
 // Similar to SendSharedMemoryHandle, but uses a ChannelProxy instead of a
 // Channel.
 TEST_F(IPCAttachmentBrokerMacTest, SendSharedMemoryHandleChannelProxy) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   Init("SendSharedMemoryHandleChannelProxy");
   MachPreForkSetUp();
 
   SetBroker(new IPC::AttachmentBrokerUnprivilegedMac);
   get_broker()->AddObserver(get_observer(), task_runner());
 
   scoped_ptr<base::Thread> thread(
       new base::Thread("ChannelProxyTestServerThread"));
   base::Thread::Options options;
   options.message_loop_type = base::MessageLoop::TYPE_IO;
@@ skipping 32 matching lines @@
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendSharedMemoryHandleChannelProxy) {
   return CommonPrivilegedProcessMain(
       &SendSharedMemoryHandleChannelProxyCallback,
       "SendSharedMemoryHandleChannelProxy");
 }
 
 // Similar to SendSharedMemoryHandle, but first makes a copy of the handle using
 // ShareToProcess().
 TEST_F(IPCAttachmentBrokerMacTest, ShareToProcess) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   CommonSetUp("ShareToProcess");
 
   {
     scoped_ptr<base::SharedMemory> shared_memory(
         MakeSharedMemory(kDataBuffer1));
     base::SharedMemoryHandle new_handle;
     ASSERT_TRUE(shared_memory->ShareToProcess(0, &new_handle));
     IPC::Message* message =
         new TestSharedMemoryHandleMsg1(100, new_handle, 200);
     sender()->Send(message);
@@ skipping 10 matching lines @@
   SendControlMessage(sender, success);
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(ShareToProcess) {
   return CommonPrivilegedProcessMain(&ShareToProcessCallback, "ShareToProcess");
 }
 
 // Similar to ShareToProcess, but instead shares the memory object only with
 // read permissions.
 TEST_F(IPCAttachmentBrokerMacTest, ShareReadOnlyToProcess) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   CommonSetUp("ShareReadOnlyToProcess");
 
   {
     scoped_ptr<base::SharedMemory> shared_memory(
         MakeSharedMemory(kDataBuffer1));
     base::SharedMemoryHandle new_handle;
     ASSERT_TRUE(shared_memory->ShareReadOnlyToProcess(0, &new_handle));
     IPC::Message* message =
         new TestSharedMemoryHandleMsg1(100, new_handle, 200);
     sender()->Send(message);
@@ skipping 29 matching lines @@
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(ShareReadOnlyToProcess) {
   return CommonPrivilegedProcessMain(&ShareReadOnlyToProcessCallback,
                                      "ShareReadOnlyToProcess");
 }
 
 // Similar to SendSharedMemoryHandleToSelf, but the child process pretends to
 // not have the task port for the parent process.
 TEST_F(IPCAttachmentBrokerMacTest, SendSharedMemoryHandleToSelfDelayedPort) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   SetBroker(new MockBroker);
   CommonSetUp("SendSharedMemoryHandleToSelfDelayedPort");
 
   // Technically, the channel is an endpoint, but we need the proxy listener to
   // receive the messages so that it can quit the message loop.
   channel()->SetAttachmentBrokerEndpoint(false);
   get_proxy_listener()->set_listener(get_broker());
 
   {
     scoped_ptr<base::SharedMemory> shared_memory(
@@ skipping 76 matching lines @@
   return CommonPrivilegedProcessMain(
       &SendSharedMemoryHandleToSelfDelayedPortCallback,
       "SendSharedMemoryHandleToSelfDelayedPort");
 }
 
 // Tests the memory usage characteristics of attachment brokering a single large
 // message. This test has the *potential* to be flaky, since it compares
 // resident memory at different points in time, and that measurement is
 // non-deterministic.
 TEST_F(IPCAttachmentBrokerMacTest, MemoryUsageLargeMessage) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   CommonSetUp("MemoryUsageLargeMessage");
 
   std::string test_string(g_large_message_size, 'a');
   SendMessage1(test_string);
   base::MessageLoop::current()->Run();
   CommonTearDown();
 }
 
 void MemoryUsageLargeMessageCallback(IPC::Sender* sender,
                                      const IPC::Message& message,
@@ skipping 30 matching lines @@
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(MemoryUsageLargeMessage) {
   return CommonPrivilegedProcessMain(&MemoryUsageLargeMessageCallback,
                                      "MemoryUsageLargeMessage");
 }
 
 // Tests the memory usage characteristics of attachment brokering many small
 // messages. This test has the *potential* to be flaky, since it compares
 // resident memory at different points in time, and that measurement is
 // non-deterministic.
 TEST_F(IPCAttachmentBrokerMacTest, MemoryUsageManyMessages) {
-  // Mach-based SharedMemory isn't support on OSX 10.6.
-  if (base::mac::IsOSSnowLeopard())
-    return;
-
   CommonSetUp("MemoryUsageManyMessages");
 
   for (int i = 0; i < g_large_message_count; ++i) {
     std::string message = base::IntToString(i);
     message += '\0';
     size_t end = message.size();
     message.resize(g_medium_message_size);
     std::fill(message.begin() + end, message.end(), 'a');
     SendMessage1(message);
 
@@ skipping 57 matching lines @@
     SendControlMessage(sender, success);
   }
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(MemoryUsageManyMessages) {
   return CommonPrivilegedProcessMain(&MemoryUsageManyMessagesCallback,
                                      "MemoryUsageManyMessages");
 }
 
 }  // namespace