Minimal if-def changes for OS_IOS in browser_main_loop.*

content/browser/browser_main_loop.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/browser/browser_main_loop.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/hi_res_timer_manager.h"
@@ skipping 278 matching lines @@
 #endif
 
   if (parsed_command_line_.HasSwitch(switches::kEnableSSLCachedInfo))
     net::SSLConfigService::EnableCachedInfo();
 
   // TODO(abarth): Should this move to InitializeNetworkOptions?  This doesn't
   // seem dependent on SSL initialization().
   if (parsed_command_line_.HasSwitch(switches::kEnableTcpFastOpen))
     net::set_tcp_fastopen_enabled(true);
 
+#if !defined(OS_IOS)
   if (parsed_command_line_.HasSwitch(switches::kRendererProcessLimit)) {
     std::string limit_string = parsed_command_line_.GetSwitchValueASCII(
         switches::kRendererProcessLimit);
     size_t process_limit;
     if (base::StringToSizeT(limit_string, &process_limit)) {
       content::RenderProcessHost::SetMaxRendererProcessCount(process_limit);
     }
   }
+#endif  // !defined(OS_IOS)
 
   if (parts_.get())
     parts_->PostEarlyInitialization();
 }
 
 void BrowserMainLoop::MainMessageLoopStart() {
   if (parts_.get())
     parts_->PreMainMessageLoopStart();
 
 #if defined(OS_WIN)
   // If we're running tests (ui_task is non-null), then the ResourceBundle
   // has already been initialized.
   if (!parameters_.ui_task) {
     // Override the configured locale with the user's preferred UI language.
     l10n_util::OverrideLocaleWithUILanguageList();
   }
 #endif
 
   // Create a MessageLoop if one does not already exist for the current thread.
   if (!MessageLoop::current())
     main_message_loop_.reset(new MessageLoop(MessageLoop::TYPE_UI));
 
   InitializeMainThread();
 
+  system_monitor_.reset(new base::SystemMonitor);
+  hi_res_timer_manager_.reset(new HighResolutionTimerManager);
+  network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
+  audio_manager_.reset(media::AudioManager::Create());
+
+#if !defined(OS_IOS)
   // Start tracing to a file if needed.
   if (base::debug::TraceLog::GetInstance()->IsEnabled()) {
     TraceControllerImpl::GetInstance()->InitStartupTracing(
         parsed_command_line_);
   }
 
-  system_monitor_.reset(new base::SystemMonitor);
-  hi_res_timer_manager_.reset(new HighResolutionTimerManager);
-  network_change_notifier_.reset(net::NetworkChangeNotifier::Create());
-  audio_manager_.reset(media::AudioManager::Create());
   online_state_observer_.reset(new BrowserOnlineStateObserver);
   scoped_refptr<media_stream::AudioInputDeviceManager>
       audio_input_device_manager(
           new media_stream::AudioInputDeviceManager(audio_manager_.get()));
   scoped_refptr<media_stream::VideoCaptureManager> video_capture_manager(
       new media_stream::VideoCaptureManager());
   media_stream_manager_.reset(new media_stream::MediaStreamManager(
       audio_input_device_manager, video_capture_manager));
 
-#if defined(OS_WIN)
-  system_message_window_.reset(new SystemMessageWindowWin);
-#endif
-
   // Prior to any processing happening on the io thread, we create the
   // plugin service as it is predominantly used from the io thread,
   // but must be created on the main thread. The service ctor is
   // inexpensive and does not invoke the io_thread() accessor.
   PluginService::GetInstance()->Init();
+#endif  // !defined(OS_IOS)
+
+#if defined(OS_WIN)
+  system_message_window_.reset(new SystemMessageWindowWin);
+#endif
 
   if (parts_.get())
     parts_->PostMainMessageLoopStart();
 }
 
 void BrowserMainLoop::CreateThreads() {
   if (parts_.get())
     result_code_ = parts_->PreCreateThreads();
 
   if (result_code_ > 0)
@@ skipping 52 matching lines @@
       case BrowserThread::UI:
       case BrowserThread::ID_COUNT:
       default:
         NOTREACHED();
         break;
     }
 
     BrowserThread::ID id = static_cast<BrowserThread::ID>(thread_id);
 
     if (thread_id == BrowserThread::WEBKIT_DEPRECATED) {
+#if !defined(OS_IOS)
       webkit_thread_.reset(new WebKitThread);
       webkit_thread_->Initialize();
+#endif
     } else if (thread_to_start) {
       (*thread_to_start).reset(new BrowserProcessSubThread(id));
       (*thread_to_start)->StartWithOptions(*options);
     } else {
       NOTREACHED();
     }
   }
 
   BrowserThreadsStarted();
 
   if (parts_.get())
     parts_->PreMainMessageLoopRun();
 
