Android content shell bringup.

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 "base/allocator/allocator_extension.h"
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/debug/debugger.h"
@@ skipping 61 matching lines @@
 }
 #endif
 
 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)
+#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
 namespace content {
 extern int ZygoteMain(const content::MainFunctionParams&,
                       content::ZygoteForkDelegate* forkdelegate);
 }  // namespace content
 #endif
 
 namespace {
 
 #if defined(OS_WIN)
 
@@ skipping 94 matching lines @@
   }
 }
 
 // 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 content::MainFunctionParams&);
 };
 
-#if defined(OS_POSIX) && !defined(OS_MACOSX)
+#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
 // 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 content::MainFunctionParams& main_function_params,
               content::ContentMainDelegate* delegate) {
   static const MainFunction kMainFunctions[] = {
     { switches::kRendererProcess,    RendererMain },
     { switches::kWorkerProcess,      WorkerMain },
     { switches::kPpapiPluginProcess, PpapiPluginMain },
@@ skipping 78 matching lines @@
       if (delegate) {
         int exit_code = delegate->RunProcess(process_type,
             main_function_params);
         if (exit_code >= 0)
           return exit_code;
       }
       return kMainFunctions[i].function(main_function_params);
     }
   }
 
-#if defined(OS_POSIX) && !defined(OS_MACOSX)
+#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_ANDROID)
   // Zygote startup is special -- see RunZygote comments above
   // for why we don't use ZygoteMain directly.
   if (process_type == switches::kZygoteProcess)
     return RunZygote(main_function_params, delegate);
 #endif
 
   // If it's a process we don't know about, the embedder should know.
   if (delegate)
     return delegate->RunProcess(process_type, main_function_params);
 
@@ skipping 38 matching lines @@
 
     if (sandbox_info)
       sandbox_info_ = *sandbox_info;
     else
       memset(&sandbox_info_, 0, sizeof(sandbox_info_));
 
 #else  // !OS_WIN
   virtual int Initialize(int argc,
                          const char** argv,
                          content::ContentMainDelegate* delegate) OVERRIDE {
+
     // NOTE(willchan): One might ask why this call is done here rather than in
     // process_util_linux.cc with the definition of
     // EnableTerminationOnOutOfMemory().  That's because base shouldn't have a
     // dependency on TCMalloc.  Really, we ought to have our allocator shim code
     // implement this EnableTerminationOnOutOfMemory() function.  Whateverz.
     // This works for now.
 #if !defined(OS_MACOSX) && defined(USE_TCMALLOC)
     // For tcmalloc, we need to tell it to behave like new.
     tc_set_new_mode(1);
 
     // On windows, we've already set these thunks up in _heap_init()
     base::allocator::SetGetStatsFunction(GetStatsThunk);
     base::allocator::SetReleaseFreeMemoryFunction(ReleaseFreeMemoryThunk);
 #endif
 
 #if !defined(OS_ANDROID)
     // Set C library locale to make sure CommandLine can parse argument values
     // in correct encoding.
+    // Android doesn't support this.
     setlocale(LC_ALL, "");
-#endif
 
+    // On Android, do not override the signal handlers so that we can get stack

[Avi (use Gerrit), 2012/05/09 18:48:28]

This comment and the one below are awkward; you describe what android doesn't do
and then you go and do it. I understand the flow, but can you figure out a
better way of comment them?

[John Grabowski, 2012/05/09 19:03:57]

Tried to clarify.

+    // trace when crashing.
     SetupSignalHandlers();
 
+    // Android passes the ipc_fd through the Java service.
     base::GlobalDescriptors* g_fds = base::GlobalDescriptors::GetInstance();
     g_fds->Set(kPrimaryIPCChannel,
                kPrimaryIPCChannel + base::GlobalDescriptors::kBaseDescriptor);
+#endif
+
 #if defined(OS_LINUX) || defined(OS_OPENBSD)
     g_fds->Set(kCrashDumpSignal,
                kCrashDumpSignal + base::GlobalDescriptors::kBaseDescriptor);
 #endif
 
 #endif  // !OS_WIN
 
     is_initialized_ = true;
     delegate_ = delegate;
 
     base::EnableTerminationOnHeapCorruption();
     base::EnableTerminationOnOutOfMemory();
 
+    // On Android, AtExitManager is set up when library is loaded.
+#if !defined(OS_ANDROID)
     // The exit manager is in charge of calling the dtors of singleton objects.
     exit_manager_.reset(new base::AtExitManager);
+#endif
 
 #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.
+    // (But *is* initialized here for content shell bringup)
+#if !defined(OS_ANDROID) || defined(ANDROID_UPSTREAM_BRINGUP)
     CommandLine::Init(argc, argv);
+#endif
 
     int exit_code;
     if (delegate && delegate->BasicStartupComplete(&exit_code))
       return exit_code;
     DCHECK(!delegate || content::GetContentClient()) <<
         "BasicStartupComplete didn't set the content client";
 
     completed_basic_startup_ = true;
 
     const CommandLine& command_line = *CommandLine::ForCurrentProcess();
@@ skipping 50 matching lines @@
         signal(SIGINT, SIG_IGN);
     }
 #endif
 
 #if defined(USE_NSS)
     crypto::EarlySetupForNSSInit();
 #endif
 
     ui::RegisterPathProvider();
     content::RegisterPathProvider();
+
+    // TODO(jrg): "up to here" is how far we get without crashing on
+    // content shell bringup.
+#if defined(ANDROID_UPSTREAM_BRINGUP)
+    return 0;
+#endif
     content::RegisterContentSchemes(true);
 
     CHECK(icu_util::Initialize());
 
     base::ProcessId browser_pid = base::GetCurrentProcId();
     if (command_line.HasSwitch(switches::kProcessChannelID)) {
 #if defined(OS_WIN) || defined(OS_MACOSX)
       std::string channel_name =
           command_line.GetSwitchValueASCII(switches::kProcessChannelID);
 
@@ skipping 120 matching lines @@
 }  // namespace
 
 namespace content {
 
 // static
 ContentMainRunner* ContentMainRunner::Create() {
   return new ContentMainRunnerImpl();
 }
 
 }  // namespace content