Mac: Proof of concept of IPCing renderer mach_port_ts.

chrome/browser/child_process_launcher.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 "chrome/browser/child_process_launcher.h"
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/scoped_ptr.h"
 #include "base/thread.h"
 #include "chrome/browser/chrome_thread.h"
 #include "chrome/common/chrome_descriptors.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/process_watcher.h"
 #include "chrome/common/result_codes.h"
 
 #if defined(OS_WIN)
 #include "chrome/browser/sandbox_policy.h"
 #elif defined(OS_LINUX)
 #include "base/singleton.h"
 #include "chrome/browser/crash_handler_host_linux.h"
 #include "chrome/browser/zygote_host_linux.h"
 #include "chrome/browser/renderer_host/render_sandbox_host_linux.h"
 #endif
 
 #if defined(OS_POSIX)
 #include "base/global_descriptors_posix.h"
 #endif
 
+#include "chrome/common/mach_ipc_mac.h"
+#include <mach/host_info.h>
+#include <mach/processor_info.h>
+
 // Having the functionality of ChildProcessLauncher be in an internal
 // ref counted object allows us to automatically terminate the process when the
 // parent class destructs, while still holding on to state that we need.
 class ChildProcessLauncher::Context
     : public base::RefCountedThreadSafe<ChildProcessLauncher::Context> {
  public:
   Context()
       : starting_(true)
 #if defined(OS_LINUX)
         , zygote_(false)
@@ skipping 117 matching lines @@
             kSandboxIPCChannel + base::GlobalDescriptors::kBaseDescriptor));
       }
 #endif  // defined(OS_LINUX)
 
       // Actually launch the app.
       if (!base::LaunchApp(cmd_line->argv(), env, fds_to_map, false, &handle))
         handle = base::kNullProcessHandle;
     }
 #endif
 
+    // This creates our named server port
+    ReceivePort receivePort("com.Google.MyService");
+
+    MachReceiveMessage message;
+    kern_return_t result = receivePort.WaitForMessage(&message, 1000);  // timeout 1000ms
+
+    if (result == KERN_SUCCESS && message.GetMessageID() == 57) {
+
+      mach_port_t task = message.GetTranslatedPort(0);
+      mach_port_t thread = message.GetTranslatedPort(1);
+      mach_port_t host = message.GetTranslatedPort(2);
+
+      unsigned char *messageString = static_cast<unsigned char*>(message.GetData());
+
+      printf("message string = %s %lu %lu\n", messageString, (unsigned long)task, (unsigned long)thread);
+
+      kern_return_t error;
+      host_cpu_load_info_data_t /*prev_cpu_load, */cpu_load;
+      mach_msg_type_number_t count = HOST_CPU_LOAD_INFO_COUNT;
+      error = host_statistics(host,
+                      HOST_CPU_LOAD_INFO,
+                      (host_info_t)&cpu_load,
+                      &count);
+      if (error != KERN_SUCCESS) {
+        fprintf(stderr, "error 1 %lu\n", (unsigned long) error);
+      }
+      printf("(%d %d %d)\n",
+             cpu_load.cpu_ticks[CPU_STATE_USER],
+             cpu_load.cpu_ticks[CPU_STATE_SYSTEM],
+             cpu_load.cpu_ticks[CPU_STATE_IDLE]);
+
+      task_basic_info_data_t    ti;
+//      count = TASK_EVENTS_INFO_COUNT;
+//      error = task_info(task, TASK_EVENTS_INFO, (task_info_t)&ti, &count);
+      count = TASK_BASIC_INFO_COUNT;
+      error = task_info(task, TASK_BASIC_INFO, (task_info_t)&ti, &count);
+
+      if (error != KERN_SUCCESS) {
+        fprintf(stderr, "error 1 %lu\n", (unsigned long) error);
+      }
+      
+      // TODO: error checking (if renderer turns into a zombie)
+      fprintf(stderr, "mem real %d virtual %d\n", ti.resident_size, ti.virtual_size);
+    } else {
+      fprintf(stderr, "Failed to receive message %lu\n", (unsigned long)result);
+    }
+
     ChromeThread::PostTask(
         client_thread_id_, FROM_HERE,
         NewRunnableMethod(
             this,
             &ChildProcessLauncher::Context::Notify,
 #if defined(OS_LINUX)
             zygote,
 #endif
             handle));
   }
@@ skipping 124 matching lines @@
   if (child_exited)
     context_->process_.Close();
 
   return did_crash;
 }
 
 void ChildProcessLauncher::SetProcessBackgrounded(bool background) {
   DCHECK(!context_->starting_);
   context_->process_.SetProcessBackgrounded(background);
 }