Created a new process type called the service process to host background task...

chrome/app/chrome_dll_main.cc

 // Copyright (c) 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.
 
 // 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"
@@ skipping 85 matching lines @@
 extern int GpuMain(const MainFunctionParams&);
 extern int PluginMain(const MainFunctionParams&);
 extern int WorkerMain(const MainFunctionParams&);
 extern int NaClMain(const MainFunctionParams&);
 extern int UtilityMain(const MainFunctionParams&);
 extern int ProfileImportMain(const MainFunctionParams&);
 extern int ZygoteMain(const MainFunctionParams&);
 #if defined(_WIN64)
 extern int NaClBrokerMain(const MainFunctionParams&);
 #endif
+extern int ServiceProcessMain(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 140 matching lines @@
 
 static void AdjustLinuxOOMScore(const std::string& process_type) {
   const int kMiscScore = 7;
   const int kPluginScore = 10;
   int score = -1;
 
   if (process_type == switches::kPluginProcess) {
     score = kPluginScore;
   } else if (process_type == switches::kUtilityProcess ||
              process_type == switches::kWorkerProcess ||
-             process_type == switches::kGpuProcess) {
+             process_type == switches::kGpuProcess ||
+             process_type == switches::kServiceProcess) {
     score = kMiscScore;
   } else if (process_type == switches::kProfileImportProcess) {
     NOTIMPLEMENTED();
 #ifndef DISABLE_NACL
   } else if (process_type == switches::kNaClLoaderProcess) {
     score = kPluginScore;
 #endif
   } else if (process_type == switches::kZygoteProcess ||
              process_type.empty()) {
     // Pass - browser / zygote process stays at 0.
@@ skipping 83 matching lines @@
 #endif
 #if defined(OS_POSIX) && !defined(OS_MACOSX)
       // The zygote process opens the resources for the renderers.
       process_type == switches::kZygoteProcess ||
 #endif
       process_type == switches::kRendererProcess ||
       process_type == switches::kExtensionProcess ||
       process_type == switches::kUtilityProcess;
 }
 
+// Returns true if this process is a child of the browser process.
+bool SubprocessIsBrowserChild(const std::string& process_type) {
+  if (process_type.empty() || process_type == switches::kServiceProcess) {
+    return false;
+  }
+  return true;
+}
+
 #if defined(OS_MACOSX)
 // Update the name shown in Activity Monitor so users are less likely to ask
 // why Chrome has so many processes.
 void SetMacProcessName(const std::string& process_type) {
   // Don't worry about the browser process, its gets the stock name.
   int name_id = 0;
   if (process_type == switches::kRendererProcess) {
     name_id = IDS_RENDERER_APP_NAME;
   } else if (process_type == switches::kPluginProcess) {
     name_id = IDS_PLUGIN_APP_NAME;
@@ skipping 126 matching lines @@
   if (parsed_command_line.HasSwitch(switches::kEnableNaCl)) {
     // NaCl currently requires two flags to run
     CommandLine* singleton_command_line = CommandLine::ForCurrentProcess();
     singleton_command_line->AppendSwitch(switches::kInternalNaCl);
     singleton_command_line->AppendSwitch(switches::kEnableGPUPlugin);
   }
 
   base::ProcessId browser_pid;
   if (process_type.empty()) {
     browser_pid = base::GetCurrentProcId();
-  } else {
+  } else if (SubprocessIsBrowserChild(process_type)) {
 #if defined(OS_WIN)
     std::wstring channel_name =
       parsed_command_line.GetSwitchValue(switches::kProcessChannelID);
 
     browser_pid =
         static_cast<base::ProcessId>(StringToInt(WideToASCII(channel_name)));
     DCHECK_NE(browser_pid, 0);
 #else
     browser_pid = base::GetCurrentProcId();
 #endif
@@ skipping 246 matching lines @@
 #endif
       } else {
         NOTREACHED() << "Unknown process type";
       }
     } else {
       rv = 0;
     }
 #else
     NOTIMPLEMENTED();
 #endif
+  } else if (process_type == switches::kServiceProcess) {
+    rv = ServiceProcessMain(main_params);
   } else if (process_type.empty()) {
 #if defined(OS_LINUX)
     const char* sandbox_binary = NULL;
     struct stat st;
 
     // In Chromium branded builds, developers can set an environment variable to
     // use the development sandbox. See
     // http://code.google.com/p/chromium/wiki/LinuxSUIDSandboxDevelopment
     if (stat("/proc/self/exe", &st) == 0 && st.st_uid == getuid())
       sandbox_binary = getenv("CHROME_DEVEL_SANDBOX");
@@ skipping 48 matching lines @@
 
 #if defined(OS_MACOSX) && defined(GOOGLE_CHROME_BUILD)
   // TODO(mark): See the TODO(mark) above at InitCrashReporter.
   DestructCrashReporter();
 #endif  // OS_MACOSX && GOOGLE_CHROME_BUILD
 
   TRACE_EVENT_END("chrome.main", NULL, "");
 
   return rv;
 }