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)

[Avi (use Gerrit), 2012/05/09 19:57:18]

Not what I meant. On line 401, the comment about how Android works is before the
ifdef, so that people could understand why it was if-ed out. Here you're saying
"disable on android" right before each item that you are calling, and the user
has to look up to see that they're in an ifdef block for it to make sense. Can
you please move your "we don't do this on android" comments to be close to the
ifdef, like you do on line 401, so that it's in a readable flow?

     // Set C library locale to make sure CommandLine can parse argument values
     // in correct encoding.
+    // Disabled on Android where it isn't supported.
     setlocale(LC_ALL, "");
-#endif
 
+    // Disabled on Android. We do not override the signal
+    // handlers so that we can get stack trace when crashing.
     SetupSignalHandlers();
 
+    // Android passes the ipc_fd through the Java service, so the next
+    // lines are disabled as well.
     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