Continue with the FreeBSD port - this version builds and links, though...

chrome/browser/renderer_host/browser_render_process_host.cc

 // Copyright (c) 2006-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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "chrome/browser/renderer_host/browser_render_process_host.h"
 
 #include "build/build_config.h"
@@ skipping 45 matching lines @@
 #include "chrome/common/result_codes.h"
 #include "chrome/renderer/render_process.h"
 #include "chrome/renderer/render_thread.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "grit/generated_resources.h"
 #include "ipc/ipc_switches.h"
 
 #if defined(OS_WIN)
 #include "app/win_util.h"
 #include "chrome/browser/sandbox_policy.h"
-#elif defined(OS_LINUX)
+#elif defined(OS_LINUX) || defined(OS_FREEBSD)
 #include "base/linux_util.h"
 #include "chrome/browser/zygote_host_linux.h"
 #include "chrome/browser/renderer_host/render_crash_handler_host_linux.h"
 #include "chrome/browser/renderer_host/render_sandbox_host_linux.h"
 #endif
 
 using WebKit::WebCache;
 
 #include "third_party/skia/include/core/SkBitmap.h"
 
@@ skipping 154 matching lines @@
 
   // We may have some unsent messages at this point, but that's OK.
   channel_.reset();
 
   // Destroy the AudioRendererHost properly.
   if (audio_renderer_host_.get())
     audio_renderer_host_->Destroy();
 
   if (process_.handle() && !run_renderer_in_process()) {
     if (zygote_child_) {
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(OS_FREEBSD)
       Singleton<ZygoteHost>()->EnsureProcessTerminated(process_.handle());
 #endif
     } else {
       ProcessWatcher::EnsureProcessTerminated(process_.handle());
     }
   }
 
   ClearTransportDIBCache();
 }
 
@@ skipping 138 matching lines @@
   if (run_renderer_in_process()) {
     // Crank up a thread and run the initialization there.  With the way that
     // messages flow between the browser and renderer, this thread is required
     // to prevent a deadlock in single-process mode.  Since the primordial
     // thread in the renderer process runs the WebKit code and can sometimes
     // make blocking calls to the UI thread (i.e. this thread), they need to run
     // on separate threads.
     in_process_renderer_.reset(new RendererMainThread(channel_id));
 
     base::Thread::Options options;
-#if !defined(OS_LINUX)
+#if !defined(USE_X11)
     // In-process plugins require this to be a UI message loop.
     options.message_loop_type = MessageLoop::TYPE_UI;
 #else
-    // We can't have multiple UI loops on Linux, so we don't support
+    // We can't have multiple UI loops on X, so we don't support
     // in-process plugins.
     options.message_loop_type = MessageLoop::TYPE_DEFAULT;
 #endif
     in_process_renderer_->StartWithOptions(options);
   } else {
     base::ProcessHandle process = 0;
 #if defined(OS_WIN)
     process = sandbox::StartProcess(&cmd_line);
 #elif defined(OS_POSIX)
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(OS_FREEBSD)
     if (!has_cmd_prefix) {
       base::GlobalDescriptors::Mapping mapping;
       const int ipcfd = channel_->GetClientFileDescriptor();
       mapping.push_back(std::pair<uint32_t, int>(kPrimaryIPCChannel, ipcfd));
       const int crash_signal_fd =
           Singleton<RenderCrashHandlerHostLinux>()->GetDeathSignalSocket();
       if (crash_signal_fd >= 0) {
         mapping.push_back(std::pair<uint32_t, int>(kCrashDumpSignal,
                                                    crash_signal_fd));
       }
       process = Singleton<ZygoteHost>()->ForkRenderer(cmd_line.argv(), mapping);
       zygote_child_ = true;
     } else {
 #endif  // defined(OS_LINUX)
       // NOTE: This code is duplicated with plugin_process_host.cc, but
       // there's not a good place to de-duplicate it.
       base::file_handle_mapping_vector fds_to_map;
       const int ipcfd = channel_->GetClientFileDescriptor();
       fds_to_map.push_back(std::make_pair(ipcfd, kPrimaryIPCChannel + 3));
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(OS_FREEBSD)
       const int crash_signal_fd =
           Singleton<RenderCrashHandlerHostLinux>()->GetDeathSignalSocket();
       if (crash_signal_fd >= 0) {
         fds_to_map.push_back(std::make_pair(crash_signal_fd,
                                             kCrashDumpSignal + 3));
       }
       const int sandbox_fd =
           Singleton<RenderSandboxHostLinux>()->GetRendererSocket();
       fds_to_map.push_back(std::make_pair(sandbox_fd, kSandboxIPCChannel + 3));
 #endif  // defined(OS_LINUX)
       base::LaunchApp(cmd_line.argv(), fds_to_map, false, &process);
       zygote_child_ = false;
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(OS_FREEBSD)
     }
 #endif  // defined(OS_LINUX)
 #endif  // defined(OS_WIN)
 
     if (!process) {
       channel_.reset();
       return false;
     }
     process_.set_handle(process);
   }
@@ skipping 196 matching lines @@
     TransportDIB::Id dib_id) {
 #if defined(OS_WIN)
   // On Windows we need to duplicate the handle from the remote process
   HANDLE section = win_util::GetSectionFromProcess(
       dib_id.handle, GetRendererProcessHandle(), false /* read write */);
   return TransportDIB::Map(section);
 #elif defined(OS_MACOSX)
   // On OSX, the browser allocates all DIBs and keeps a file descriptor around
   // for each.
   return widget_helper_->MapTransportDIB(dib_id);
-#elif defined(OS_LINUX)
+#elif defined(USE_X11)
   return TransportDIB::Map(dib_id);
-#endif  // defined(OS_LINUX)
+#endif  // defined(USE_X11)
 }
 
 TransportDIB* BrowserRenderProcessHost::GetTransportDIB(
     TransportDIB::Id dib_id) {
   const std::map<TransportDIB::Id, TransportDIB*>::iterator
       i = cached_dibs_.find(dib_id);
   if (i != cached_dibs_.end()) {
     cached_dibs_cleaner_.Reset();
     return i->second;
   }
@@ skipping 132 matching lines @@
 void BrowserRenderProcessHost::OnChannelError() {
   // Our child process has died.  If we didn't expect it, it's a crash.
   // In any case, we need to let everyone know it's gone.
 
   DCHECK(process_.handle());
   DCHECK(channel_.get());
 
   bool child_exited;
   bool did_crash;
   if (zygote_child_) {
-#if defined(OS_LINUX)
+#if defined(OS_LINUX) || defined(OS_FREEBSD)
     did_crash = Singleton<ZygoteHost>()->DidProcessCrash(
         process_.handle(), &child_exited);
 #else
     NOTREACHED();
     did_crash = true;
 #endif
   } else {
     did_crash = base::DidProcessCrash(&child_exited, process_.handle());
   }
 
@@ skipping 129 matching lines @@
     profile()->GetExtensionMessageService()->RemoveEventListener(
         event_name, id());
   }
 }
 
 void BrowserRenderProcessHost::OnExtensionCloseChannel(int port_id) {
   if (profile()->GetExtensionMessageService()) {
     profile()->GetExtensionMessageService()->CloseChannel(port_id);
   }
 }