Move content_restriction.h and main_function_params.h to content/public/common, and put them in t...

content/app/content_main.cc

 // Copyright (c) 2011 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/app/content_main.h"
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/debug/debugger.h"
 #include "base/i18n/icu_util.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/stats_table.h"
 #include "base/process_util.h"
 #include "base/stringprintf.h"
 #include "base/string_number_conversions.h"
 #include "content/browser/browser_main.h"
-#include "content/common/main_function_params.h"
 #include "content/common/set_process_title.h"
 #include "content/public/app/content_main_delegate.h"
 #include "content/public/app/startup_helper_win.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"
 #include "content/public/common/sandbox_init.h"
 #include "crypto/nss_util.h"
 #include "ipc/ipc_switches.h"
 #include "ui/base/ui_base_switches.h"
 #include "ui/base/ui_base_paths.h"
 #include "webkit/glue/webkit_glue.h"
 
 #if defined(OS_WIN)
 #include <atlbase.h>
 #include <atlapp.h>
@@ skipping 16 matching lines @@
 #endif
 
 #endif  // OS_POSIX
 
 #if !defined(OS_MACOSX) && defined(USE_TCMALLOC)
 extern "C" {
 int tc_set_new_mode(int mode);
 }
 #endif
 
-extern int GpuMain(const MainFunctionParams&);
-extern int PluginMain(const MainFunctionParams&);
-extern int PpapiPluginMain(const MainFunctionParams&);
-extern int PpapiBrokerMain(const MainFunctionParams&);
-extern int RendererMain(const MainFunctionParams&);
-extern int WorkerMain(const MainFunctionParams&);
-extern int UtilityMain(const MainFunctionParams&);
+extern int GpuMain(const content::MainFunctionParams&);
+extern int PluginMain(const content::MainFunctionParams&);
+extern int PpapiPluginMain(const content::MainFunctionParams&);
+extern int PpapiBrokerMain(const content::MainFunctionParams&);
+extern int RendererMain(const content::MainFunctionParams&);
+extern int WorkerMain(const content::MainFunctionParams&);
+extern int UtilityMain(const content::MainFunctionParams&);
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
-extern int ZygoteMain(const MainFunctionParams&,
+extern int ZygoteMain(const content::MainFunctionParams&,
                       content::ZygoteForkDelegate* forkdelegate);
 #endif
 
 namespace {
 
 #if defined(OS_WIN)
 
 static CAppModule _Module;
 
 #elif defined(OS_MACOSX)
@@ skipping 88 matching lines @@
     base::StatsTable* stats_table = new base::StatsTable(statsfile,
         content::kStatsMaxThreads, content::kStatsMaxCounters);
     base::StatsTable::set_current(stats_table);
   }
 }
 
 // We dispatch to a process-type-specific FooMain() based on a command-line
 // flag.  This struct is used to build a table of (flag, main function) pairs.
 struct MainFunction {
   const char* name;
-  int (*function)(const MainFunctionParams&);
+  int (*function)(const content::MainFunctionParams&);
 };
 
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
 // On platforms that use the zygote, we have a special subset of
 // subprocesses that are launched via the zygote.  This function
 // fills in some process-launching bits around ZygoteMain().
 // Returns the exit code of the subprocess.
-int RunZygote(const MainFunctionParams& main_function_params,
+int RunZygote(const content::MainFunctionParams& main_function_params,
               content::ContentMainDelegate* delegate) {
   static const MainFunction kMainFunctions[] = {
     { switches::kRendererProcess,    RendererMain },
     { switches::kWorkerProcess,      WorkerMain },
     { switches::kPpapiPluginProcess, PpapiPluginMain },
   };
 
   scoped_ptr<content::ZygoteForkDelegate> zygote_fork_delegate;
   if (delegate) zygote_fork_delegate.reset(delegate->ZygoteStarting());
 
@@ skipping 14 matching lines @@
   std::string ua = content::GetContentClient()->GetUserAgent(&custom);
   if (custom) webkit_glue::SetUserAgent(ua, custom);
 
   // The StatsTable must be initialized in each process; we already
   // initialized for the browser process, now we need to initialize
   // within the new processes as well.
   pid_t browser_pid = base::GetParentProcessId(
       base::GetParentProcessId(base::GetCurrentProcId()));
   InitializeStatsTable(browser_pid, command_line);
 
-  MainFunctionParams main_params(command_line);
+  content::MainFunctionParams main_params(command_line);
 
   // Get the new process type from the new command line.
   std::string process_type =
       command_line.GetSwitchValueASCII(switches::kProcessType);
 
   for (size_t i = 0; i < arraysize(kMainFunctions); ++i) {
     if (process_type == kMainFunctions[i].name)
       return kMainFunctions[i].function(main_params);
   }
 
   if (delegate)
     return delegate->RunProcess(process_type, main_params);
 
   NOTREACHED() << "Unknown zygote process type: " << process_type;
   return 1;
 }
 #endif  // defined(OS_POSIX) && !defined(OS_MACOSX)
 
 // Run the FooMain() for a given process type.
 // If |process_type| is empty, runs BrowserMain().
 // Returns the exit code for this process.
-int RunNamedProcessTypeMain(const std::string& process_type,
-                            const MainFunctionParams& main_function_params,
-                            content::ContentMainDelegate* delegate) {
+int RunNamedProcessTypeMain(
+    const std::string& process_type,
+    const content::MainFunctionParams& main_function_params,
+    content::ContentMainDelegate* delegate) {
   static const MainFunction kMainFunctions[] = {
     { "",                            BrowserMain },
     { switches::kRendererProcess,    RendererMain },
     { switches::kPluginProcess,      PluginMain },
     { switches::kWorkerProcess,      WorkerMain },
     { switches::kPpapiPluginProcess, PpapiPluginMain },
     { switches::kPpapiBrokerProcess, PpapiBrokerMain },
     { switches::kUtilityProcess,     UtilityMain },
     { switches::kGpuProcess,         GpuMain },
   };
@@ skipping 171 matching lines @@
     CHECK(content::InitializeSandbox());
   }
 #endif
 
   if (delegate) delegate->SandboxInitialized(process_type);
 
 #if defined(OS_POSIX)
   SetProcessTitleFromCommandLine(argv);
 #endif
 
-  MainFunctionParams main_params(command_line);
+  content::MainFunctionParams main_params(command_line);
 #if defined(OS_WIN)
   main_params.sandbox_info = sandbox_info;
 #elif defined(OS_MACOSX)
   main_params.autorelease_pool = &autorelease_pool;
 #endif
 
   exit_code = RunNamedProcessTypeMain(process_type, main_params, delegate);
 
   if (delegate) delegate->ProcessExiting(process_type);
 
 #if defined(OS_WIN)
 #ifdef _CRTDBG_MAP_ALLOC
   _CrtDumpMemoryLeaks();
 #endif  // _CRTDBG_MAP_ALLOC
 
   _Module.Term();
 #endif  // OS_WIN
 
   return exit_code;
 }
 
 }  // namespace content