remove chrome dependencies from win sandboxing headers.

chrome/app/chrome_dll_main.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.
 
 // TODO(port): the ifdefs in here are a first step towards trying to determine
 // the correct abstraction for all the OS functionality required at this
 // stage of process initialization. It should not be taken as a final 
 // abstraction. 
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <atlbase.h>
 #include <atlapp.h>
 #include <malloc.h>
 #include <new.h>
-#elif defined(OS_MACOSX)
-extern "C" {
-#include <sandbox.h>
-}
 #endif
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/icu_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/stats_table.h"
 #include "base/string_util.h"
 #if defined(OS_WIN)
 #include "base/win_util.h"
 #include "chrome/browser/render_process_host.h"
 #endif
+#include "chrome/app/scoped_ole_initializer.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_counters.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/logging_chrome.h"
+#include "chrome/common/main_function_params.h"
 #if defined(OS_WIN)
 #include "chrome/common/resource_bundle.h"
 #endif
+#include "chrome/common/sandbox_init_wrapper.h"
+#if defined(OS_WIN)
 #include "sandbox/src/sandbox.h"
-#if defined(OS_WIN)
 #include "tools/memory_watcher/memory_watcher.h"
 #endif
 
-extern int BrowserMain(CommandLine&, sandbox::BrokerServices*);
-extern int RendererMain(CommandLine&, sandbox::TargetServices*);
-extern int PluginMain(CommandLine&, sandbox::TargetServices*);
+extern int BrowserMain(const MainFunctionParams&);
+extern int RendererMain(const MainFunctionParams&);
+extern int PluginMain(const MainFunctionParams&);
 
 #if defined(OS_WIN)
 // TODO(erikkay): isn't this already defined somewhere?
 #define DLLEXPORT __declspec(dllexport)
 
 // We use extern C for the prototype DLLEXPORT to avoid C++ name mangling.
 extern "C" {
 DLLEXPORT int __cdecl ChromeMain(HINSTANCE instance,
                                  sandbox::SandboxInterfaceInfo* sandbox_info,
                                  TCHAR* command_line);
@@ skipping 47 matching lines @@
   DumpProcessFunction DumpProcess = reinterpret_cast<DumpProcessFunction>(
       ::GetProcAddress(::GetModuleHandle(L"chrome.exe"), "DumpProcess"));
   if (DumpProcess)
     DumpProcess();
 }
 
 #pragma optimize("", on)
 
 #endif  // OS_WIN
 
