Convert ContentMain to take a struct instead of parameters that vary depending on the platform.

content/app/content_main_runner.cc

 // Copyright (c) 2012 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 "content/public/app/content_main_runner.h"
 
 #include <stdlib.h>
 
 #include "base/allocator/allocator_extension.h"
 #include "base/at_exit.h"
@@ skipping 12 matching lines @@
 #include "base/process/process_handle.h"
 #include "base/profiler/alternate_timer.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "content/browser/browser_main.h"
 #include "content/browser/gpu/gpu_process_host.h"
 #include "content/common/set_process_title.h"
 #include "content/common/url_schemes.h"
 #include "content/gpu/in_process_gpu_thread.h"
+#include "content/public/app/content_main.h"
 #include "content/public/app/content_main_delegate.h"
 #include "content/public/app/startup_helper_win.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/utility_process_host.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_constants.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/main_function_params.h"
@@ skipping 483 matching lines @@
 
   static void GetStatsThunk(char* buffer, int buffer_length) {
     MallocExtension::instance()->GetStats(buffer, buffer_length);
   }
 
   static void ReleaseFreeMemoryThunk() {
     MallocExtension::instance()->ReleaseFreeMemory();
   }
 #endif
 
-#if defined(OS_WIN)
-  virtual int Initialize(HINSTANCE instance,
-                         sandbox::SandboxInterfaceInfo* sandbox_info,
-                         ContentMainDelegate* delegate) OVERRIDE {
-    // argc/argv are ignored on Windows; see command_line.h for details.
-    int argc = 0;
-    char** argv = NULL;
+  virtual int Initialize(const ContentMainParams& params) OVERRIDE {
+#if defined(OS_WIN)   
+    RegisterInvalidParamHandler();
+    _Module.Init(NULL, static_cast<HINSTANCE>(params.instance));
 
-    RegisterInvalidParamHandler();
-    _Module.Init(NULL, static_cast<HINSTANCE>(instance));
-
-    sandbox_info_ = *sandbox_info;
+    sandbox_info_ = *params.sandbox_info;
 #else  // !OS_WIN
-  virtual int Initialize(int argc,
-                         const char** argv,
-                         ContentMainDelegate* delegate) OVERRIDE {
 
 #if defined(OS_ANDROID)
     // See note at the initialization of ExitManager, below; basically,
     // only Android builds have the ctor/dtor handlers set up to use
     // TRACE_EVENT right away.
     TRACE_EVENT0("startup", "ContentMainRunnerImpl::Initialize");
 #endif  // OS_ANDROID
 
     // NOTE(willchan): One might ask why these TCMalloc-related calls are done
     // here rather than in process_util_linux.cc with the definition of
@@ skipping 49 matching lines @@
 #endif  // !OS_ANDROID && !OS_IOS
 
 #if defined(OS_LINUX) || defined(OS_OPENBSD)
     g_fds->Set(kCrashDumpSignal,
                kCrashDumpSignal + base::GlobalDescriptors::kBaseDescriptor);
 #endif
 
 #endif  // !OS_WIN
 
     is_initialized_ = true;
-    delegate_ = delegate;
+    delegate_ = params.delegate;
 
     base::EnableTerminationOnHeapCorruption();
     base::EnableTerminationOnOutOfMemory();
 
     // The exit manager is in charge of calling the dtors of singleton objects.
     // On Android, AtExitManager is set up when library is loaded.
     // On iOS, it's set up in main(), which can't call directly through to here.
     // A consequence of this is that you can't use the ctor/dtor-based
     // TRACE_EVENT methods on Linux or iOS builds till after we set this up.
 #if !defined(OS_ANDROID) && !defined(OS_IOS)
     exit_manager_.reset(new base::AtExitManager);
 #endif  // !OS_ANDROID && !OS_IOS
 
 #if defined(OS_MACOSX)
     // We need this pool for all the objects created before we get to the
     // event loop, but we don't want to leave them hanging around until the
     // app quits. Each "main" needs to flush this pool right before it goes into
     // its main event loop to get rid of the cruft.
     autorelease_pool_.reset(new base::mac::ScopedNSAutoreleasePool());
 #endif
 
     // On Android, the command line is initialized when library is loaded and
     // we have already started our TRACE_EVENT0.
 #if !defined(OS_ANDROID)
+    // argc/argv are ignored on Windows and Android; see command_line.h for
+    // details.
+    int argc = 0;
+    const char** argv = NULL;
+
+#if !defined(OS_WIN)
+    argc = params.argc;
+    argv = params.argv;
+#endif
+
     CommandLine::Init(argc, argv);
+
+#if !defined(OS_IOS)
+    SetProcessTitleFromCommandLine(argv);
+#endif
 #endif // !OS_ANDROID
 
     int exit_code;
-    if (delegate && delegate->BasicStartupComplete(&exit_code))
+    if (delegate_ && delegate_->BasicStartupComplete(&exit_code))
       return exit_code;
 
     completed_basic_startup_ = true;
 
     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
     std::string process_type =
         command_line.GetSwitchValueASCII(switches::kProcessType);
 
     if (!GetContentClient())
       SetContentClient(&empty_content_client_);
@@ skipping 21 matching lines @@
     // management setup to be completed.
     TRACE_EVENT0("startup", "ContentMainRunnerImpl::Initialize");
 #endif // !OS_ANDROID
 
 #if defined(OS_MACOSX) && !defined(OS_IOS)
     // We need to allocate the IO Ports before the Sandbox is initialized or
     // the first instance of PowerMonitor is created.
     // It's important not to allocate the ports for processes which don't
     // register with the power monitor - see crbug.com/88867.
     if (process_type.empty() ||
-        (delegate &&
-         delegate->ProcessRegistersWithSystemProcess(process_type))) {
+        (delegate_ &&
+         delegate_->ProcessRegistersWithSystemProcess(process_type))) {
       base::PowerMonitorDeviceSource::AllocateSystemIOPorts();
     }
 
     if (!process_type.empty() &&
-        (!delegate || delegate->ShouldSendMachPort(process_type))) {
+        (!delegate_ || delegate_->ShouldSendMachPort(process_type))) {
       MachBroker::ChildSendTaskPortToParent();
     }
 #elif defined(OS_WIN)
     if (command_line.HasSwitch(switches::kEnableHighResolutionTime))
       base::TimeTicks::SetNowIsHighResNowIfSupported();
 
     // This must be done early enough since some helper functions like
     // IsTouchEnabled, needed to load resources, may call into the theme dll.
     EnableThemeSupportOnAllWindowStations();
     SetupCRT(command_line);
@@ skipping 22 matching lines @@
 #endif
 
     ui::RegisterPathProvider();
     RegisterPathProvider();
     RegisterContentSchemes(true);
 
     CHECK(base::i18n::InitializeICU());
 
     InitializeStatsTable(command_line);
 
-    if (delegate)
-      delegate->PreSandboxStartup();
+    if (delegate_)
+      delegate_->PreSandboxStartup();
 
     // Set any custom user agent passed on the command line now so the string
     // doesn't change between calls to webkit_glue::GetUserAgent(), otherwise it
     // defaults to the user agent set during SetContentClient().
     if (command_line.HasSwitch(switches::kUserAgent)) {
       webkit_glue::SetUserAgent(
           command_line.GetSwitchValueASCII(switches::kUserAgent));
     }
 
     if (!process_type.empty())
       CommonSubprocessInit(process_type);
 
 #if defined(OS_WIN)
-    CHECK(InitializeSandbox(sandbox_info));
+    CHECK(InitializeSandbox(params.sandbox_info));
 #elif defined(OS_MACOSX) && !defined(OS_IOS)
     if (process_type == switches::kRendererProcess ||
         process_type == switches::kPpapiPluginProcess ||
-        (delegate && delegate->DelaySandboxInitialization(process_type))) {
+        (delegate_ && delegate_->DelaySandboxInitialization(process_type))) {
       // On OS X the renderer sandbox needs to be initialized later in the
       // startup sequence in RendererMainPlatformDelegate::EnableSandbox().
     } else {
       CHECK(InitializeSandbox());
     }
 #endif
 
-    if (delegate)
-      delegate->SandboxInitialized(process_type);
-
-#if defined(OS_POSIX) && !defined(OS_IOS)
-    SetProcessTitleFromCommandLine(argv);
-#endif
+    if (delegate_)
+      delegate_->SandboxInitialized(process_type);
 
     // Return -1 to indicate no early termination.
     return -1;
   }
 
   virtual int Run() OVERRIDE {
     DCHECK(is_initialized_);
     DCHECK(!is_shutdown_);
     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
     std::string process_type =
@@ skipping 68 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(ContentMainRunnerImpl);
 };
 
 // static
 ContentMainRunner* ContentMainRunner::Create() {
   return new ContentMainRunnerImpl();
 }
 
 }  // namespace content