+#if !defined(OS_IOS)
   // When running the GPU thread in-process, avoid optimistically starting it
   // since creating the GPU thread races against creation of the one-and-only
   // ChildProcess instance which is created by the renderer thread.
   GpuDataManager* gpu_data_manager = content::GpuDataManager::GetInstance();
   if (gpu_data_manager->GpuAccessAllowed() &&
       !parsed_command_line_.HasSwitch(switches::kDisableGpuProcessPrelaunch) &&
       !parsed_command_line_.HasSwitch(switches::kSingleProcess) &&
       !parsed_command_line_.HasSwitch(switches::kInProcessGPU)) {
     TRACE_EVENT_INSTANT0("gpu", "Post task to launch GPU process");
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE, base::Bind(
             base::IgnoreResult(&GpuProcessHost::Get),
             GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
             content::CAUSE_FOR_GPU_LAUNCH_BROWSER_STARTUP));
   }
+#endif  // !defined(OS_IOS)
 
   // If the UI thread blocks, the whole UI is unresponsive.
   // Do not allow disk IO from the UI thread.
   base::ThreadRestrictions::SetIOAllowed(false);
   base::ThreadRestrictions::DisallowWaiting();
 }
 
 void BrowserMainLoop::RunMainMessageLoopParts() {
   TRACE_EVENT_BEGIN_ETW("BrowserMain:MESSAGE_LOOP", 0, "");
 
@@ skipping 12 matching lines @@
   // need to be able to perform IO.
   base::ThreadRestrictions::SetIOAllowed(true);
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(base::IgnoreResult(&base::ThreadRestrictions::SetIOAllowed),
                  true));
 
   if (parts_.get())
     parts_->PostMainMessageLoopRun();
 
+#if !defined(OS_IOS)
   // Destroying the GpuProcessHostUIShims on the UI thread posts a task to
   // delete related objects on the GPU thread. This must be done before
   // stopping the GPU thread. The GPU thread will close IPC channels to renderer
   // processes so this has to happen before stopping the IO thread.
   GpuProcessHostUIShim::DestroyAll();
 
   // Cancel pending requests and prevent new requests.
   if (resource_dispatcher_host_.get())
     resource_dispatcher_host_.get()->Shutdown();
 
 #if defined(USE_AURA)
   ImageTransportFactory::Terminate();
 #endif
   BrowserGpuChannelHostFactory::Terminate();
 
   GamepadService::GetInstance()->Terminate();
 
   // The device monitors are using |system_monitor_| as dependency, so delete
   // them before |system_monitor_| goes away.
   // On Mac and windows, the monitor needs to be destroyed on the same thread
   // as they were created. On Linux, the monitor will be deleted when IO thread
   // goes away.
 #if defined(OS_WIN)
   system_message_window_.reset();
 #elif defined(OS_MACOSX)
   device_monitor_mac_.reset();
 #endif
