Get render_process_host to build on Linux by butchering a bunch of files.

chrome/browser/renderer_host/browser_render_process_host.cc

 // Copyright (c) 2006-2008 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"
+
 #include <algorithm>
 #include <sstream>
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/debug_util.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/shared_memory.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 #include "base/thread.h"
-#include "base/win_util.h"
 #include "chrome/app/result_codes.h"
-#include "chrome/browser/browser.h"
+// #include "chrome/browser/browser.h"

[brettw, 2009/01/21 19:18:50]

Be sure to remove these commented ones.

[brettw, 2009/01/21 19:18:50]

Be sure to remove these commented-out ones.

 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/cache_manager_host.h"
 #include "chrome/browser/extensions/user_script_master.h"
 #include "chrome/browser/history/history.h"
 #include "chrome/browser/plugin_service.h"
 #include "chrome/browser/render_widget_helper.h"
-#include "chrome/browser/render_view_host.h"
 #include "chrome/browser/renderer_security_policy.h"
 #include "chrome/browser/resource_message_filter.h"
-#include "chrome/browser/sandbox_policy.h"
 #include "chrome/browser/spellchecker.h"
 #include "chrome/browser/visitedlink_master.h"
-#include "chrome/browser/tab_contents/web_contents.h"
+// #include "chrome/browser/tab_contents/web_contents.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/debug_flags.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/logging_chrome.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/pref_service.h"
 #include "chrome/common/process_watcher.h"
-#include "chrome/common/win_util.h"
 #include "chrome/renderer/render_process.h"
 #include "net/base/cookie_monster.h"
 #include "net/base/net_util.h"
+
+#if defined(OS_WIN)
+// TODO(port): see comment by the only usage of RenderViewHost in this file.
+#include "chrome/browser/render_view_host.h"
+
+// Once the above TODO is finished, then this block is all Windows-specific
+// files.
+#include "base/win_util.h"
+#include "chrome/browser/sandbox_policy.h"
+#include "chrome/common/win_util.h"
 #include "sandbox/src/sandbox.h"
