[ozone] Temporary workaround for GPU support message filter not being installed early enough.

ui/ozone/platform/dri/dri_gpu_platform_support.cc

 // Copyright 2014 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 "ui/ozone/platform/dri/dri_gpu_platform_support.h"
 
 #include "base/bind.h"
 #include "base/thread_task_runner_handle.h"
 #include "ipc/ipc_message_macros.h"
 #include "ui/display/types/display_mode.h"
@@ skipping 16 matching lines @@
 }
 
 class DriGpuPlatformSupportMessageFilter : public IPC::MessageFilter {
  public:
   DriGpuPlatformSupportMessageFilter(DriWindowDelegateManager* window_manager,
                                      IPC::Listener* main_thread_listener)
       : window_manager_(window_manager),
         main_thread_listener_(main_thread_listener),
         main_thread_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         pending_main_thread_operations_(0),
-        cursor_animating_(false) {}
+        cursor_animating_(false),
+        start_on_main_(true) {}
 
   void OnFilterAdded(IPC::Sender* sender) override {
     io_thread_task_runner_ = base::ThreadTaskRunnerHandle::Get();
   }
 
   // This code is meant to be very temporary and only as a special case to fix
   // cursor movement jank resulting from slowdowns on the gpu main thread.
   // It handles cursor movement on IO thread when display config is stable
   // and returns it to main thread during transitions.
   bool OnMessageReceived(const IPC::Message& message) override {
     // If this message affects the state needed to set cursor, handle it on
     // the main thread. If a cursor move message arrives but we haven't
     // processed the previous main thread message, keep processing on main
     // until nothing is pending.
     bool cursor_position_message = MessageAffectsCursorPosition(message.type());
     bool cursor_state_message = MessageAffectsCursorState(message.type());
 
     // Only handle cursor related messages here.
     if (!cursor_position_message && !cursor_state_message)
       return false;
 
     bool cursor_was_animating = cursor_animating_;
     UpdateAnimationState(message);
     if (cursor_state_message || pending_main_thread_operations_ ||
-        cursor_animating_ || cursor_was_animating) {
+        cursor_animating_ || cursor_was_animating || start_on_main_) {
+      start_on_main_ = false;
       pending_main_thread_operations_++;
 
       base::Closure main_thread_message_handler =
           base::Bind(base::IgnoreResult(&IPC::Listener::OnMessageReceived),
                      base::Unretained(main_thread_listener_), message);
       main_thread_task_runner_->PostTask(FROM_HERE,
                                          main_thread_message_handler);
 
       // This is an echo from the main thread to decrement pending ops.
       // When the main thread is done with the task, it posts back to IO to
@@ skipping 71 matching lines @@
     int frame_delay_ms = get<3>(param);
     cursor_animating_ = frame_delay_ms != 0;
   }
 
   DriWindowDelegateManager* window_manager_;
   IPC::Listener* main_thread_listener_;
   scoped_refptr<base::SingleThreadTaskRunner> main_thread_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> io_thread_task_runner_;
   int32 pending_main_thread_operations_;
   bool cursor_animating_;
+  // The filter is not installed early enough, so some messages may
+  // get routed to main thread. Once we get our first message on io, send it
+  // to main to ensure all prior main thread operations are finished before we
+  // continue on io.
+  // TODO: remove this once filter is properly installed.
+  bool start_on_main_;
 };
 }
 
 DriGpuPlatformSupport::DriGpuPlatformSupport(
     DriWrapper* drm,
     DriWindowDelegateManager* window_manager,
     ScreenManager* screen_manager,
     scoped_ptr<NativeDisplayDelegateDri> ndd)
     : sender_(NULL),
       drm_(drm),
@@ skipping 175 matching lines @@
 void DriGpuPlatformSupport::RelinquishGpuResources(
     const base::Closure& callback) {
   callback.Run();
 }
 
 IPC::MessageFilter* DriGpuPlatformSupport::GetMessageFilter() {
   return filter_.get();
 }
 
 }  // namespace ui