gpu: Use mojom API for recording log messages to the host.

content/gpu/gpu_child_thread.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/gpu/gpu_child_thread.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
-#include "base/lazy_instance.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/thread_local.h"
-#include "base/threading/thread_task_runner_handle.h"
 #include "base/threading/worker_pool.h"
 #include "build/build_config.h"
 #include "content/child/child_process.h"
 #include "content/child/thread_safe_sender.h"
 #include "content/common/gpu_host_messages.h"
 #include "content/gpu/gpu_service_factory.h"
 #include "content/public/common/content_client.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/service_manager_connection.h"
 #include "content/public/gpu/content_gpu_client.h"
@@ skipping 24 matching lines @@
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
 #if defined(OS_ANDROID)
 #include "media/base/android/media_client_android.h"
 #endif
 
 namespace content {
 namespace {
 
-static base::LazyInstance<scoped_refptr<ThreadSafeSender>>::DestructorAtExit
-    g_thread_safe_sender = LAZY_INSTANCE_INITIALIZER;
-
-bool GpuProcessLogMessageHandler(int severity,
-                                 const char* file, int line,
-                                 size_t message_start,
-                                 const std::string& str) {
-  std::string header = str.substr(0, message_start);
-  std::string message = str.substr(message_start);
-
-  g_thread_safe_sender.Get()->Send(
-      new GpuHostMsg_OnLogMessage(severity, header, message));
-
-  return false;
-}
-
 // Message filter used to to handle GpuMsg_CreateGpuMemoryBuffer messages
 // on the IO thread. This allows the UI thread in the browser process to remain
 // fast at all times.
 class GpuMemoryBufferMessageFilter : public IPC::MessageFilter {
  public:
   explicit GpuMemoryBufferMessageFilter(
       gpu::GpuMemoryBufferFactory* gpu_memory_buffer_factory)
       : gpu_memory_buffer_factory_(gpu_memory_buffer_factory),
         sender_(nullptr) {}
 
@@ skipping 70 matching lines @@
       in_browser_process_(false),
       gpu_service_(new ui::GpuService(gpu_info,
                                       std::move(watchdog_thread),
                                       gpu_memory_buffer_factory,
                                       ChildProcess::current()->io_task_runner(),
                                       gpu_feature_info)),
       gpu_main_binding_(this) {
 #if defined(OS_WIN)
   target_services_ = NULL;
 #endif
-  g_thread_safe_sender.Get() = thread_safe_sender();
 }
 
 GpuChildThread::GpuChildThread(
     const InProcessChildThreadParams& params,
     const gpu::GPUInfo& gpu_info,
     const gpu::GpuFeatureInfo& gpu_feature_info,
     gpu::GpuMemoryBufferFactory* gpu_memory_buffer_factory)
     : ChildThreadImpl(ChildThreadImpl::Options::Builder()
                           .InBrowserProcess(params)
                           .AddStartupFilter(new GpuMemoryBufferMessageFilter(
                               gpu_memory_buffer_factory))
                           .ConnectToBrowser(true)
                           .Build()),
       dead_on_arrival_(false),
       gpu_info_(gpu_info),
       in_browser_process_(true),
       gpu_service_(new ui::GpuService(gpu_info,
                                       nullptr /* watchdog thread */,
                                       gpu_memory_buffer_factory,
                                       ChildProcess::current()->io_task_runner(),
                                       gpu_feature_info)),
       gpu_main_binding_(this) {
 #if defined(OS_WIN)
   target_services_ = NULL;
 #endif
   DCHECK(base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kSingleProcess) ||
          base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kInProcessGPU));
-
-  g_thread_safe_sender.Get() = thread_safe_sender();
 }
 
 GpuChildThread::~GpuChildThread() {
 }
 
 void GpuChildThread::Shutdown() {
   ChildThreadImpl::Shutdown();
-  logging::SetLogMessageHandler(NULL);
 }
 
 void GpuChildThread::Init(const base::Time& process_start_time) {
   process_start_time_ = process_start_time;
+  gpu_service_->set_in_host_process(in_browser_process_);
 
 #if defined(OS_ANDROID)
   // When running in in-process mode, this has been set in the browser at
   // ChromeBrowserMainPartsAndroid::PreMainMessageLoopRun().
   if (!in_browser_process_)
     media::SetMediaClientAndroid(GetContentClient()->GetMediaClientAndroid());
 #endif
   // We don't want to process any incoming interface requests until
   // OnInitialize() is invoked.
   GetInterfaceRegistry()->PauseBinding();
@@ skipping 73 matching lines @@
       media::GpuJpegDecodeAcceleratorFactoryProvider::
           IsAcceleratedJpegDecodeSupported();
 
   // Record initialization only after collecting the GPU info because that can
   // take a significant amount of time.
   gpu_info_.initialization_time = base::Time::Now() - process_start_time_;
   Send(new GpuHostMsg_Initialized(!dead_on_arrival_, gpu_info_,
                                   gpu_service_->gpu_feature_info()));
   while (!deferred_messages_.empty()) {
     const LogMessage& log = deferred_messages_.front();
-    Send(new GpuHostMsg_OnLogMessage(log.severity, log.header, log.message));
+    gpu_host->RecordLogMessage(log.severity, log.header, log.message);
     deferred_messages_.pop();
   }
 
   if (dead_on_arrival_) {
     LOG(ERROR) << "Exiting GPU process due to errors during initialization";
     base::MessageLoop::current()->QuitWhenIdle();
     return;
   }
 
-  // We don't need to pipe log messages if we are running the GPU thread in
-  // the browser process.
-  if (!in_browser_process_)
-    logging::SetLogMessageHandler(GpuProcessLogMessageHandler);
-
   gpu::SyncPointManager* sync_point_manager = nullptr;
   // Note SyncPointManager from ContentGpuClient cannot be owned by this.
   if (GetContentClient()->gpu())
     sync_point_manager = GetContentClient()->gpu()->GetSyncPointManager();
   gpu_service_->InitializeWithHost(
       std::move(gpu_host), gpu_preferences,
       gpu::GpuProcessActivityFlags(std::move(activity_flags)),
       sync_point_manager, ChildProcess::current()->GetShutDownEvent());
   CHECK(gpu_service_->media_gpu_channel_manager());
 
@@ skipping 91 matching lines @@
 
 void GpuChildThread::BindServiceFactoryRequest(
     service_manager::mojom::ServiceFactoryRequest request) {
   DVLOG(1) << "GPU: Binding service_manager::mojom::ServiceFactoryRequest";
   DCHECK(service_factory_);
   service_factory_bindings_.AddBinding(service_factory_.get(),
                                        std::move(request));
 }
 
 }  // namespace content