+#endif
 
 #include "SkBitmap.h"
 
 #include "generated_resources.h"
 
 namespace {
 
 // ----------------------------------------------------------------------------
 
 class RendererMainThread : public base::Thread {
  public:
   explicit RendererMainThread(const std::wstring& channel_id)
       : base::Thread("Chrome_InProcRendererThread"),
         channel_id_(channel_id) {
   }
 
  protected:
   virtual void Init() {
+#if defined(OS_WIN)
     CoInitialize(NULL);
+#endif
 
     bool rv = RenderProcess::GlobalInit(channel_id_);
     DCHECK(rv);
     // It's a little lame to manually set this flag.  But the single process
     // RendererThread will receive the WM_QUIT.  We don't need to assert on
     // this thread, so just force the flag manually.
     // If we want to avoid this, we could create the InProcRendererThread
     // directly with _beginthreadex() rather than using the Thread class.
     base::Thread::SetThreadWasQuitProperly(true);
   }
 
   virtual void CleanUp() {
     RenderProcess::GlobalCleanup();
 
+#if defined(OS_WIN)
     CoUninitialize();
+#endif
   }
 
  private:
   std::wstring channel_id_;
 };
 
 // Used for a View_ID where the renderer has not been attached yet
 const int32 kInvalidViewID = -1;
 
 // Get the path to the renderer executable, which is the same as the
@@ skipping 38 matching lines @@
 
 BrowserRenderProcessHost::~BrowserRenderProcessHost() {
   // Some tests hold BrowserRenderProcessHost in a scoped_ptr, so we must call
   // Unregister here as well as in response to Release().
   Unregister();
 
   // We may have some unsent messages at this point, but that's OK.
   channel_.reset();
 
   if (process_.handle() && !run_renderer_in_process()) {
-    watcher_.StopWatching();
     ProcessWatcher::EnsureProcessTerminated(process_.handle());
   }
 
   profile()->GetPrefs()->RemovePrefObserver(prefs::kBlockPopups, this);
 
   NotificationService::current()->RemoveObserver(this,
       NOTIFY_USER_SCRIPTS_LOADED, NotificationService::AllSources());
 }
 
+// When we're started with the --start-renderers-manually flag, we pop up a
+// modal dialog requesting the user manually start up a renderer.
+// |cmd_line| is the command line to start the renderer with.
+static void RunStartRenderersManuallyDialog(const std::wstring& cmd_line) {
+#if defined(OS_WIN)
+  std::wstring message =
+      L"Please start a renderer process using:\n" + cmd_line;
+
+  // We don't know the owner window for RenderProcessHost and therefore we
+  // pass a NULL HWND argument.
+  win_util::MessageBox(NULL,
+                       message,
+                       switches::kBrowserStartRenderersManually,
+                       MB_OK);
+#else
+  // TODO(port): refactor above code / pop up a message box here.
+  NOTIMPLEMENTED();
+#endif
+}
+
 bool BrowserRenderProcessHost::Init() {
   // calling Init() more than once does nothing, this makes it more convenient
   // for the view host which may not be sure in some cases
   if (channel_.get())
     return true;
 
   // run the IPC channel on the shared IO thread.
   base::Thread* io_thread = g_browser_process->io_thread();
 
   scoped_refptr<ResourceMessageFilter> resource_message_filter =
       new ResourceMessageFilter(g_browser_process->resource_dispatcher_host(),
                                 PluginService::GetInstance(),
                                 g_browser_process->print_job_manager(),
                                 host_id(),
                                 profile(),
                                 widget_helper_,
                                 profile()->GetSpellChecker());
 
   CommandLine browser_command_line;
 
+#if defined(OS_WIN)
   // setup IPC channel
-  std::wstring channel_id = GenerateRandomChannelID(this);
+  const std::wstring channel_id = GenerateRandomChannelID(this);
   channel_.reset(
       new IPC::SyncChannel(channel_id, IPC::Channel::MODE_SERVER, this,
                            resource_message_filter,
                            io_thread->message_loop(), true,
                            g_browser_process->shutdown_event()));
   // As a preventive mesure, we DCHECK if someone sends a synchronous message
   // with no time-out, which in the context of the browser process we should not
   // be doing.
   channel_->set_sync_messages_with_no_timeout_allowed(false);
+#else
+  // TODO(port): this depends on resource_message_filter
+  NOTIMPLEMENTED();
+  io_thread = io_thread;
+  static const std::wstring channel_id = L"set to quiet the compiler";
+#endif
 
   // build command line for renderer, we have to quote the executable name to
   // deal with spaces
   std::wstring renderer_path =
       browser_command_line.GetSwitchValue(switches::kRendererPath);
   if (renderer_path.empty())
     if (!GetRendererPath(&renderer_path))
       return false;
   std::wstring cmd_line;
   cmd_line = L"\"" + renderer_path + L"\"";
@@ skipping 27 matching lines @@
     switches::kMessageLoopHistogrammer,
     switches::kEnableDCHECK,
     switches::kSilentDumpOnDCHECK,
     switches::kDisablePopupBlocking,
     switches::kUseLowFragHeapCrt,
     switches::kGearsInRenderer,
     switches::kEnableUserScripts,
     switches::kEnableVideo,
   };
 
-  for (int i = 0; i < arraysize(switch_names); ++i) {
+  for (size_t i = 0; i < arraysize(switch_names); ++i) {
     if (browser_command_line.HasSwitch(switch_names[i])) {
       CommandLine::AppendSwitchWithValue(
           &cmd_line, switch_names[i],
           browser_command_line.GetSwitchValue(switch_names[i]));
     }
   }
 
   // Pass on the browser locale.
   const std::wstring locale = g_browser_process->GetApplicationLocale();
   CommandLine::AppendSwitchWithValue(&cmd_line, switches::kLang, locale);
 
   bool in_sandbox = !browser_command_line.HasSwitch(switches::kNoSandbox);
   if (browser_command_line.HasSwitch(switches::kInProcessPlugins)) {
     // In process plugins won't work if the sandbox is enabled.
     in_sandbox = false;
   }
 
+#if defined(OS_WIN)
   bool child_needs_help =
       DebugFlags::ProcessDebugFlags(&cmd_line,
                                     DebugFlags::RENDERER,
                                     in_sandbox);
+#endif
   CommandLine::AppendSwitchWithValue(&cmd_line,
                                      switches::kProcessType,
                                      switches::kRendererProcess);
 
   CommandLine::AppendSwitchWithValue(&cmd_line,
                                      switches::kProcessChannelID,
                                      channel_id);
 
   const std::wstring& profile_path =
       browser_command_line.GetSwitchValue(switches::kUserDataDir);
@@ skipping 16 matching lines @@
     //
     // TODO: We should consider how to better cleanup threads on exit.
     base::Thread *render_thread = new RendererMainThread(channel_id);
     base::Thread::Options options;
     options.message_loop_type = MessageLoop::TYPE_IO;
     render_thread->StartWithOptions(options);
   } else {
     if (g_browser_process->local_state() &&
         g_browser_process->local_state()->GetBoolean(
             prefs::kStartRenderersManually)) {
-      std::wstring message =
-        L"Please start a renderer process using:\n" + cmd_line;
-
-      // We don't know the owner window for BrowserRenderProcessHost and therefore we
-      // pass a NULL HWND argument.
-      win_util::MessageBox(NULL,
-                           message,
-                           switches::kBrowserStartRenderersManually,
-                           MB_OK);
+      RunStartRenderersManuallyDialog(cmd_line);
     } else {
+#if defined(OS_WIN)
       if (in_sandbox) {
         // spawn the child process in the sandbox
         sandbox::BrokerServices* broker_service =
             g_browser_process->broker_services();
 
         sandbox::ResultCode result;
         PROCESS_INFORMATION target = {0};
         sandbox::TargetPolicy* policy = broker_service->CreatePolicy();
         policy->SetJobLevel(sandbox::JOB_LOCKDOWN, 0);
 
@@ skipping 50 matching lines @@
             Details<bool>(&on_sandbox_desktop));
 
         ResumeThread(target.hThread);
         CloseHandle(target.hThread);
         process_.set_handle(target.hProcess);
 
         // Help the process a little. It can't start the debugger by itself if
         // the process is in a sandbox.
         if (child_needs_help)
             DebugUtil::SpawnDebuggerOnProcess(target.dwProcessId);
-      } else {
+      } else
+#endif  // OS_WIN and sandbox
+      {
         // spawn child process
-        HANDLE process;
+        base::ProcessHandle process = 0;
+        // TODO(port): LaunchApp is actually no good on POSIX when
+        // we've constructed the command line as we have here, as the above
+        // calls all append to a single string while LaunchApp reaches in to
+        // the argv array.  CommandLine should be fixed, but once it is, this
+        // code will be correct.
         if (!base::LaunchApp(cmd_line, false, false, &process))
           return false;
         process_.set_handle(process);
       }
-
-      watcher_.StartWatching(process_.handle(), this);
     }
   }
 
   // Now that the process is created, set it's backgrounding accordingly.
   SetBackgrounded(backgrounded_);
 
   InitVisitedLinks();
   InitUserScripts();
 
   if (max_page_id_ != -1)
