Revert of ipc: Add basic memory usage tests for attachment brokering.

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 <sys/mman.h>
 
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/files/scoped_file.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/mac/mac_util.h"
-#include "base/mac/mach_logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/shared_memory.h"
-#include "base/strings/string_number_conversions.h"
-#include "base/synchronization/spin_wait.h"
-#include "base/time/time.h"
 #include "ipc/attachment_broker_messages.h"
 #include "ipc/attachment_broker_privileged_mac.h"
 #include "ipc/attachment_broker_unprivileged_mac.h"
 #include "ipc/ipc_listener.h"
 #include "ipc/ipc_message.h"
 #include "ipc/ipc_test_base.h"
 #include "ipc/ipc_test_messages.h"
 #include "ipc/test_util_mac.h"
 
 namespace {
 
 const char kDataBuffer1[] = "This is some test data to write to the file.";
 const char kDataBuffer2[] = "The lazy dog and a fox.";
 const char kDataBuffer3[] = "Two green bears but not a potato.";
 const char kDataBuffer4[] = "Red potato is best potato.";
 const std::string g_service_switch_name = "service_name";
-const size_t g_large_message_size = 8 * 1024 * 1024;
-const int g_large_message_count = 1000;
-const size_t g_medium_message_size = 512 * 1024;
-
-// Running the message loop is expected to increase the number of resident
-// pages. The exact amount is non-deterministic, but for a simple test suite
-// like this one, the increase is expected to be less than 1 MB.
-const size_t g_expected_memory_increase = 1024 * 1024;
 
 enum TestResult {
   RESULT_UNKNOWN,
   RESULT_SUCCESS,
   RESULT_FAILURE,
 };
 
-mach_vm_size_t GetResidentSize() {
-  task_basic_info_64 info;
-  mach_msg_type_number_t count = TASK_BASIC_INFO_64_COUNT;
-  kern_return_t kr = task_info(mach_task_self(), TASK_BASIC_INFO_64,
-                               reinterpret_cast<task_info_t>(&info), &count);
-  MACH_CHECK(kr == KERN_SUCCESS, kr) << "Couldn't get resident size.";
-
-  return info.resident_size;
-}
-
 base::mac::ScopedMachSendRight GetMachPortFromBrokeredAttachment(
     const scoped_refptr<IPC::BrokerableAttachment>& attachment) {
   if (attachment->GetType() !=
       IPC::BrokerableAttachment::TYPE_BROKERABLE_ATTACHMENT) {
     LOG(INFO) << "Attachment type not TYPE_BROKERABLE_ATTACHMENT.";
     return base::mac::ScopedMachSendRight(MACH_PORT_NULL);
   }
 
   if (attachment->GetBrokerableType() != IPC::BrokerableAttachment::MACH_PORT) {
     LOG(INFO) << "Brokerable type not MACH_PORT.";
@@ skipping 361 matching lines @@
   }
 
   void CheckChildResult() {
     ASSERT_EQ(ProxyListener::MESSAGE_RECEIVED,
               get_proxy_listener()->get_reason());
     ASSERT_EQ(get_result_listener()->get_result(), RESULT_SUCCESS);
   }
 
   void FinalCleanUp() {
     // There should be no leaked names.
-    SPIN_FOR_TIMEDELTA_OR_UNTIL_TRUE(
-        base::TimeDelta::FromSeconds(10),
-        active_names_at_start_ == IPC::GetActiveNameCount());
     EXPECT_EQ(active_names_at_start_, IPC::GetActiveNameCount());
 
     // Close the channel so the client's OnChannelError() gets fired.
     channel()->Close();
 
     EXPECT_TRUE(WaitForClientShutdown());
     DestroyChannel();
     broker_.reset();
   }
 
@@ skipping 43 matching lines @@
 // Channels.
 struct ChildProcessGlobals {
   MockPortProvider port_provider;
 
   // The broker must be destroyed before the port_provider, so that the broker
   // gets a chance to unregister itself as an observer. This doesn't matter
   // outside of tests, since neither port_provider nor broker will ever be
   // destroyed.
   scoped_ptr<IPC::AttachmentBrokerPrivilegedMac> broker;
   base::mac::ScopedMachSendRight server_task_port;
-
-  // Total resident memory before running the message loop.
-  mach_vm_size_t initial_resident_size;
-
-  // Whether to emit log statements while processing messages.
-  bool message_logging;
 };
 
 using OnMessageReceivedCallback = void (*)(IPC::Sender* sender,
                                            const IPC::Message& message,
                                            ChildProcessGlobals* globals);
 
 // Sets up the Mach communication ports with the server. Returns a set of
 // globals that must live at least as long as the test.
 scoped_ptr<ChildProcessGlobals> CommonChildProcessSetUp() {
   base::CommandLine cmd_line = *base::CommandLine::ForCurrentProcess();
   std::string service_name =
       cmd_line.GetSwitchValueASCII(g_service_switch_name);
   base::mac::ScopedMachSendRight server_port(
       IPC::LookupServer(service_name.c_str()));
   base::mac::ScopedMachReceiveRight client_port(IPC::MakeReceivingPort());
 
   // Send the port that this process is listening on to the server.
   IPC::SendMachPort(
       server_port.get(), client_port.get(), MACH_MSG_TYPE_MAKE_SEND);
 
   // Receive the task port of the server process.
   base::mac::ScopedMachSendRight server_task_port(
       IPC::ReceiveMachPort(client_port.get()));
 
   scoped_ptr<ChildProcessGlobals> globals(new ChildProcessGlobals);
   globals->broker.reset(
       new IPC::AttachmentBrokerPrivilegedMac(&globals->port_provider));
   globals->port_provider.InsertEntry(getppid(), server_task_port.get());
   globals->server_task_port.reset(server_task_port.release());
-  globals->message_logging = true;
   return globals;
 }
 
 int CommonPrivilegedProcessMain(OnMessageReceivedCallback callback,
                                 const char* channel_name) {
   LOG(INFO) << "Privileged process start.";
   scoped_ptr<ChildProcessGlobals> globals(CommonChildProcessSetUp());
 
   mach_msg_type_number_t active_names_at_start = IPC::GetActiveNameCount();
 
   base::MessageLoopForIO main_message_loop;
   ProxyListener listener;
 
   scoped_ptr<IPC::Channel> channel(IPC::Channel::CreateClient(
       IPCTestBase::GetChannelName(channel_name), &listener));
   globals->broker->RegisterCommunicationChannel(channel.get());
   CHECK(channel->Connect());
 
-  globals->initial_resident_size = GetResidentSize();
-
   while (true) {
-    if (globals->message_logging)
-      LOG(INFO) << "Privileged process spinning run loop.";
+    LOG(INFO) << "Privileged process spinning run loop.";
     base::MessageLoop::current()->Run();
     ProxyListener::Reason reason = listener.get_reason();
     if (reason == ProxyListener::CHANNEL_ERROR)
       break;
 
     while (listener.has_message()) {
-      if (globals->message_logging)
-        LOG(INFO) << "Privileged process running callback.";
+      LOG(INFO) << "Privileged process running callback.";
       callback(channel.get(), listener.get_first_message(), globals.get());
-      if (globals->message_logging)
-        LOG(INFO) << "Privileged process finishing callback.";
+      LOG(INFO) << "Privileged process finishing callback.";
       listener.pop_first_message();
     }
   }
 
   if (active_names_at_start != IPC::GetActiveNameCount()) {
     LOG(INFO) << "Memory leak!.";
   }
   LOG(INFO) << "Privileged process end.";
   return 0;
 }
@@ skipping 593 matching lines @@
     globals->port_provider.InsertEntry(pid, task_port);
   }
 }
 
 MULTIPROCESS_IPC_TEST_CLIENT_MAIN(SendSharedMemoryHandleToSelfDelayedPort) {
   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,
-                                     ChildProcessGlobals* globals) {
-  EXPECT_LE(GetResidentSize(),
-            globals->initial_resident_size + g_expected_memory_increase);
-
-  base::SharedMemoryHandle shm(GetSharedMemoryHandleFromMsg1(message));
-  scoped_ptr<base::SharedMemory> shared_memory(
-      MapSharedMemoryHandle(shm, false));
-  EXPECT_LE(GetResidentSize(),
-            globals->initial_resident_size + g_expected_memory_increase);
-
-  char c = '\0';
-  void* addr = shared_memory->memory();
-  for (size_t i = 0; i < g_large_message_size; i += 1024) {
-    // Volatile prevents the compiler from optimizing out the read.
-    c += static_cast<volatile char*>(addr)[i];
-  }
-  EXPECT_GE(GetResidentSize(),
-            globals->initial_resident_size + g_large_message_size);
-
-  shared_memory.reset();
-  EXPECT_LE(GetResidentSize(),
-            globals->initial_resident_size + g_expected_memory_increase);
-
-  SendControlMessage(sender, true);
-}
-
-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);
-
-    base::MessageLoop::current()->RunUntilIdle();
-  }
-
-  if (get_result_listener()->get_result() == RESULT_UNKNOWN)
-    base::MessageLoop::current()->Run();
-
-  CommonTearDown();
-}
-
-void MemoryUsageManyMessagesCallback(IPC::Sender* sender,
-                                     const IPC::Message& message,
-                                     ChildProcessGlobals* globals) {
-  static char c = '\0';
-  static int message_index = 0;
-
-  {
-    // Map the shared memory, and make sure that its pages are counting towards
-    // resident size.
-    base::SharedMemoryHandle shm(GetSharedMemoryHandleFromMsg1(message));
-    scoped_ptr<base::SharedMemory> shared_memory(
-        MapSharedMemoryHandle(shm, false));
-
-    char* addr = static_cast<char*>(shared_memory->memory());
-    std::string message_string(addr);
-    int message_int;
-    ASSERT_TRUE(base::StringToInt(message_string, &message_int));
-    ASSERT_EQ(message_index, message_int);
-    for (size_t i = 0; i < g_medium_message_size; i += 1024) {
-      // Volatile prevents the compiler from optimizing out the read.
-      c += static_cast<volatile char*>(addr)[i];
-    }
-  }
-
-  ++message_index;
-
-  if (message_index == 1) {
-    // Disable message logging, since it significantly contributes towards total
-    // memory usage.
-    LOG(INFO) << "Disable privileged process message logging.";
-    globals->message_logging = false;
-  }
-
-  if (message_index == g_large_message_count) {
-    size_t memory_increase_kb =
-        (GetResidentSize() - globals->initial_resident_size) / 1024;
-    LOG(INFO) << "Increase in memory usage in KB: " << memory_increase_kb;
-
-    // The total increase in resident size should be less than 1MB. The exact
-    // amount is not deterministic.
-    bool success = memory_increase_kb < 1024;
-    SendControlMessage(sender, success);
-  }
-}
-
-MULTIPROCESS_IPC_TEST_CLIENT_MAIN(MemoryUsageManyMessages) {
-  return CommonPrivilegedProcessMain(&MemoryUsageManyMessagesCallback,
-                                     "MemoryUsageManyMessages");
-}
-
 }  // namespace