WIP - Gutterless resize on Windows

content/common/gpu/client/gpu_channel_host.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/common/gpu/client/gpu_channel_host.h"
 
 #include <algorithm>
 
 #include "base/atomic_sequence_num.h"
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/posix/eintr_wrapper.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/trace_event/trace_event.h"
 #include "content/common/gpu/client/command_buffer_proxy_impl.h"
 #include "content/common/gpu/client/gpu_jpeg_decode_accelerator_host.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "ipc/ipc_sync_message_filter.h"
 #include "url/gurl.h"
 
 #if defined(OS_WIN) || defined(OS_MACOSX)
 #include "content/public/common/sandbox_init.h"
+#include "ui/base/window_resize_helper.h"
 #endif
 
 using base::AutoLock;
 
 namespace content {
 namespace {
 
 // Global atomic to generate unique transfer buffer IDs.
 base::StaticAtomicSequenceNumber g_next_transfer_buffer_id;
 
@@ skipping 275 matching lines @@
 void GpuChannelHost::DestroyChannel() {
   DCHECK(factory_->IsMainThread());
   AutoLock lock(context_lock_);
   channel_.reset();
 }
 
 void GpuChannelHost::AddRoute(
     int route_id, base::WeakPtr<IPC::Listener> listener) {
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
       factory_->GetIOThreadTaskRunner();
+
+#if defined(OS_MACOSX) || defined(OS_WIN)
+  scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner;
+  if (factory_->IsMainThread()) {
+    // If we're adding a route to the main UI thread, we need to use the
+    // WindowResizeHelper's task runner, otherwise Gpu Channel messages will be
+    // blocked during a resize and we won't recieve the swap complete signal.
+    thread_task_runner = ui::WindowResizeHelper::Get()->task_runner();

[piman, 2015/12/11 07:53:12]

This code (GpuChannelHost) is used by both the renderer and the browser, so it's
not appropriate to always use WindowResizeHelper here.
My suggestion is to have the factory (which is different between the 2 cases)
provide the TaskRunner.

[ericrk, 2015/12/15 00:25:03]

done - good point - was thinking that was what IsMainThread meant, but realize I
misread this.

+  } else {
+    thread_task_runner = base::ThreadTaskRunnerHandle::Get();
+  }
+#else
+  scoped_refptr<base::SingleThreadTaskRunner> thread_task_runner =
+      base::ThreadTaskRunnerHandle::Get();
+#endif
+
   io_task_runner->PostTask(FROM_HERE,
                            base::Bind(&GpuChannelHost::MessageFilter::AddRoute,
                                       channel_filter_.get(), route_id, listener,
-                                      base::ThreadTaskRunnerHandle::Get()));
+                                      thread_task_runner));
 }
 
 void GpuChannelHost::RemoveRoute(int route_id) {
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner =
       factory_->GetIOThreadTaskRunner();
   io_task_runner->PostTask(
       FROM_HERE, base::Bind(&GpuChannelHost::MessageFilter::RemoveRoute,
                             channel_filter_.get(), route_id));
 }
 
@@ skipping 193 matching lines @@
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
 }  // namespace content