WIP HW

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 <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 1087 matching lines @@
   // data during shutdown, so the blocking pool needs to be available. There
   // may also be slow operations pending that will blcok shutdown, so closing
   // it here (which will block until required operations are complete) gives
   // more head start for those operations to finish.
   {
     TRACE_EVENT0("shutdown", "BrowserMainLoop::Subsystem:ThreadPool");
     BrowserThreadImpl::ShutdownThreadPool();
   }
   // Must happen after the IO thread is shutdown since this may be accessed from
   // it.
-  {
+  if (!shell::ShellIsRemote()) {
     TRACE_EVENT0("shutdown", "BrowserMainLoop::Subsystem:GPUChannelFactory");
     if (BrowserGpuChannelHostFactory::instance())
       BrowserGpuChannelHostFactory::Terminate();
   }
 
   // Must happen after the I/O thread is shutdown since this class lives on the
   // I/O thread and isn't threadsafe.
   {
     TRACE_EVENT0("shutdown", "BrowserMainLoop::Subsystem:GamepadService");
     GamepadService::GetInstance()->Terminate();
@@ skipping 33 matching lines @@
 }
 
 int BrowserMainLoop::BrowserThreadsStarted() {
   TRACE_EVENT0("startup", "BrowserMainLoop::BrowserThreadsStarted");
 
   // Bring up Mojo IPC and shell as early as possible.
   mojo_ipc_support_.reset(new mojo::edk::ScopedIPCSupport(
       BrowserThread::UnsafeGetMessageLoopForThread(BrowserThread::IO)
           ->task_runner()));
 
+  if (shell::ShellIsRemote()) {
+    base::CommandLine::ForCurrentProcess()->AppendSwitch(
+        switches::kIsRunningInMojoShell);
+  }
   mojo_shell_context_.reset(new MojoShellContext);
   if (shell::ShellIsRemote()) {
 #if defined(MOJO_SHELL_CLIENT) && defined(USE_AURA)
     // TODO(rockot): Remove the blocking wait for init.
     // http://crbug.com/594852.
     if (MojoShellConnection::GetForProcess())
       WaitForMojoShellInitialize();
 #endif
   }
 
@@ skipping 20 matching lines @@
   bool always_uses_gpu = true;
   bool established_gpu_channel = false;
 #if defined(OS_ANDROID)
   // TODO(crbug.com/439322): This should be set to |true|.
   established_gpu_channel = false;
   always_uses_gpu = ShouldStartGpuProcessOnBrowserStartup();
   BrowserGpuChannelHostFactory::Initialize(established_gpu_channel);
 #elif defined(USE_AURA) || defined(OS_MACOSX)
   established_gpu_channel = true;
   if (!GpuDataManagerImpl::GetInstance()->CanUseGpuBrowserCompositor() ||
-      parsed_command_line_.HasSwitch(switches::kDisableGpuEarlyInit)) {
+      parsed_command_line_.HasSwitch(switches::kDisableGpuEarlyInit) ||
+      shell::ShellIsRemote()) {
     established_gpu_channel = always_uses_gpu = false;
   }
   BrowserGpuChannelHostFactory::Initialize(established_gpu_channel);
   ImageTransportFactory::Initialize();
 #if defined(USE_AURA)
   bool use_mus_in_renderer = false;
 #if defined (MOJO_SHELL_CLIENT)
   use_mus_in_renderer = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUseMusInRenderer);
 #endif  // defined(MOJO_SHELL_CLIENT);
@@ skipping 82 matching lines @@
   // On Windows, clipboards are also used on the FILE or IO threads.
   allowed_clipboard_threads.push_back(file_thread_->GetThreadId());
   allowed_clipboard_threads.push_back(io_thread_->GetThreadId());
 #endif
   ui::Clipboard::SetAllowedThreads(allowed_clipboard_threads);
 
   // 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.
   if (GpuDataManagerImpl::GetInstance()->GpuAccessAllowed(NULL) &&
-      !established_gpu_channel &&
-      always_uses_gpu &&
-      !UsingInProcessGpu()) {
+      !established_gpu_channel && always_uses_gpu && !UsingInProcessGpu() &&
+      !shell::ShellIsRemote()) {
     TRACE_EVENT_INSTANT0("gpu", "Post task to launch GPU process",
                          TRACE_EVENT_SCOPE_THREAD);
     BrowserThread::PostTask(
         BrowserThread::IO, FROM_HERE,
         base::Bind(base::IgnoreResult(&GpuProcessHost::Get),
                    GpuProcessHost::GPU_PROCESS_KIND_SANDBOXED,
                    CAUSE_FOR_GPU_LAUNCH_BROWSER_STARTUP));
   }
 
 #if defined(OS_MACOSX)
@@ skipping 179 matching lines @@
                                                  std::move(worker_task_runner),
                                                  MediaInternals::GetInstance());
   }
   CHECK(audio_manager_);
 
   if (use_hang_monitor)
     media::AudioManager::StartHangMonitor(io_thread_->task_runner());
 }
 
 }  // namespace content