-// Called before/after the call to BrowseMain() to handle platform-specific
-// setup/teardown.
-void PreBrowserMain() {
-#if defined(OS_WIN)
-  int ole_result = OleInitialize(NULL);
-  DCHECK(ole_result == S_OK);
-#endif
-}
-
-void PostBrowserMain() {
-#if defined(OS_WIN)
-  OleUninitialize();
-#endif
-}
-
 // Register the invalid param handler and pure call handler to be able to
 // notify breakpad when it happens.
 void RegisterInvalidParamHandler() {
 #if defined(OS_WIN)
   _set_invalid_parameter_handler(InvalidParameter);
   _set_purecall_handler(PureCall);
   // Gather allocation failure.
   _set_new_handler(&OnNoMemory);
   // Make sure malloc() calls the new handler too.
   _set_new_mode(1);
@@ skipping 30 matching lines @@
 // Enable the heap profiler if the appropriate command-line switch is
 // present, bailing out of the app we can't.
 void EnableHeapProfiler(const CommandLine& parsed_command_line) {
 #if defined(OS_WIN)
   if (parsed_command_line.HasSwitch(switches::kMemoryProfiling))
     if (!LoadMemoryProfiler())
       exit(-1);
 #endif
 }
 
-// Checks if the sandbox is enabled in this process and initializes it if this
-// is the case. Sandboxing is only valid on render and plugin processes. It's
-// meaningless for the browser process.
-void InitializeSandbox(const CommandLine& parsed_command_line,
-                       const std::wstring process_type,
-                       sandbox::BrokerServices* broker_services,
-                       sandbox::TargetServices* target_services) {
-  if (target_services && !parsed_command_line.HasSwitch(switches::kNoSandbox)) {
-    if ((process_type == switches::kRendererProcess) ||
-        (process_type == switches::kPluginProcess &&
-         parsed_command_line.HasSwitch(switches::kSafePlugins))) {
-#if defined(OS_WIN)
-      target_services->Init();
-#elif defined(OS_MACOSX)
-      // TODO(pinkerton): note, this leaks |error_buff|. What do we want to
-      // do with the error? Pass it back to main?
-      char* error_buff;
-      int error = sandbox_init(kSBXProfilePureComputation, SANDBOX_NAMED,
-                               &error_buff);
-      if (error)
-        exit(-1);
-#endif
-    }
-  }  
-}
-
 void CommonSubprocessInit() {
 #if defined(OS_WIN)
   // Initialize ResourceBundle which handles files loaded from external
   // sources.  The language should have been passed in to us from the
   // browser process as a command line flag.
   // TODO(port): enable when we figure out resource bundle issues
   ResourceBundle::InitSharedInstance(std::wstring());
 
   // HACK: Let Windows know that we have started.  This is needed to suppress
   // the IDC_APPSTARTING cursor from being displayed for a prolonged period
@@ skipping 48 matching lines @@
 
   // Enable the heap profiler as early as possible!
   EnableHeapProfiler(parsed_command_line);
 
   // Enable Message Loop related state asap.
   if (parsed_command_line.HasSwitch(switches::kMessageLoopHistogrammer))
     MessageLoop::EnableHistogrammer(true);
 
   std::wstring process_type =
     parsed_command_line.GetSwitchValue(switches::kProcessType);
-    
-  sandbox::BrokerServices* broker_services = NULL;
-  sandbox::TargetServices* target_services = NULL;
-#if defined(OS_WIN)
-  if (sandbox_info) {
-    target_services = sandbox_info->target_services;
-    broker_services = sandbox_info->broker_services;
-  }
-#endif
-
+  
   // Checks if the sandbox is enabled in this process and initializes it if this
   // is the case. The crash handler depends on this so it has to be done before
   // its initialization.
-  InitializeSandbox(parsed_command_line, process_type, broker_services,
-                    target_services);
-
+  SandboxInitWrapper sandbox_wrapper;
+#if defined(OS_WIN)
+  sandbox_wrapper.SetServices(sandbox_info);
+#endif
+  sandbox_wrapper.InitializeSandbox(parsed_command_line, process_type);
+  
 #if defined(OS_WIN)
   _Module.Init(NULL, instance);
 #endif
 
   // Notice a user data directory override if any
   const std::wstring user_data_dir =
       parsed_command_line.GetSwitchValue(switches::kUserDataDir);
   if (!user_data_dir.empty())
     PathService::Override(chrome::DIR_USER_DATA, user_data_dir);
 
@@ skipping 23 matching lines @@
     logging::SetLogAssertHandler(ChromeAssert);
 #endif
   }
 #endif  // NDEBUG
 
   if (!process_type.empty())
     CommonSubprocessInit();
 
   startup_timer.Stop();  // End of Startup Time Measurement.
 
+  MainFunctionParams main_params(parsed_command_line, sandbox_wrapper);
+  
   // TODO(port): turn on these main() functions as they've been de-winified.
   int rv = -1;
   if (process_type == switches::kRendererProcess) {
 #if defined(OS_WIN)
-    rv = RendererMain(parsed_command_line, target_services);
+    rv = RendererMain(main_params);
 #endif
   } else if (process_type == switches::kPluginProcess) {
 #if defined(OS_WIN)
-    rv = PluginMain(parsed_command_line, target_services);
+    rv = PluginMain(main_params);
 #endif
   } else if (process_type.empty()) {
-    PreBrowserMain();
-    rv = BrowserMain(parsed_command_line, broker_services);
-    PostBrowserMain();
+    ScopedOleInitializer ole_initializer;
+    rv = BrowserMain(main_params);
   } else {
     NOTREACHED() << "Unknown process type";
   }
 
   // TODO(pinkerton): nothing after this point will be hit on Mac if this is the
   // browser process, as NSApplicationMain doesn't return. There are a couple of
   // possible solutions, including breaking this up into pre/post code (won't
   // work for stack-based objects) or making sure we fall out of the runloop
   // ourselves, then manually call |-NSApp terminate:|. We'll most likely 
   // need to do the latter.
@@ skipping 12 matching lines @@
 
   _Module.Term();
 #endif
 
   logging::CleanupChromeLogging();
 
   return rv;
 }