+#endif  // !defined(OS_IOS)
 
   // Must be size_t so we can subtract from it.
   for (size_t thread_id = BrowserThread::ID_COUNT - 1;
        thread_id >= (BrowserThread::UI + 1);
        --thread_id) {
     // Find the thread object we want to stop. Looping over all valid
     // BrowserThread IDs and DCHECKing on a missing case in the switch
     // statement helps avoid a mismatch between this code and the
     // BrowserThread::ID enumeration.
     //
@@ skipping 27 matching lines @@
         // Need to destroy ResourceDispatcherHost before PluginService
         // and since it caches a pointer to it.
         resource_dispatcher_host_.reset();
         break;
       case BrowserThread::FILE_USER_BLOCKING:
         thread_to_stop = &file_user_blocking_thread_;
         break;
       case BrowserThread::FILE:
         thread_to_stop = &file_thread_;
 
+#if !defined(OS_IOS)
         // Clean up state that lives on or uses the file_thread_ before
         // it goes away.
         if (resource_dispatcher_host_.get()) {
           resource_dispatcher_host_.get()->download_file_manager()->Shutdown();
           resource_dispatcher_host_.get()->save_file_manager()->Shutdown();
         }
+#endif  // !defined(OS_IOS)
         break;
       case BrowserThread::PROCESS_LAUNCHER:
         thread_to_stop = &process_launcher_thread_;
         break;
       case BrowserThread::CACHE:
         thread_to_stop = &cache_thread_;
         break;
       case BrowserThread::IO:
         thread_to_stop = &io_thread_;
         break;
       case BrowserThread::UI:
       case BrowserThread::ID_COUNT:
       default:
         NOTREACHED();
         break;
     }
 
     BrowserThread::ID id = static_cast<BrowserThread::ID>(thread_id);
 
     if (id == BrowserThread::WEBKIT_DEPRECATED) {
+#if !defined(OS_IOS)
       webkit_thread_.reset();
+#endif
     } else if (thread_to_stop) {
       thread_to_stop->reset();
     } else {
       NOTREACHED();
     }
   }
 
   // Close the blocking I/O pool after the other threads. Other threads such
   // as the I/O thread may need to schedule work like closing files or flushing
   // data during shutdown, so the blocking pool needs to be available. There
@@ skipping 12 matching lines @@
   if (main_message_loop_.get())
     main_message_loop_->set_thread_name(kThreadName);
 
   // Register the main thread by instantiating it, but don't call any methods.
   main_thread_.reset(new BrowserThreadImpl(BrowserThread::UI,
                                            MessageLoop::current()));
 }
 
 
 void BrowserMainLoop::BrowserThreadsStarted() {
+#if !defined(OS_IOS)
   HistogramSynchronizer::GetInstance();
 
   content::BrowserGpuChannelHostFactory::Initialize();
 #if defined(USE_AURA)
   ImageTransportFactory::Initialize();
 #endif
 
 #if defined(OS_LINUX)
   device_monitor_linux_.reset(new DeviceMonitorLinux());
 #elif defined(OS_MACOSX)
   device_monitor_mac_.reset(new DeviceMonitorMac());
 #endif
 
   // RDH needs the IO thread to be created.
   resource_dispatcher_host_.reset(new ResourceDispatcherHostImpl());
 
+  // Start the GpuDataManager before we set up the MessageLoops because
+  // otherwise we'll trigger the assertion about doing IO on the UI thread.
+  content::GpuDataManager::GetInstance();
+#endif  // !OS_IOS
+
 #if defined(ENABLE_INPUT_SPEECH)
   speech_recognition_manager_.reset(new speech::SpeechRecognitionManagerImpl());
 #endif
-
-  // Start the GpuDataManager before we set up the MessageLoops because
-  // otherwise we'll trigger the assertion about doing IO on the UI thread.
-  content::GpuDataManager::GetInstance();
 }
 
 void BrowserMainLoop::InitializeToolkit() {
   // TODO(evan): this function is rather subtle, due to the variety
   // of intersecting ifdefs we have.  To keep it easy to follow, there
   // are no #else branches on any #ifs.
   // TODO(stevenjb): Move platform specific code into platform specific Parts
   // (Need to add InitializeToolkit stage to BrowserParts).
 #if defined(OS_LINUX) || defined(OS_OPENBSD)
   // Glib type system initialization. Needed at least for gconf,
@@ skipping 37 matching lines @@
   DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
   if (parameters_.ui_task)
     MessageLoopForUI::current()->PostTask(FROM_HERE, *parameters_.ui_task);
 
   base::RunLoop run_loop;
   run_loop.Run();
 #endif
 }
 
 }  // namespace content