@@ skipping 113 matching lines @@
     channel_->Send(new ViewMsg_UserScripts_NewScripts(handle_for_process));
   }
 }
 
 bool BrowserRenderProcessHost::FastShutdownIfPossible() {
   if (!process_.handle())
     return false;  // Render process is probably crashed.
   if (BrowserRenderProcessHost::run_renderer_in_process())
     return false;  // Since process mode can't do fast shutdown.
 
+#if defined(OS_WIN)
   // Test if there's an unload listener
   BrowserRenderProcessHost::listeners_iterator iter;
   // NOTE: This is a bit dangerous.  We know that for now, listeners are
   // always RenderWidgetHosts.  But in theory, they don't have to be.
   for (iter = listeners_begin(); iter != listeners_end(); ++iter) {
     RenderWidgetHost* widget = static_cast<RenderWidgetHost*>(iter->second);
     DCHECK(widget);
     if (!widget || !widget->IsRenderView())
       continue;
     RenderViewHost* rvh = static_cast<RenderViewHost*>(widget);
     if (!rvh->CanTerminate()) {
       // NOTE: It's possible that an onunload listener may be installed
       // while we're shutting down, so there's a small race here.  Given that
       // the window is small, it's unlikely that the web page has much
       // state that will be lost by not calling its unload handlers properly.
       return false;
     }
   }
+#else
+  // TODO(port): the above is the only reason this file pulls in
+  // RenderWidgetHost and RenderViewHost.
+  // Perhaps IPC::Channel::Listener needs another method like CanTerminate()?
+  // No matter what, some abstractions are getting broken here...
+  NOTIMPLEMENTED();
+#endif
 
   // Otherwise, we're allowed to just terminate the process. Using exit code 0
   // means that UMA won't treat this as a renderer crash.
   process_.Terminate(ResultCodes::NORMAL_EXIT);
   return true;
 }
 
 bool BrowserRenderProcessHost::Send(IPC::Message* msg) {
   if (!channel_.get()) {
     delete msg;
@@ skipping 32 matching lines @@
       Send(reply);
     }
     return;
   }
   listener->OnMessageReceived(msg);
 }
 
 void BrowserRenderProcessHost::OnChannelConnected(int32 peer_pid) {
   // process_ is not NULL if we created the renderer process
   if (!process_.handle()) {
-    if (GetCurrentProcessId() == peer_pid) {
+    if (base::GetCurrentProcId() == peer_pid) {
       // We are in single-process mode. In theory we should have access to
       // ourself but it may happen that we don't.
-      process_.set_handle(GetCurrentProcess());
+      process_.set_handle(base::GetCurrentProcessHandle());
     } else {
+#if defined(OS_WIN)
       // Request MAXIMUM_ALLOWED to match the access a handle
       // returned by CreateProcess() has to the process object.
       process_.set_handle(OpenProcess(MAXIMUM_ALLOWED, FALSE, peer_pid));
+#elif defined(OS_POSIX)
+      // ProcessHandle is just a pid.
+      process_.set_handle(peer_pid);
+#endif
       DCHECK(process_.handle());
-      watcher_.StartWatching(process_.handle(), this);
     }
   } else {
     // Need to verify that the peer_pid is actually the process we know, if
     // it is not, we need to panic now. See bug 1002150.
     CHECK(peer_pid == process_.pid());
   }
 }
 
-// Static. This function can be called from the IO Thread or from the UI thread.
-void BrowserRenderProcessHost::BadMessageTerminateProcess(uint16 msg_type,
-                                                          HANDLE process) {
-  LOG(ERROR) << "bad message " << msg_type << " terminating renderer.";
-  if (BrowserRenderProcessHost::run_renderer_in_process()) {
-    // In single process mode it is better if we don't suicide but just crash.
-    CHECK(false);
-  }
-  NOTREACHED();
-  ::TerminateProcess(process, ResultCodes::KILLED_BAD_MESSAGE);
-}
+void RenderProcessHost::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.
 
-// indicates the renderer process has exited
-void BrowserRenderProcessHost::OnObjectSignaled(HANDLE object) {
   DCHECK(process_.handle());
   DCHECK(channel_.get());
-  DCHECK_EQ(object, process_.handle());
+  base::ProcessHandle process = process_.handle();
 
-  bool clean_shutdown = !base::DidProcessCrash(object);
+  bool clean_shutdown = !base::DidProcessCrash(process);
 
   process_.Close();
 
   channel_.reset();
 
   if (!notified_termination_) {
     // If |close_expected| is false, it means the renderer process went away
     // before the web views expected it; count it as a crash.
     NotificationService::current()->Notify(NOTIFY_RENDERER_PROCESS_TERMINATED,
                                            Source<RenderProcessHost>(this),
                                            Details<bool>(&clean_shutdown));
     notified_termination_ = true;
   }
 
   // This process should detach all the listeners, causing the object to be
   // deleted. We therefore need a stack copy of the web view list to avoid
   // crashing when checking for the termination condition the last time.
   IDMap<IPC::Channel::Listener> local_listeners(listeners_);
-  for (IDMap<IPC::Channel::Listener>::const_iterator i = local_listeners.begin();
+  for (listeners_iterator i = local_listeners.begin();
        i != local_listeners.end(); ++i) {
     i->second->OnMessageReceived(ViewHostMsg_RendererGone(i->first));
   }
   // at this point, this object should be deleted
 }
 
 void BrowserRenderProcessHost::Unregister() {
   // RenderProcessHost::Unregister will clean up the host_id_, so we must
   // do our cleanup that uses that variable before we call it.
   if (host_id() >= 0) {
@@ skipping 75 matching lines @@
         SendUserScriptsUpdate(shared_memory);
       }
       break;
     }
     default: {
       NOTREACHED();
       break;
     }
   }
 }
+
+std::wstring GenerateRandomChannelID(void* instance) {
+  // Note: the string must start with the current process id, this is how
+  // child processes determine the pid of the parent.
+  // Build the channel ID.  This is composed of a unique identifier for the
+  // parent browser process, an identifier for the renderer/plugin instance,
+  // and a random component. We use a random component so that a hacked child
+  // process can't cause denial of service by causing future named pipe creation
+  // to fail.
+  return StringPrintf(L"%d.%x.%d",
+                      base::GetCurrentProcId(), instance,
+                      base::RandInt(0, std::numeric_limits<int>::max()));
+}